shell.exec runs on the gateway host, so the owner keeps refusing it for a
session whose frozen terminal backend is a sandbox. The refusal now carries
field=terminal.backend and detail=<backend>, and Ink renders it as a sentence
that names the backend and says to ask the agent instead, for both !cmd and
{!cmd}. Local sessions still run. An older gateway (no detail) still gets the
"ask the agent" wording.
Refs #134889 (TUI-16)
Refs #141321
76 lines
3.8 KiB
Python
76 lines
3.8 KiB
Python
"""Ink ``!cmd`` runs for its own local session, in that session's directory (dokterdok N22)."""
|
|
import json
|
|
from pathlib import Path
|
|
import subprocess
|
|
import sys
|
|
|
|
import pytest
|
|
|
|
from tests.gateway.fixtures.local_recovery_probe import child_env
|
|
|
|
|
|
@pytest.mark.platforms("posix")
|
|
def test_shell_exec_runs_in_the_session_cwd_behind_the_safety_gates(tmp_path):
|
|
"""The owner serves ``shell.exec`` with the ``session_id`` Ink sends: the command runs in the
|
|
session's frozen launch cwd (not the daemon's), its exit code and output come back, the
|
|
owner's credentials are scrubbed from the child, and a dangerous or sessionless command is
|
|
refused."""
|
|
root = Path(__file__).resolve().parents[2]
|
|
home, user = tmp_path / 'state', tmp_path / 'user'
|
|
home.mkdir()
|
|
user.mkdir()
|
|
env = child_env()
|
|
env.update(HOME=str(user), USERPROFILE=str(user), HERMES_HOME=str(home),
|
|
PYTHONPATH=str(root), PYTHONUNBUFFERED='1')
|
|
result = subprocess.run([sys.executable, str(root / 'tests/gateway/fixtures/shell_exec_peer.py')],
|
|
cwd=root, env=env, capture_output=True, text=True, timeout=90, check=False)
|
|
assert result.returncode == 0, result.stdout + result.stderr
|
|
receipt = json.loads((home / 'receipt.json').read_text())
|
|
assert receipt['owner_cwd'] != receipt['session_cwd']
|
|
ran = receipt['ran']
|
|
assert isinstance(ran, dict) and ran.get('code') == 3, receipt
|
|
assert Path(ran['stdout'].strip()).resolve() == Path(receipt['session_cwd']).resolve(), receipt
|
|
assert ran['stderr'] == 'key=', receipt
|
|
assert receipt['dangerous'].get('message') == 'dangerous_command', receipt
|
|
assert receipt['sessionless'] == 4001, receipt
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize('backend', ['docker', 'ssh'])
|
|
async def test_shell_exec_refusal_names_a_sandboxed_terminal_backend(tmp_path, monkeypatch, backend):
|
|
"""``shell.exec`` runs on the gateway host, so a session whose frozen terminal policy is a
|
|
sandbox is refused (#134889 TUI-16) and the refusal names that backend for the client. A local
|
|
session still runs. Monkeypatched: the session's policy lookup and local-source check."""
|
|
from types import SimpleNamespace
|
|
|
|
from gateway import session_local, session_policy
|
|
from gateway.session_authority import LiveSession, SessionAuthority
|
|
from gateway.session_controls import AuthorityConnection
|
|
from hermes_state import SessionDB
|
|
from hermes_state_runtime import begin_runtime_epoch
|
|
|
|
work = tmp_path / 'work'
|
|
work.mkdir()
|
|
terminal = {'TERMINAL_ENV': backend}
|
|
monkeypatch.setattr(session_local, 'authorize_local_source', lambda runner, source: True)
|
|
monkeypatch.setattr(session_policy, 'policy_for_source', lambda runner, source: SimpleNamespace(
|
|
cwd=str(work), terminal_json=json.dumps(terminal)))
|
|
with SessionDB(db_path=tmp_path / 'state.db') as db:
|
|
db.create_session('s', source='test')
|
|
epoch = begin_runtime_epoch(db, instance_id='current')
|
|
authority = SessionAuthority(SimpleNamespace(_draining=False), profile_id=str(tmp_path / 'home'),
|
|
instance_id='current', db=db, epoch=epoch)
|
|
authority.sessions['s'] = LiveSession(None, 'route')
|
|
connection = AuthorityConnection(authority, object(), {'user_id': 'owner'})
|
|
|
|
async def call():
|
|
return await connection.dispatch({'id': 1, 'method': 'shell.exec',
|
|
'params': {'session_id': 's', 'command': 'echo ran'}})
|
|
|
|
refused = await call()
|
|
assert refused['error']['data'] == {'reason': 'unsupported_terminal_backend',
|
|
'field': 'terminal.backend', 'detail': backend}, refused
|
|
terminal['TERMINAL_ENV'] = 'local'
|
|
ran = await call()
|
|
assert ran.get('result', {}).get('stdout', '').strip() == 'ran', ran
|