Import AITURK IDE 1.0.0-beta.1 from Hermes 63279301; preserve MIT license

tests/hermes_cli/test_mcp_helper_ledger.py

@@ -0,0 +1,220 @@
+"""Tests for stdio MCP helper children in the spawn ledger (#61514).
+
+Covers ``register_child`` (the ledger mirror of ``register_self`` for
+subprocesses that never import Hermes code), the live-spawner protection
+contract, dead-spawner reap eligibility through BOTH consumers (the updater's
+``_ledger_reapable_backend_pids`` rung and the startup
+``reap_orphaned_mcp_helpers`` sweep), and prune-on-write of exited children.
+
+Uses REAL subprocesses (``sleep``) and the real psutil so the
+``(pid, create_time)`` identity pair is exercised end-to-end, with the ledger
+redirected to a tmp path.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import time
+from unittest.mock import patch
+
+import psutil
+import pytest
+
+from hermes_cli import process_identity as pi
+
+pytestmark = pytest.mark.skipif(
+    sys.platform == "win32", reason="uses POSIX sleep children"
+)
+
+
+@pytest.fixture
+def ledger(tmp_path):
+    path = tmp_path / pi.LEDGER_FILENAME
+    with patch.object(pi, "_ledger_path", return_value=path):
+        yield path
+
+
+@pytest.fixture
+def child():
+    """A real live child process of THIS test process."""
+    proc = subprocess.Popen(["sleep", "300"])
+    try:
+        yield proc
+    finally:
+        proc.kill()
+        proc.wait()
+
+
+def _dead_process_identity() -> tuple[int, float]:
+    """(pid, create_time) of a real process that is provably dead."""
+    proc = subprocess.Popen(["sleep", "300"])
+    create = psutil.Process(proc.pid).create_time()
+    proc.kill()
+    proc.wait()
+    # Ensure the corpse is fully reaped (no zombie ambiguity).
+    deadline = time.time() + 5
+    while time.time() < deadline and psutil.pid_exists(proc.pid):
+        time.sleep(0.05)
+    return proc.pid, create
+
+
+# ---------------------------------------------------------------------------
+# register_child — entry shape
+# ---------------------------------------------------------------------------
+
+def test_register_child_entry_shape(ledger, child):
+    assert pi.register_child(child.pid, "mcp-helper") is True
+    entries = json.loads(ledger.read_text(encoding="utf-8"))
+    assert len(entries) == 1
+    e = entries[0]
+    assert e["pid"] == child.pid
+    assert e["purpose"] == "mcp-helper"
+    assert e["install"] == pi.install_id()
+    assert e["spawner_pid"] == os.getpid()
+    assert e["spawner_create"] == pytest.approx(
+        psutil.Process(os.getpid()).create_time(), abs=2.0
+    )
+    assert e["create_time"] == pytest.approx(
+        psutil.Process(child.pid).create_time(), abs=2.0
+    )
+    assert e["registered_at"] == pytest.approx(time.time(), abs=30.0)
+    # Visible through the live-verified reader too.
+    live = pi.ledger_entries()
+    assert [x["pid"] for x in live] == [child.pid]
+
+
+def test_register_child_rejects_dead_or_invalid_pids(ledger):
+    dead_pid, _ = _dead_process_identity()
+    assert pi.register_child(dead_pid, "mcp-helper") is False
+    assert pi.register_child(0, "mcp-helper") is False
+    assert pi.register_child(-5, "mcp-helper") is False
+    assert pi.register_child("junk", "mcp-helper") is False  # type: ignore[arg-type]
+    assert not ledger.exists() or json.loads(ledger.read_text()) == []
+
+
+def test_mcp_helper_is_reapable_purpose():
+    assert "mcp-helper" in pi.REAPABLE_PURPOSES
+    # Interactive purposes still excluded.
+    assert "chat" not in pi.REAPABLE_PURPOSES
+
+
+# ---------------------------------------------------------------------------
+# Spawner liveness gate
+# ---------------------------------------------------------------------------
+
+def test_live_spawner_protection(ledger, child):
+    """A helper whose spawner (this process) lives is never reap-eligible."""
+    pi.register_child(child.pid, "mcp-helper")
+    (entry,) = pi.ledger_entries()
+    assert pi.spawner_is_dead(entry) is False
+
+    killed: list[int] = []
+    reaped = pi.reap_orphaned_mcp_helpers(kill_fn=killed.append)
+    assert reaped == [] and killed == []
+    assert psutil.pid_exists(child.pid)
+
+
+def _orphan_entry_for(child_pid: int) -> None:
+    """Rewrite the child's ledger entry so its spawner is a real dead process."""
+    path = pi._ledger_path()
+    dead_pid, dead_create = _dead_process_identity()
+    entries = json.loads(path.read_text(encoding="utf-8"))
+    for e in entries:
+        if e["pid"] == child_pid:
+            e["spawner_pid"] = dead_pid
+            e["spawner_create"] = dead_create
+    path.write_text(json.dumps(entries), encoding="utf-8")
+
+
+def test_dead_spawner_reap_eligibility(ledger, child):
+    pi.register_child(child.pid, "mcp-helper")
+    _orphan_entry_for(child.pid)
+    (entry,) = pi.ledger_entries()
+    assert pi.spawner_is_dead(entry) is True
+
+    killed: list[int] = []
+    assert pi.reap_orphaned_mcp_helpers(kill_fn=killed.append) == [child.pid]
+    assert killed == [child.pid]
+
+
+def test_reap_selection_mixes_live_and_dead_spawners(ledger):
+    """Only the orphan is selected; the live-spawner helper is untouched."""
+    live_proc = subprocess.Popen(["sleep", "300"])
+    orphan_proc = subprocess.Popen(["sleep", "300"])
+    try:
+        pi.register_child(live_proc.pid, "mcp-helper")
+        pi.register_child(orphan_proc.pid, "mcp-helper")
+        _orphan_entry_for(orphan_proc.pid)
+
+        killed: list[int] = []
+        reaped = pi.reap_orphaned_mcp_helpers(kill_fn=killed.append)
+        assert reaped == [orphan_proc.pid]
+        assert live_proc.pid not in killed
+    finally:
+        for p in (live_proc, orphan_proc):
+            p.kill()
+            p.wait()
+
+
+def test_reap_actually_kills_orphan(ledger, child):
+    """Default kill path really terminates the orphaned helper."""
+    pi.register_child(child.pid, "mcp-helper")
+    _orphan_entry_for(child.pid)
+    assert pi.reap_orphaned_mcp_helpers() == [child.pid]
+    deadline = time.time() + 5
+    while time.time() < deadline and child.poll() is None:
+        time.sleep(0.05)
+    assert child.poll() is not None
+
+
+def test_reap_ignores_non_mcp_purposes(ledger, child):
+    pi.register_child(child.pid, "serve-child-not-helper")
+    _orphan_entry_for(child.pid)
+    assert pi.reap_orphaned_mcp_helpers() == []
+    assert psutil.pid_exists(child.pid)
+
+
+# ---------------------------------------------------------------------------
+# Updater rung (_ledger_reapable_backend_pids) flow-through
+# ---------------------------------------------------------------------------
+
+def test_updater_ledger_rung_flows_mcp_helper(ledger, child):
+    from hermes_cli import update_cmd
+
+    pi.register_child(child.pid, "mcp-helper")
+    matches = [(child.pid, "python", "sleep 300")]
+
+    # Live spawner (this process) → never selected.
+    assert update_cmd._ledger_reapable_backend_pids(matches) == []
+
+    # Provably dead spawner → positively identified as reapable.
+    _orphan_entry_for(child.pid)
+    assert update_cmd._ledger_reapable_backend_pids(matches) == [child.pid]
+
+
+# ---------------------------------------------------------------------------
+# Prune-on-write of exited children
+# ---------------------------------------------------------------------------
+
+def test_ledger_prunes_exited_children_on_next_write(ledger):
+    doomed = subprocess.Popen(["sleep", "300"])
+    pi.register_child(doomed.pid, "mcp-helper")
+    doomed.kill()
+    doomed.wait()
+    deadline = time.time() + 5
+    while time.time() < deadline and psutil.pid_exists(doomed.pid):
+        time.sleep(0.05)
+
+    survivor = subprocess.Popen(["sleep", "300"])
+    try:
+        pi.register_child(survivor.pid, "mcp-helper")
+        entries = json.loads(ledger.read_text(encoding="utf-8"))
+        pids = [e["pid"] for e in entries]
+        assert survivor.pid in pids
+        assert doomed.pid not in pids
+    finally:
+        survivor.kill()
+        survivor.wait()