hermes-agent/tests/agent/lsp/test_workspace_trust.py
kshitijk4poor da2b64304b fix(lsp): no automatic trust for scheduled work; lock-free trust lookups
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.
2026-09-29 03:28:46 +05:30

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