mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-16 19:36:54 +00:00
Re-review of the trust-anchor follow-up: - Cron runs and Kanban workers no longer anchor trust. The cronjob tool lets the model pick a job's workdir, which becomes the run's session cwd, and kanban_create lets it pick a task workspace, which becomes the worker's launch dir and TERMINAL_CWD. Either one let an agent-cloned repo become trusted. Both now rely on lsp.trusted_workspaces only. - A repository at or above $HOME never anchors, not only one at $HOME exactly. - Operator roots are recorded only where a tool thread enters (enabled_for) and when the service is created. _trusted() is now a pure read. Before, it took _state_lock while two of its callers already held it, so a change in the roots could deadlock the LSP loop. - Client lookups go through _live_key(). A multi-root client that started while its root was untrusted is still found and released after the root becomes trusted, instead of being orphaned. - `hermes lsp status` stops listing roots that have since become trusted. The lint gate reads the cwd the same way the linter subprocess does. - The path-list parser returns None for a malformed value, and each key logs its own warning. The _node_modules_trees docstring no longer mentions Vue.
177 lines
8.6 KiB
Python
177 lines
8.6 KiB
Python
"""Nothing a checkout ships runs unless the operator trusts that workspace.
|
|
|
|
A cloned repository can ship its own ``.venv/bin/python`` (pyright executes the configured
|
|
interpreter), ``node_modules/typescript`` (typescript-language-server loads it), Vue compiler plugins,
|
|
``svelte.config.js``, Rust build scripts and Gradle builds (rust-analyzer, jdtls and
|
|
kotlin-language-server evaluate them), and a ``node_modules/.bin/tsc`` or ``rust-toolchain.toml``
|
|
the post-write shell linters would pick up. Nothing here executes those files: the tests record
|
|
which servers Hermes would start, the configuration it hands them, and the shell commands it runs.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
from types import SimpleNamespace
|
|
|
|
from agent.lsp import manager
|
|
from agent.lsp.servers import UNTRUSTED_SAFE_SERVERS
|
|
from agent.lsp.workspace import clear_cache, is_inside_workspace
|
|
|
|
_SERVERS = {"pyright": "a.py", "typescript": "a.ts", "vue-language-server": "a.vue",
|
|
"svelte-language-server": "a.svelte", "rust-analyzer": "a.rs", "jdtls": "A.java",
|
|
"kotlin-language-server": "a.kt"}
|
|
|
|
|
|
def _write(path, text: str = ""):
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
path.write_text(text, encoding="utf-8")
|
|
return path
|
|
|
|
|
|
def _hermes_side_tree(tmp_path, monkeypatch) -> str:
|
|
"""``<HERMES_HOME>/lsp/node_modules`` with a JS TypeScript SDK and Vue 2.x; returns a launcher inside it."""
|
|
monkeypatch.setenv("HERMES_HOME", str(tmp_path / "home"))
|
|
monkeypatch.delenv("VIRTUAL_ENV", raising=False)
|
|
staging = tmp_path / "home" / "lsp" / "node_modules"
|
|
_write(staging / "typescript" / "lib" / "typescript.js")
|
|
_write(staging / "typescript" / "lib" / "tsserver.js")
|
|
_write(staging / "@vue" / "language-server" / "package.json", json.dumps({"version": "2.2.12"}))
|
|
return str(_write(staging / "server-launcher"))
|
|
|
|
|
|
def _checkout_shipping_its_own_toolchain(root) -> None:
|
|
"""Marker files only: an interpreter, a TypeScript SDK and build files the project brings itself."""
|
|
(root / ".git").mkdir(parents=True)
|
|
_write(root / "pyproject.toml")
|
|
_write(root / ".venv" / "bin" / "python")
|
|
_write(root / ".venv" / "Scripts" / "python.exe")
|
|
_write(root / "node_modules" / "typescript" / "lib" / "typescript.js")
|
|
_write(root / "node_modules" / "typescript" / "lib" / "tsserver.js")
|
|
_write(root / "node_modules" / ".bin" / "tsc")
|
|
_write(root / "Cargo.toml")
|
|
_write(root / "build.rs")
|
|
_write(root / "rust-toolchain.toml")
|
|
_write(root / "build.gradle.kts")
|
|
|
|
|
|
def _strings(value):
|
|
if isinstance(value, str):
|
|
yield value
|
|
elif isinstance(value, dict):
|
|
for v in value.values():
|
|
yield from _strings(v)
|
|
elif isinstance(value, (list, tuple)):
|
|
for v in value:
|
|
yield from _strings(v)
|
|
|
|
|
|
def _record_spawns(tmp_path, monkeypatch, launcher, roots, *, trusted_workspaces=()):
|
|
"""Config → service → spawn for every ``_SERVERS`` file in every root, cwd inside ``tmp/launch``.
|
|
Returns ``{(server_id, root): initialization_options}`` for the servers Hermes would start, and the status."""
|
|
_write(tmp_path / "home" / "config.yaml", json.dumps({"lsp": {
|
|
"trusted_workspaces": [str(p) for p in trusted_workspaces],
|
|
"servers": {sid: {"command": [launcher]} for sid in _SERVERS},
|
|
}}))
|
|
(tmp_path / "launch" / "src").mkdir(parents=True, exist_ok=True)
|
|
monkeypatch.chdir(tmp_path / "launch" / "src")
|
|
clear_cache()
|
|
handed = {}
|
|
|
|
class _RecordingClient:
|
|
def __init__(self, *, server_id, workspace_root, initialization_options, **_):
|
|
handed[(server_id, workspace_root)] = initialization_options
|
|
|
|
async def start(self):
|
|
raise RuntimeError("recorded, not started")
|
|
|
|
monkeypatch.setattr(manager, "LSPClient", _RecordingClient)
|
|
svc = manager.LSPService.create_from_config()
|
|
try:
|
|
for root in roots:
|
|
for name in _SERVERS.values():
|
|
svc._loop.run(svc._get_or_spawn(str(_write(root / name))), timeout=10)
|
|
status = svc.get_status()
|
|
finally:
|
|
svc.shutdown()
|
|
return handed, status
|
|
|
|
|
|
def test_untrusted_checkout_starts_only_allowlisted_servers_pinned_to_hermes_code(tmp_path, monkeypatch):
|
|
launcher = _hermes_side_tree(tmp_path, monkeypatch)
|
|
launch, clone = tmp_path / "launch", tmp_path / "elsewhere" / "clone"
|
|
for root in (launch, clone):
|
|
_checkout_shipping_its_own_toolchain(root)
|
|
handed, status = _record_spawns(tmp_path, monkeypatch, launcher, (launch, clone))
|
|
|
|
untrusted = {sid: init for (sid, root), init in handed.items() if root == str(clone)}
|
|
# Deny by default: servers that evaluate build files (cargo, Gradle) never start in the clone.
|
|
assert set(untrusted) == set(_SERVERS) & UNTRUSTED_SAFE_SERVERS
|
|
assert {("rust-analyzer", str(clone)), ("jdtls", str(clone)), ("vue-language-server", str(clone))} \
|
|
<= set(status["untrusted_skipped"])
|
|
for sid, init in untrusted.items():
|
|
leaked = [s for s in _strings(init) if os.path.isabs(s) and is_inside_workspace(s, str(clone))]
|
|
assert not leaked, (sid, leaked)
|
|
# Allowlisted servers that would fall back to project code by themselves are told not to.
|
|
assert os.path.isfile(os.path.join(untrusted["typescript"]["tsserver"]["path"], "tsserver.js"))
|
|
assert untrusted["svelte-language-server"]["isTrusted"] is False
|
|
|
|
# The launch worktree is trusted: every server starts, pyright gets the project interpreter back.
|
|
trusted = {sid: init for (sid, root), init in handed.items() if root == str(launch)}
|
|
assert set(trusted) == set(_SERVERS)
|
|
assert is_inside_workspace(trusted["pyright"]["python"]["pythonPath"], str(launch / ".venv"))
|
|
assert all(trusted[sid] == {} for sid in ("typescript", "svelte-language-server", "rust-analyzer"))
|
|
|
|
|
|
def test_only_operator_workspaces_and_listed_directories_are_trusted(tmp_path, monkeypatch):
|
|
"""The same trust decision gates the servers and the post-write shell linters that use the repo's toolchain."""
|
|
launcher = _hermes_side_tree(tmp_path, monkeypatch)
|
|
launch, listed = tmp_path / "launch", tmp_path / "listed" / "proj"
|
|
nested, sibling = launch / "vendor" / "clone", tmp_path / "elsewhere" / "clone"
|
|
roots = (launch, nested, sibling, listed)
|
|
for root in roots:
|
|
_checkout_shipping_its_own_toolchain(root)
|
|
handed, _ = _record_spawns(tmp_path, monkeypatch, launcher, roots, trusted_workspaces=[tmp_path / "listed"])
|
|
|
|
from tools.environments.local import LocalEnvironment
|
|
from tools.file_operations import ShellFileOperations
|
|
fops = ShellFileOperations(LocalEnvironment(cwd=str(launch / "src")))
|
|
ran = []
|
|
monkeypatch.setattr(fops, "_exec", lambda cmd, **_: ran.append(cmd) or SimpleNamespace(exit_code=0, stdout=""))
|
|
monkeypatch.setattr(fops, "_run_managed_node_linter", lambda ext, path: ran.append(path) or SimpleNamespace(exit_code=0, stdout=""))
|
|
monkeypatch.setattr(fops, "_has_command", lambda _cmd: True)
|
|
monkeypatch.setattr(fops, "_lsp_will_handle", lambda _path: False)
|
|
|
|
def shell_linted(root):
|
|
"""``npx tsc`` / rustup resolve the toolchain from the linter's cwd: the agent has ``cd``'d into ``root``."""
|
|
ran.clear()
|
|
fops.env.cwd = str(root)
|
|
for name in ("a.ts", "a.rs"):
|
|
fops._check_lint(str(root / name))
|
|
return len(ran)
|
|
|
|
for root in (launch, listed):
|
|
assert is_inside_workspace(handed[("pyright", str(root))]["python"]["pythonPath"], str(root / ".venv"))
|
|
assert ("rust-analyzer", str(root)) in handed
|
|
assert shell_linted(root) == 2, root
|
|
for root in (nested, sibling):
|
|
assert not is_inside_workspace(handed[("pyright", str(root))].get("python", {}).get("pythonPath", ""), str(root)), root
|
|
assert ("rust-analyzer", str(root)) not in handed
|
|
assert shell_linted(root) == 0, root
|
|
|
|
# The workspace a surface points the session at is the operator's too (hermes -w, a Desktop project)...
|
|
monkeypatch.setenv("TERMINAL_CWD", str(sibling))
|
|
assert shell_linted(sibling) == 2
|
|
# ...but not one the model scheduled: a cron job's workdir or a kanban task's workspace...
|
|
from gateway.session_context import clear_session_vars, set_session_vars
|
|
tokens = set_session_vars(cron_session="1")
|
|
try:
|
|
assert shell_linted(sibling) == 0
|
|
finally:
|
|
clear_session_vars(tokens)
|
|
monkeypatch.setenv("HERMES_KANBAN_TASK", "t_1")
|
|
assert shell_linted(sibling) == 0
|
|
monkeypatch.delenv("HERMES_KANBAN_TASK")
|
|
# ...and never $HOME: a dotfiles repo there would trust every directory below it.
|
|
monkeypatch.setenv("HOME", str(sibling))
|
|
monkeypatch.setenv("USERPROFILE", str(sibling))
|
|
assert shell_linted(sibling) == 0
|