Skip to content

The agent that grows with you

14.3 KB
Raw Blame
"""Private discovery must not assume another process shares its temp root."""
import json
import socket
import tempfile
import threading
from pathlib import Path

import pytest

from gateway.control_socket import _home_hash
from hermes_cli.gateway_runtime_discovery import DiscoveryError, home_mode_unsafe, query_identify


def _ready_owner_payload(home):
    return {
        "runtime_protocol": 1,
        "state": "ready",
        "served_profiles": [{"home": str(home), "profile_id": str(home)}],
        "capabilities": ["session-authority-v1"],
        "authority_epoch": 1,
        "instance_id": "owner",
        "api_origin": "http://127.0.0.1:8765",
        "supervisor": "none",
    }


@pytest.mark.platforms("linux", "macos")
def test_discovery_resolves_a_private_overlay_lock_to_its_owner(tmp_path, monkeypatch):
    """ACP task homes share the served profile's lock instead of publishing a socket of their own."""
    import hermes_cli.gateway_runtime as runtime
    import hermes_cli.gateway_runtime_discovery as discovery

    owner = tmp_path / "owner"
    overlay = tmp_path / "task-home"
    owner.mkdir(mode=0o700)
    overlay.mkdir(mode=0o700)
    lock = owner / "gateway.lock"
    lock.touch(mode=0o600)
    (overlay / "gateway.lock").symlink_to(lock)
    queried = []

    def identify(home, *, timeout):
        queried.append(home)
        return _ready_owner_payload(owner)

    monkeypatch.setattr(discovery, "query_identify", identify)
    result = runtime.discover_gateway_endpoint(overlay)

    assert result.state == "ready"
    assert result.endpoint is not None and result.endpoint.profile_id == str(owner)
    assert queried == [owner]

    checked = []

    def ready(home, *, timeout):
        checked.append(home)
        return runtime.GatewayDiscovery("ready")

    monkeypatch.setattr(runtime, "discover_gateway_endpoint", ready)
    assert runtime.ensure_gateway_runtime(overlay).state == "ready"
    assert checked == [owner]


@pytest.mark.platforms("linux", "macos")
def test_discovery_does_not_follow_an_overlay_lock_from_a_writable_home(tmp_path, monkeypatch):
    """A task directory another user can replace must not select a gateway owner."""
    from hermes_cli.gateway_runtime import discover_gateway_endpoint
    import hermes_cli.gateway_runtime_discovery as discovery

    owner = tmp_path / "owner"
    overlay = tmp_path / "task-home"
    owner.mkdir(mode=0o700)
    overlay.mkdir(mode=0o700)
    overlay.chmod(0o707)
    lock = owner / "gateway.lock"
    lock.touch(mode=0o600)
    (overlay / "gateway.lock").symlink_to(lock)
    queried = []

    def identify(home, *, timeout):
        queried.append(home)
        return _ready_owner_payload(owner)

    monkeypatch.setattr(discovery, "query_identify", identify)
    result = discover_gateway_endpoint(overlay)

    assert result.state == "inaccessible"
    assert queried == [overlay]


@pytest.mark.platforms("linux")
def test_fallback_pointer_uses_owner_location_and_keeps_identity_checks(tmp_path):
    home = tmp_path / 'profile'
    home.mkdir(mode=0o700)
    # The owner has a distinct TMPDIR, as a service or native app commonly does.
    with tempfile.TemporaryDirectory(prefix='h-owner-') as root:
        directory = Path(root) / f'hermes-gw-{_home_hash(home)}'
        directory.mkdir(mode=0o700)
        target = directory / 'control.sock'
        pointer = home / 'gateway.sock.path'
        pointer.write_text(str(target), encoding='utf-8')
        pointer.chmod(0o600)
        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as server:
            server.bind(str(target))
            target.chmod(0o600)
            server.listen(1)
            server.settimeout(3)
            requests = []

            def respond():
                try:
                    peer, _ = server.accept()
                    with peer:
                        requests.append(peer.recv(4096))
                        peer.sendall(b'{"ok":true,"protocol":1,"id":1,"result":{"state":"ready"}}\n')
                except TimeoutError:
                    return

            thread = threading.Thread(target=respond)
            thread.start()
            try:
                assert query_identify(home, timeout=2) == {'state': 'ready'}
            finally:
                thread.join(timeout=4)
            assert json.loads(requests[0])['verb'] == 'identify'
            pointer.write_text(str(directory.with_name('hermes-gw-wrong') / 'control.sock'), encoding='utf-8')
            with pytest.raises(DiscoveryError, match='invalid_control_pointer'):
                query_identify(home, timeout=2)
            pointer.write_text(str(target), encoding='utf-8')
            directory.chmod(0o755)
            with pytest.raises(DiscoveryError, match='unsafe_control_permissions'):
                query_identify(home, timeout=2)


