mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-16 19:04:08 +03:00
39f22caafe
A shell client's session reads HERMES_EPHEMERAL_SYSTEM_PROMPT, the provider request, the prefill file and the project-plugins opt-in from its client, but its tool subprocesses (terminal, background processes, execute_code) still inherited the gateway daemon's own values, e.g. an operator-started gateway's ephemeral prompt. toolchain_environ now drops those names for a bound session: all four for a local client, and for a client not attached locally the two it takes from its client (prompt, provider request), keeping the daemon's host values that session still uses. Unbound sessions (messaging, cron, Desktop) keep the gateway's environment unchanged. No tool subprocess reads these names; only a nested hermes run from a terminal would, and it now falls back to its own config instead of the daemon's values. Refs #134889 (T3) Refs #139523
229 lines
12 KiB
Python
229 lines
12 KiB
Python
"""T3: a local session's tool subprocesses (terminal, background processes, execute_code) start with
|
|
its client's allowlisted toolchain environment (PATH, an activated venv, nvm/pyenv/conda), not the
|
|
gateway daemon's. Applied to that session only; no full shell snapshot. As on main, the activated venv
|
|
reaches terminal children through PATH: ``VIRTUAL_ENV`` itself stays a stripped runtime marker there."""
|
|
import asyncio
|
|
import os
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
|
|
from tests.tools._child_env_fixtures import child_env, run_code
|
|
|
|
CLIENT = {'PATH': '/client/venv/bin:/usr/bin:/bin', 'VIRTUAL_ENV': '/client/venv', 'NVM_DIR': '/client/.nvm'}
|
|
|
|
|
|
@pytest.fixture
|
|
def daemon_env(monkeypatch):
|
|
monkeypatch.setenv('PATH', '/daemon/bin:/usr/bin:/bin')
|
|
monkeypatch.delenv('VIRTUAL_ENV', raising=False)
|
|
monkeypatch.delenv('NVM_DIR', raising=False)
|
|
|
|
|
|
def _parts(env):
|
|
return env['PATH'].split(os.pathsep)
|
|
|
|
|
|
def test_terminal_run_env_starts_from_the_sessions_toolchain(daemon_env):
|
|
from agent.session_client_env import client_env_scope
|
|
from tools.environments.local import _make_run_env
|
|
with client_env_scope(CLIENT):
|
|
env = _make_run_env({})
|
|
assert '/client/venv/bin' in _parts(env) and '/daemon/bin' not in _parts(env)
|
|
assert env['NVM_DIR'] == '/client/.nvm'
|
|
# The backend's own terminal.env still wins over the client's.
|
|
assert _make_run_env({'NVM_DIR': '/configured'})['NVM_DIR'] == '/configured'
|
|
with client_env_scope({'HERMES_EPHEMERAL_SYSTEM_PROMPT': 'p'}): # behaviour names are not tool env
|
|
assert 'HERMES_EPHEMERAL_SYSTEM_PROMPT' not in _make_run_env({})
|
|
env = _make_run_env({}) # messaging/cron/Desktop: the gateway's own environment
|
|
assert '/daemon/bin' in _parts(env) and 'NVM_DIR' not in env
|
|
|
|
|
|
def test_tool_envs_carry_the_behaviour_values_the_session_uses(daemon_env, monkeypatch, tmp_path):
|
|
"""A shell client's session reads its client's behaviour values, so the daemon's own (an operator's
|
|
ephemeral prompt) never reach its tool subprocesses; a remote client's session still uses the
|
|
daemon's host values (prefill file), and an unbound session (messaging, cron) all of them."""
|
|
import sys
|
|
from agent.session_client_env import BEHAVIOUR_ENV, client_env_scope
|
|
from tools.code_execution_env import _build_child_env
|
|
from tools.environments.local import _make_run_env
|
|
from tools.process_registry import ProcessRegistry
|
|
daemon = {name: f'daemon-{name}' for name in BEHAVIOUR_ENV}
|
|
for name, value in daemon.items():
|
|
monkeypatch.setenv(name, value)
|
|
|
|
def envs():
|
|
return (_make_run_env({}), ProcessRegistry._spawn_env({}),
|
|
_build_child_env(rpc_endpoint='sock', rpc_token='t', tmpdir=str(tmp_path), child_python=sys.executable))
|
|
with client_env_scope({**CLIENT, 'HERMES_EPHEMERAL_SYSTEM_PROMPT': 'client prompt'}):
|
|
for env in envs():
|
|
assert not set(BEHAVIOUR_ENV) & set(env), env
|
|
with client_env_scope(CLIENT, local=False):
|
|
terminal = envs()[0]
|
|
assert 'HERMES_EPHEMERAL_SYSTEM_PROMPT' not in terminal and 'HERMES_INFERENCE_PROVIDER' not in terminal
|
|
assert terminal['HERMES_PREFILL_MESSAGES_FILE'] == daemon['HERMES_PREFILL_MESSAGES_FILE']
|
|
assert envs()[0]['HERMES_EPHEMERAL_SYSTEM_PROMPT'] == daemon['HERMES_EPHEMERAL_SYSTEM_PROMPT']
|
|
|
|
|
|
def test_background_process_env_starts_from_the_sessions_toolchain(daemon_env):
|
|
from agent.session_client_env import client_env_scope
|
|
from tools.process_registry import ProcessRegistry
|
|
with client_env_scope(CLIENT):
|
|
env = ProcessRegistry._spawn_env({})
|
|
assert '/client/venv/bin' in _parts(env) and env['NVM_DIR'] == '/client/.nvm'
|
|
assert '/daemon/bin' in _parts(ProcessRegistry._spawn_env({}))
|
|
|
|
|
|
def test_execute_code_child_env_starts_from_the_sessions_toolchain(daemon_env, tmp_path):
|
|
import sys
|
|
from agent.session_client_env import client_env_scope
|
|
from tools.code_execution_env import _build_child_env
|
|
kwargs = dict(rpc_endpoint='sock', rpc_token='t', tmpdir=str(tmp_path), child_python=sys.executable)
|
|
with client_env_scope(CLIENT):
|
|
env = _build_child_env(**kwargs)
|
|
assert '/client/venv/bin' in _parts(env) and env['VIRTUAL_ENV'] == '/client/venv'
|
|
assert '/daemon/bin' in _parts(_build_child_env(**kwargs))
|
|
|
|
|
|
# execute_code's secret names (BEARER, CREDS, DSN, WEBHOOK...) and Hermes control names never travel, even
|
|
# under a built-in prefix (NODE_, CONDA_) or a profile's configured extra names.
|
|
REFUSED = {'NODE_BEARER': 'b', 'NODE_CREDS': 'c', 'CONDA_DSN': 'postgres://u:p@h/db', 'DEPLOY_WEBHOOK': 'https://h',
|
|
'HERMES_KANBAN_DB': '/board.db', 'HERMES_DELEGATED_CHILD_CONTEXT': '1'}
|
|
|
|
|
|
def test_credential_and_control_names_are_refused_by_execute_codes_secret_policy():
|
|
from agent.session_client_env import accept_client_env, collect_client_env
|
|
config = {'terminal': {'client_env_passthrough': ['DEPLOY_WEBHOOK', 'HERMES_KANBAN_DB', 'MY_TOOLCHAIN_HOME']}}
|
|
sent = {**REFUSED, 'NVM_DIR': '/client/.nvm', 'MY_TOOLCHAIN_HOME': '/opt/tc', 'PATH': '/client/bin'}
|
|
kept = {'NVM_DIR': '/client/.nvm', 'MY_TOOLCHAIN_HOME': '/opt/tc', 'PATH': '/client/bin'}
|
|
assert accept_client_env(sent, config) == kept # the gateway, before anything is stored
|
|
assert collect_client_env(sent, config) == kept # the client, before anything is sent
|
|
|
|
|
|
def test_execute_code_scrubs_after_merging_the_sessions_toolchain(daemon_env, tmp_path):
|
|
"""A bound map (say, one committed before this rule) still cannot carry a secret or a control marker
|
|
into the sandbox; the client's non-secret toolchain names (NVM_DIR) do reach it."""
|
|
import sys
|
|
from agent.session_client_env import client_env_scope
|
|
from tools.code_execution_env import _build_child_env
|
|
with client_env_scope({**CLIENT, **REFUSED}):
|
|
env = _build_child_env(rpc_endpoint='sock', rpc_token='t', tmpdir=str(tmp_path), child_python=sys.executable)
|
|
assert env['NVM_DIR'] == '/client/.nvm' and '/client/venv/bin' in _parts(env)
|
|
assert not set(REFUSED) & set(env)
|
|
|
|
|
|
@pytest.mark.platforms('linux', 'macos')
|
|
@pytest.mark.usefixtures('child_env') # yields tmp_path: an isolated environment for the real kernel
|
|
def test_execute_code_runs_each_sessions_own_interpreter(tmp_path):
|
|
"""Project mode picks the interpreter from the session's toolchain: each client's venv, and for a
|
|
client with no venv the gateway's own Python, never the venv of the client that started the daemon."""
|
|
import sys
|
|
import venv
|
|
from pathlib import Path
|
|
from agent.session_client_env import client_env_scope
|
|
roots = {name: tmp_path / name for name in ('alpha', 'beta', 'daemon')}
|
|
for root in roots.values():
|
|
venv.EnvBuilder(with_pip=False, symlinks=False).create(root)
|
|
os.environ['VIRTUAL_ENV'] = str(roots['daemon']) # inherited from whichever client started the gateway
|
|
probe = 'import json, sys; print(json.dumps([sys.executable, sys.prefix]))'
|
|
|
|
def child(client):
|
|
with client_env_scope(client):
|
|
return [Path(p) for p in run_code(probe)]
|
|
for name in ('alpha', 'beta'):
|
|
exe, prefix = child({'PATH': f'{roots[name] / "bin"}{os.pathsep}{os.environ["PATH"]}',
|
|
'VIRTUAL_ENV': str(roots[name])})
|
|
assert exe == roots[name] / 'bin' / 'python' and prefix.resolve() == roots[name].resolve()
|
|
exe, prefix = child({'PATH': os.environ['PATH']}) # a client with no activated venv
|
|
assert prefix.resolve() == Path(sys.prefix).resolve()
|
|
exe, prefix = child(None) # messaging/cron/Desktop: the gateway's own environment, as before
|
|
assert prefix.resolve() == roots['daemon'].resolve()
|
|
|
|
|
|
async def _owner(home, monkeypatch):
|
|
from gateway import run
|
|
from gateway.config import GatewayConfig
|
|
from gateway.session import SessionStore
|
|
from gateway.session_authority import initialize_session_authority
|
|
from gateway.session_controls import AuthorityConnection
|
|
monkeypatch.setattr(run, '_hermes_home', home)
|
|
monkeypatch.setenv('HERMES_HOME', str(home))
|
|
store = SessionStore(home / 'sessions', GatewayConfig())
|
|
runner = SimpleNamespace(session_store=store, _session_db=store._db, adapters={}, _draining=False,
|
|
_cached_agent_for=lambda route: None, _adapter_for_source=lambda source: None,
|
|
_evict_cached_agent=lambda route: None)
|
|
owner = await initialize_session_authority(runner, profile_id=str(home), instance_id='fixture')
|
|
return owner, AuthorityConnection(owner, object(), {'user_id': 'owner'})
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_a_sessions_terminal_runs_with_its_clients_path(tmp_path, monkeypatch, daemon_env):
|
|
"""Two CLI sessions on one gateway: each terminal command sees its own client's PATH and venv."""
|
|
from gateway.session_local import create_local_session
|
|
from gateway.session_policy import restore_policy
|
|
from hermes_state_local import local_receipt
|
|
home = tmp_path / 'home'
|
|
home.mkdir()
|
|
(home / 'config.yaml').write_text(
|
|
'platform_toolsets: {cli: []}\nmodel: {provider: custom, default: m, base_url: http://x.invalid/v1}\n'
|
|
'terminal: {client_env_passthrough: [MY_TOOLCHAIN_HOME, MY_API_TOKEN]}\n')
|
|
bins = {name: tmp_path / name / 'bin' for name in ('alpha', 'beta')}
|
|
for path in bins.values():
|
|
path.mkdir(parents=True)
|
|
monkeypatch.setenv('PATH', f'/daemon/bin{os.pathsep}{os.environ["PATH"].split(os.pathsep, 1)[-1]}')
|
|
owner, connection = await _owner(home, monkeypatch)
|
|
try:
|
|
policies = {}
|
|
for name, path in bins.items():
|
|
ref = create_local_session(owner, connection.actor, {
|
|
'request_id': name, 'source': 'cli', 'cwd': str(home), 'toolsets': [],
|
|
'client_env': {'PATH': f'{path}{os.pathsep}/usr/bin{os.pathsep}/bin', 'NVM_DIR': str(path.parent),
|
|
'MY_TOOLCHAIN_HOME': f'/opt/{name}', 'MY_API_TOKEN': 'secret', 'UNLISTED': 'x'}},
|
|
client_local=True) # attached through the gateway's own ticket
|
|
policies[name] = restore_policy(local_receipt(owner.db, ref.session_id)['policy'])
|
|
# Listed toolchain names travel; a credential-looking name never lands in the stored policy.
|
|
assert set(policies['alpha'].client_env()) == {'PATH', 'NVM_DIR', 'MY_TOOLCHAIN_HOME'}
|
|
outputs = await asyncio.to_thread(_overlapping_terminal_turns, owner, policies)
|
|
for name, runs in outputs.items():
|
|
for out in runs: # the first command, then again on the cached environment
|
|
path, nvm, toolchain = out.strip().splitlines()[-1].split('|')
|
|
assert str(bins[name]) in path.split(os.pathsep) and '/daemon/bin' not in path.split(os.pathsep)
|
|
assert nvm == str(bins[name].parent) and toolchain == f'/opt/{name}'
|
|
finally:
|
|
from tools.terminal_tool_lifecycle import cleanup_all_environments
|
|
cleanup_all_environments()
|
|
await connection.close()
|
|
owner.db.close()
|
|
|
|
|
|
def _overlapping_terminal_turns(owner, policies):
|
|
"""Each session's turn runs the real terminal entry point (environment cache, shell snapshot)
|
|
with the SAME task id, both turns alive at once, each twice so the second hits the cache."""
|
|
import json
|
|
import threading
|
|
from gateway.session_context import clear_session_vars, set_session_vars
|
|
from gateway.session_policy import policy_scope
|
|
from tools.terminal_tool import terminal_tool
|
|
barrier, outputs, errors = threading.Barrier(len(policies)), {}, []
|
|
|
|
def turn(name, policy):
|
|
tokens = set_session_vars(platform='local', session_key=f'agent:main:local:dm:{name}', session_id=name)
|
|
try:
|
|
with policy_scope(policy, authority=owner):
|
|
command = 'echo "$PATH|$NVM_DIR|$MY_TOOLCHAIN_HOME"'
|
|
first = json.loads(terminal_tool(command, task_id='same-task'))['output']
|
|
barrier.wait(timeout=60) # both sessions now hold a cached environment for 'same-task'
|
|
outputs[name] = (first, json.loads(terminal_tool(command, task_id='same-task'))['output'])
|
|
except Exception as exc: # surfaced below: an assertion in a thread would be lost
|
|
errors.append(exc)
|
|
barrier.abort()
|
|
finally:
|
|
clear_session_vars(tokens)
|
|
threads = [threading.Thread(target=turn, args=item) for item in policies.items()]
|
|
for thread in threads:
|
|
thread.start()
|
|
for thread in threads:
|
|
thread.join(timeout=120)
|
|
assert not errors, errors
|
|
return outputs
|