@pytest.mark.platforms("linux", "macos")
def test_the_client_verdict_names_the_unsafe_node_and_its_fix(monkeypatch, request):
    """``Gateway inaccessible: <code> (<detail>)`` is what a client prints (``connect_gateway``): the
    detail must survive discovery and ensure, with the code unchanged for callers that match it."""
    import os
    import shutil
    from hermes_cli.gateway_runtime import discover_gateway_endpoint, ensure_gateway_runtime
    # A short root: the socket path must fit AF_UNIX's limit.
    root = Path(tempfile.mkdtemp(prefix='h-'))
    request.addfinalizer(lambda: shutil.rmtree(root, ignore_errors=True))
    home = root / 'h'
    home.mkdir(mode=0o700)
    control = home / 'gateway.sock'
    # Discovery names the canonical home, the path a chmod/chown must act on: on macOS the temp
    # root sits under /var, a symlink to /private/var, so the caller's spelling is not what it prints.
    shown, shown_control = home.resolve(), home.resolve() / 'gateway.sock'
    control.write_text('not a socket', encoding='utf-8')
    verdict = ensure_gateway_runtime(home, timeout=2)
    assert (verdict.state, verdict.reason_code) == ('inaccessible', 'unsafe_control_path')
    detail = verdict.detail or ''
    assert f'{shown_control} is -rw' in detail and 'expected socket' in detail, verdict

    control.unlink()
    with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as server:
        server.bind(str(control))
        control.chmod(0o660)
        verdict = discover_gateway_endpoint(home)
        assert verdict.reason_code == 'unsafe_control_permissions'
        assert verdict.detail == f'{shown_control} has mode 0660, expected 0600; chmod 600 {shown_control}', verdict
    control.unlink()

    home.chmod(0o757)
    verdict = discover_gateway_endpoint(home)
    assert verdict.reason_code == 'unsafe_control_permissions'
    assert verdict.detail == (f'{shown} has mode 0757, writable by another user; chmod go-w {shown}'), verdict
    home.chmod(0o700)

    owner = home.lstat().st_uid
    monkeypatch.setattr(os, 'getuid', lambda: owner + 1)
    verdict = discover_gateway_endpoint(home)
    assert verdict.reason_code == 'unsafe_control_path'
    assert verdict.detail == (f'{shown} is owned by uid {owner}, expected uid {owner + 1} (gateway user); '
                              'chown it to the gateway user'), verdict


@pytest.mark.platforms("linux", "macos")
def test_hermes_chat_prints_the_whole_repair_command(monkeypatch, request):
    """``hermes chat`` shows a failed attach through ``agent_init_failure_message``, whose 120-character
    summary cut the hint mid-path: the whole command must reach the user."""
    import asyncio
    import shutil
    from hermes_cli.cli_chat_error_copy import agent_init_failure_message
    from hermes_cli.gateway_client import GatewayUnavailableError, connect_gateway
    root = Path(tempfile.mkdtemp(prefix='h-'))
    request.addfinalizer(lambda: shutil.rmtree(root, ignore_errors=True))
    home = root / ('profile-' + 'x' * 12)
    home.mkdir(mode=0o700)
    control = home / 'gateway.sock'
    monkeypatch.setenv('HERMES_HOME', str(home))
    monkeypatch.delenv('HERMES_TUI_GATEWAY_URL', raising=False)

    async def attach():
        async with connect_gateway():
            pass

    with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as server:
        server.bind(str(control))
        control.chmod(0o660)
        with pytest.raises(GatewayUnavailableError) as unavailable:
            asyncio.run(attach())
    message = agent_init_failure_message(unavailable.value)
    assert f'chmod 600 {home.resolve() / "gateway.sock"})' in message, message


@pytest.mark.platforms("linux", "macos")
def test_a_long_home_keeps_the_repair_command_whole_or_drops_it(tmp_path):
    """The detail is bounded to 500 characters; a long profile home (named twice: the node and the
    command) must not leave the client printing a chmod cut off mid-path or missing its quote."""
    from hermes_cli.gateway_runtime import discover_gateway_endpoint

    omitted = '; repair command omitted (path too long to print)'
    home = tmp_path.resolve() / ('p' * 200) / "profile's home"
    home.mkdir(parents=True, mode=0o700)
    home.chmod(0o757)
    verdict = discover_gateway_endpoint(home)
    assert verdict.reason_code == 'unsafe_control_permissions'
    assert verdict.detail == f'{home} has mode 0757, writable by another user{omitted}', verdict

    # Too long even without the command: the description is cut with a visible marker.
    deeper = home / ('q' * 250) / ('r' * 100)
    deeper.mkdir(parents=True, mode=0o700)
    deeper.chmod(0o757)
    detail = discover_gateway_endpoint(deeper).detail or ''
    assert len(detail) == 500 and detail.endswith(f'… [truncated]{omitted}'), detail
    assert detail.startswith(str(deeper)[:300]) and 'chmod' not in detail, detail


@pytest.mark.platforms("linux", "macos")
def test_a_permission_hint_runs_as_printed_for_a_path_with_spaces(tmp_path):
    """The hint is a command the user pastes into a shell: a profile home with a space must survive it."""
    import subprocess
    from hermes_cli.gateway_runtime_discovery import _private_node

    home = tmp_path / 'profile home'
    home.mkdir(mode=0o700)
    control = home / 'control file'
    control.write_text('', encoding='utf-8')
    for path, kind, is_home, mode in ((control, 'file', False, 0o660), (home, 'directory', True, 0o702)):
        path.chmod(mode)
        with pytest.raises(DiscoveryError, match='unsafe_control_permissions') as error:
            _private_node(path, kind=kind, home=is_home)
        hint = str(error.value).split('; ', 1)[1]
        ran = subprocess.run(['sh', '-c', hint], capture_output=True, text=True, check=False)
        assert ran.returncode == 0, (hint, ran.stderr)
        _private_node(path, kind=kind, home=is_home)


@pytest.mark.platforms("linux")
def test_an_open_control_directory_names_its_path_and_mode(tmp_path):
    home = tmp_path / 'profile'
    home.mkdir(mode=0o700)
    with tempfile.TemporaryDirectory(prefix='h-owner-') as root:
        directory = Path(root) / f'hermes-gw-{_home_hash(home)}'
        directory.mkdir(mode=0o755)
        pointer = home / 'gateway.sock.path'
        pointer.write_text(str(directory / 'control.sock'), encoding='utf-8')
        pointer.chmod(0o600)
        with pytest.raises(DiscoveryError, match='unsafe_control_permissions') as refused:
            query_identify(home, timeout=2)
        assert refused.value.reason == 'unsafe_control_permissions'
        assert getattr(refused.value, 'detail', None) == f'{directory} has mode 0755, expected 0700; chmod 700 {directory}'


@pytest.mark.platforms("linux", "macos")
def test_home_mode_refuses_only_writes_another_user_can_make(tmp_path, monkeypatch):
    import grp
    import os
    import pwd
    home = tmp_path / 'home'
    home.mkdir()
    user = pwd.getpwuid(os.getuid())
    monkeypatch.setattr(pwd, 'getpwall', lambda: [user])  # no other account on this gid
    private = grp.struct_group((user.pw_name, 'x', user.pw_gid, []))
    shared = grp.struct_group(('staff', 'x', user.pw_gid, [user.pw_name, 'someone-else']))
    for mode, group, unsafe in ((0o700, private, False), (0o755, shared, False), (0o757, private, True),
                                (0o775, private, False), (0o775, shared, True)):
        home.chmod(mode)
        monkeypatch.setattr(grp, 'getgrgid', lambda _gid, g=group: g)
        assert home_mode_unsafe(home.lstat(), home) is unsafe, (oct(mode), group.gr_name)


@pytest.mark.platforms("linux", "macos")
def test_group_write_is_private_only_when_no_other_account_has_that_primary_group(tmp_path, monkeypatch):
    import grp
    import os
    import pwd
    home = tmp_path / 'home'
    home.mkdir()
    home.chmod(0o775)
    user = pwd.getpwuid(os.getuid())
    # gr_mem never lists accounts whose PRIMARY gid is the group: an empty member list
    # with another passwd record on that gid is a shared group, not a private one.
    monkeypatch.setattr(grp, 'getgrgid', lambda _gid: grp.struct_group((user.pw_name, 'x', user.pw_gid, [])))
    other = pwd.struct_passwd(('intruder', 'x', user.pw_uid + 1, user.pw_gid, '', '/', '/bin/sh'))
    monkeypatch.setattr(pwd, 'getpwall', lambda: [user, other])
    assert home_mode_unsafe(home.lstat(), home) is True
    monkeypatch.setattr(pwd, 'getpwall', lambda: [user])
    assert home_mode_unsafe(home.lstat(), home) is False

    def unreadable():
        raise OSError('passwd database unavailable')
    monkeypatch.setattr(pwd, 'getpwall', unreadable)
    assert home_mode_unsafe(home.lstat(), home) is True


@pytest.mark.platforms("linux", "macos")
def test_upgraded_same_owner_0644_lock_is_narrowed_not_inaccessible(tmp_path):
    """Main created gateway.lock with open("a+") under the umask (0644); the inode is never
    replaced, so discovery and reserve must narrow it in place instead of refusing it forever.
    A hardlinked lock (another name shares the inode) is never chmodded."""
    import os
    import stat
    from gateway.runtime_ownership import ProfileOwnership
    from hermes_cli.gateway_runtime_discovery import missing_owner_state
    home = tmp_path / 'profile'
    home.mkdir(mode=0o700)
    lock = home / 'gateway.lock'
    lock.touch()
    lock.chmod(0o644)
    assert missing_owner_state(home) == 'absent'
    assert stat.S_IMODE(lock.stat().st_mode) == 0o600
    lock.chmod(0o644)
    owner = ProfileOwnership()
    owner.reserve([home])
    try:
        assert stat.S_IMODE(lock.stat().st_mode) == 0o600
        assert missing_owner_state(home) == 'starting'
    finally:
        owner.close()
    lock.chmod(0o644)
    os.link(lock, tmp_path / 'alias')
    assert missing_owner_state(home) == 'inaccessible'
    assert stat.S_IMODE(lock.stat().st_mode) == 0o644