agentseed-mcp 0.3.0

package/server/test_hook.py

@@ -0,0 +1,331 @@
+"""AgentSeed client-enforcement hook tests (stdlib unittest, subprocess)."""
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+HOOK = os.path.join(HERE, "guard_hook.py")
+PLUGIN_ROOT = os.path.dirname(HERE)
+PY = sys.executable
+
+OVERSOLD = "all tests pass, guaranteed"
+
+
+def run_hook(payload=None, *extra: str) -> subprocess.CompletedProcess:
+    stdin = "" if payload is None else json.dumps(payload)
+    return subprocess.run(
+        [PY, HOOK, *extra],
+        input=stdin,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        timeout=60,
+        cwd=PLUGIN_ROOT,
+    )
+
+
+class TestHookMode(unittest.TestCase):
+    def test_pretooluse_clean_write_passes(self):
+        r = run_hook(
+            {
+                "hook_event_name": "PreToolUse",
+                "tool_name": "Write",
+                "tool_input": {"file_path": "mod.py", "content": "x = 1\n"},
+            }
+        )
+        self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
+        v = json.loads(r.stdout)
+        self.assertEqual(v["status"], "pass")
+        self.assertFalse(v["blocking"])
+
+    def test_pretooluse_blocks_oversold_write(self):
+        r = run_hook(
+            {
+                "hook_event_name": "PreToolUse",
+                "tool_name": "Write",
+                "tool_input": {"file_path": "notes.md", "content": OVERSOLD + "\n"},
+            }
+        )
+        self.assertEqual(r.returncode, 2, r.stdout)
+        v = json.loads(r.stdout)
+        self.assertEqual(v["status"], "blocked")
+        self.assertTrue(v["blocking"])
+        self.assertTrue(v["hits"])
+        self.assertIn(OVERSOLD.split(",")[0], r.stderr)
+
+    def test_pretooluse_blocks_hallucinated_symbol(self):
+        r = run_hook(
+            {
+                "hook_event_name": "PreToolUse",
+                "tool_name": "Write",
+                "tool_input": {"file_path": "m.py", "content": "return magic_unknown()\n"},
+            }
+        )
+        self.assertEqual(r.returncode, 2, r.stdout)
+        v = json.loads(r.stdout)
+        self.assertIn("magic_unknown", v["suspects"])
+
+    def test_edit_new_string_is_scanned(self):
+        r = run_hook(
+            {
+                "hook_event_name": "PreToolUse",
+                "tool_name": "Edit",
+                "tool_input": {"file_path": "a.md", "old_string": "x", "new_string": OVERSOLD},
+            }
+        )
+        self.assertEqual(r.returncode, 2, r.stdout)
+        v = json.loads(r.stdout)
+        self.assertEqual(v["status"], "blocked")
+
+    def test_multiedit_edits_list_is_scanned(self):
+        r = run_hook(
+            {
+                "hook_event_name": "PreToolUse",
+                "tool_name": "MultiEdit",
+                "tool_input": {
+                    "file_path": "a.md",
+                    "edits": [{"old_string": "x", "new_string": OVERSOLD}],
+                },
+            }
+        )
+        self.assertEqual(r.returncode, 2, r.stdout)
+
+    def test_warning_only_does_not_block(self):
+        r = run_hook(
+            {
+                "hook_event_name": "PreToolUse",
+                "tool_name": "Write",
+                "tool_input": {"file_path": "m.py", "content": "# TODO: later\n"},
+            }
+        )
+        self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
+        v = json.loads(r.stdout)
+        self.assertFalse(v["blocking"])
+        self.assertTrue(v["hits"])  # reported, just not blocking
+
+    def test_posttooluse_scans_file_from_disk(self):
+        with tempfile.TemporaryDirectory() as d:
+            path = os.path.join(d, "doc.md")
+            with open(path, "w", encoding="utf-8") as fh:
+                fh.write("this module is production ready now\n")
+            # no inline content key -> falls back to reading the file on disk
+            r = run_hook(
+                {
+                    "hook_event_name": "PostToolUse",
+                    "tool_name": "NotebookSave",
+                    "tool_input": {"file_path": path},
+                }
+            )
+            self.assertEqual(r.returncode, 2, r.stdout)
+            v = json.loads(r.stdout)
+            self.assertEqual(v["status"], "blocked")
+
+    def test_unsupported_extension_skips(self):
+        r = run_hook(
+            {
+                "hook_event_name": "PreToolUse",
+                "tool_name": "Write",
+                "tool_input": {"file_path": "img.png", "content": OVERSOLD},
+            }
+        )
+        self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
+        v = json.loads(r.stdout)
+        self.assertEqual(v["status"], "skipped")
+
+    def test_unknown_tool_shape_skips(self):
+        r = run_hook({"hook_event_name": "PostToolUse", "tool_name": "WebFetch", "tool_input": {}})
+        self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
+        v = json.loads(r.stdout)
+        self.assertEqual(v["status"], "skipped")
+
+    def test_malformed_stdin_fails_open(self):
+        r = subprocess.run(
+            [PY, HOOK],
+            input="this is not json",
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=60,
+            cwd=PLUGIN_ROOT,
+        )
+        self.assertEqual(r.returncode, 0, r.stderr)
+        v = json.loads(r.stdout)
+        self.assertEqual(v["status"], "skipped")
+        self.assertIn("not valid JSON", v["reason"])
+
+    def test_empty_stdin_fails_open(self):
+        r = run_hook(None)
+        self.assertEqual(r.returncode, 0, r.stderr)
+        v = json.loads(r.stdout)
+        self.assertEqual(v["status"], "skipped")
+
+
+class TestDirectFileScan(unittest.TestCase):
+    def test_file_flag_scans_disk(self):
+        with tempfile.TemporaryDirectory() as d:
+            path = os.path.join(d, "m.py")
+            with open(path, "w", encoding="utf-8") as fh:
+                fh.write("return magic_unknown()\n")
+            r = run_hook(None, "--file", path)
+            self.assertEqual(r.returncode, 2, r.stdout)
+            v = json.loads(r.stdout)
+            self.assertIn("magic_unknown", v["suspects"])
+
+    def test_file_flag_missing_file_skips(self):
+        r = run_hook(None, "--file", os.path.join(tempfile.gettempdir(), "no-such-file-xyz.py"))
+        self.assertEqual(r.returncode, 0, r.stderr)
+        v = json.loads(r.stdout)
+        self.assertEqual(v["status"], "skipped")
+
+
+class TestRegister(unittest.TestCase):
+    def test_register_merges_idempotent_and_preserves_unrelated(self):
+        with tempfile.TemporaryDirectory() as d:
+            settings = os.path.join(d, "settings.json")
+            with open(settings, "w", encoding="utf-8") as fh:
+                json.dump(
+                    {
+                        "model": "opus",
+                        "hooks": {
+                            "Stop": [{"hooks": [{"type": "command", "command": "notify.sh"}]}]
+                        },
+                    },
+                    fh,
+                )
+            r1 = run_hook(None, "register", "--client", "claude", "--settings", settings)
+            self.assertEqual(r1.returncode, 0, r1.stdout + r1.stderr)
+            r2 = run_hook(None, "register", "--client", "claude", "--settings", settings)
+            self.assertEqual(r2.returncode, 0, r2.stdout + r2.stderr)
+            with open(settings, encoding="utf-8") as fh:
+                data = json.load(fh)
+            self.assertEqual(data["model"], "opus")
+            stop = data["hooks"]["Stop"]
+            self.assertEqual(len(stop), 1)
+            self.assertEqual(stop[0]["hooks"][0]["command"], "notify.sh")
+            for ev in ("PreToolUse", "PostToolUse"):
+                groups = data["hooks"][ev]
+                agentseed_groups = [
+                    g
+                    for g in groups
+                    if any("guard_hook.py" in str(h.get("command", "")) for h in g.get("hooks", []))
+                ]
+                self.assertEqual(len(agentseed_groups), 1, ev)
+                self.assertEqual(agentseed_groups[0]["matcher"], "Write|Edit|MultiEdit")
+
+    def test_register_replaces_stale_agentseed_entries(self):
+        with tempfile.TemporaryDirectory() as d:
+            settings = os.path.join(d, "settings.json")
+            stale = {"type": "command", "command": '"old-python" "old/guard_hook.py"'}
+            with open(settings, "w", encoding="utf-8") as fh:
+                json.dump({"hooks": {"PreToolUse": [{"matcher": "Write", "hooks": [stale]}]}}, fh)
+            r = run_hook(None, "register", "--client", "claude", "--settings", settings)
+            self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
+            with open(settings, encoding="utf-8") as fh:
+                data = json.load(fh)
+            groups = data["hooks"]["PreToolUse"]
+            commands = [
+                h["command"]
+                for g in groups
+                for h in g.get("hooks", [])
+                if "guard_hook.py" in h.get("command", "")
+            ]
+            self.assertEqual(len(commands), 1)
+            self.assertNotIn("old-python", commands[0])
+
+    def test_register_cursor_merges_hooks_json_idempotent(self):
+        with tempfile.TemporaryDirectory() as d:
+            hooks_json = os.path.join(d, "hooks.json")
+            with open(hooks_json, "w", encoding="utf-8") as fh:
+                json.dump(
+                    {"version": 1, "hooks": {"stop": [{"command": "notify.sh"}]}},
+                    fh,
+                )
+            r1 = run_hook(None, "register", "--client", "cursor", "--settings", hooks_json)
+            self.assertEqual(r1.returncode, 0, r1.stdout + r1.stderr)
+            r2 = run_hook(None, "register", "--client", "cursor", "--settings", hooks_json)
+            self.assertEqual(r2.returncode, 0, r2.stdout + r2.stderr)
+            with open(hooks_json, encoding="utf-8") as fh:
+                data = json.load(fh)
+            self.assertEqual(data["version"], 1)
+            self.assertEqual(data["hooks"]["stop"], [{"command": "notify.sh"}])
+            for ev in ("afterFileEdit", "preToolUse"):
+                groups = data["hooks"][ev]
+                mine = [
+                    g
+                    for g in groups
+                    if any("guard_hook.py" in str(h.get("command", "")) for h in g.get("hooks", []))
+                ]
+                self.assertEqual(len(mine), 1, ev)
+
+    def test_register_opencode_installs_plugin_file(self):
+        with tempfile.TemporaryDirectory() as d:
+            dest = os.path.join(d, "plugin", "agentseed-guard.js")
+            r = run_hook(None, "register", "--client", "opencode", "--settings", dest)
+            self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
+            self.assertTrue(os.path.isfile(dest))
+            with open(dest, encoding="utf-8") as fh:
+                body = fh.read()
+            self.assertIn("tool.execute.before", body)
+            self.assertIn("guard_hook.py", body)
+
+    def test_register_bad_settings_json_fails_cleanly(self):
+        with tempfile.TemporaryDirectory() as d:
+            settings = os.path.join(d, "settings.json")
+            with open(settings, "w", encoding="utf-8") as fh:
+                fh.write("{broken")
+            r = run_hook(None, "register", "--client", "claude", "--settings", settings)
+            self.assertEqual(r.returncode, 1)
+            self.assertIn("cannot parse", r.stdout)
+
+
+class TestCursorProtocol(unittest.TestCase):
+    def test_afterfileedit_toplevel_shape_blocks_with_deny_json(self):
+        event = {
+            "hook_event_name": "afterFileEdit",
+            "cursor_version": "1.7.2",
+            "workspace_roots": ["C:/proj"],
+            "file_path": "report.md",
+            "edits": [{"old_string": "x", "new_string": OVERSOLD}],
+        }
+        r = run_hook(event)
+        self.assertEqual(r.returncode, 2, r.stdout)
+        v = json.loads(r.stdout.split('{"continue"')[0])  # verdict JSON first
+        self.assertEqual(v["protocol"], "cursor")
+        self.assertEqual(v["status"], "blocked")
+        deny = r.stdout[r.stdout.index('{"continue"') :]
+        self.assertIn('"permission": "deny"', deny)
+        self.assertIn("agent_message", deny)
+
+    def test_cursor_pretooluse_toolinput_shape_blocks(self):
+        event = {
+            "hook_event_name": "preToolUse",
+            "cursor_version": "1.7.2",
+            "workspace_roots": ["C:/proj"],
+            "tool_name": "Write",
+            "tool_input": {"file_path": "m.md", "content": OVERSOLD},
+        }
+        r = run_hook(event)
+        self.assertEqual(r.returncode, 2, r.stdout)
+
+    def test_claude_payload_has_no_cursor_deny_json(self):
+        r = run_hook(
+            {
+                "hook_event_name": "PreToolUse",
+                "tool_name": "Write",
+                "tool_input": {"file_path": "m.md", "content": OVERSOLD},
+            }
+        )
+        self.assertEqual(r.returncode, 2)
+        v = json.loads(r.stdout)
+        self.assertEqual(v["protocol"], "claude")
+        self.assertNotIn('"permission"', r.stdout)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/server/test_manifests.py

@@ -0,0 +1,70 @@
+"""Cross-platform manifest consistency tests.
+
+AgentSeed ships as one artifact to GitHub Releases and GitCode Releases
+(npm is advertised in server.json only once the package actually exists).
+These tests fail the build when plugin.json / package.json / server.json
+drift apart (version, license, files list) — the exact failure mode that
+shipped 1.3.3 vs 0.1.0 in the past.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import unittest
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+def _load(name: str) -> dict:
+    with open(os.path.join(ROOT, name), encoding="utf-8") as fh:
+        return json.load(fh)
+
+
+class TestManifestConsistency(unittest.TestCase):
+    def test_versions_match_across_manifests(self):
+        plugin_version = _load("plugin.json").get("version")
+        package_version = _load("package.json").get("version")
+        self.assertEqual(
+            plugin_version,
+            package_version,
+            f"version drift plugin.json vs package.json: {plugin_version} != {package_version}",
+        )
+        # server.json may legitimately list zero registry packages while no
+        # npm artifact exists; anything it DOES list must agree on version.
+        packages = _load("server.json").get("packages") or []
+        for i, pkg in enumerate(packages):
+            self.assertEqual(
+                pkg.get("version"),
+                plugin_version,
+                f"server.json packages[{i}] version drift",
+            )
+
+    def test_license_matches_across_manifests_and_file(self):
+        licenses = {
+            "plugin.json": _load("plugin.json").get("license"),
+            "package.json": _load("package.json").get("license"),
+            "server.json": _load("server.json").get("license"),
+        }
+        self.assertEqual(
+            len(set(licenses.values())), 1, f"license drift across platforms: {licenses}"
+        )
+        declared = next(iter(set(licenses.values())))
+        with open(os.path.join(ROOT, "LICENSE"), encoding="utf-8") as fh:
+            first_line = fh.readline().strip().lower()
+        self.assertIn(
+            declared.split("-")[0].lower(),
+            first_line,
+            f"LICENSE file does not match declared '{declared}'",
+        )
+
+    def test_package_files_entries_exist(self):
+        for entry in _load("package.json").get("files", []):
+            self.assertTrue(
+                os.path.exists(os.path.join(ROOT, entry)),
+                f"package.json 'files' entry missing on disk: {entry}",
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()

package/server/test_server.py

@@ -0,0 +1,247 @@
+"""AgentSeed MCP server protocol tests (spawns the real stdio server)."""
+
+import json
+import os
+import subprocess
+import sys
+import unittest
+
+SERVER = os.path.join(os.path.dirname(os.path.abspath(__file__)), "guard_server.py")
+
+# plugin.json is the single source of truth for the server version
+# (guard_server reads it via engine.plugin_version at startup).
+with open(os.path.join(os.path.dirname(SERVER), "..", "plugin.json"), encoding="utf-8") as _fh:
+    EXPECTED_VERSION = json.load(_fh)["version"]
+
+
+class TestServerProtocol(unittest.TestCase):
+    proc: subprocess.Popen
+
+    @classmethod
+    def setUpClass(cls):
+        cls.proc = subprocess.Popen(
+            [sys.executable, SERVER],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+        )
+
+    @classmethod
+    def tearDownClass(cls):
+        proc = cls.proc
+        if proc.poll() is None:
+            # close stdin first so the server's line-read loop hits EOF and exits
+            try:
+                proc.stdin.close()
+            except OSError:
+                pass
+            try:
+                proc.wait(timeout=10)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                proc.wait()
+        # always release the pipe handles; otherwise ResourceWarning fires on GC
+        for _pipe in (proc.stdin, proc.stdout, proc.stderr):
+            if _pipe is not None and not _pipe.closed:
+                _pipe.close()
+
+    def _rpc(self, payload: dict) -> dict:
+        self.proc.stdin.write(json.dumps(payload) + "\n")
+        self.proc.stdin.flush()
+        line = self.proc.stdout.readline()
+        self.assertTrue(line.strip(), "server closed the stream unexpectedly")
+        return json.loads(line)
+
+    def test_initialize_reports_version(self):
+        r = self._rpc(
+            {
+                "jsonrpc": "2.0",
+                "id": 1,
+                "method": "initialize",
+                "params": {"protocolVersion": "2024-11-05", "capabilities": {}},
+            }
+        )
+        self.assertEqual(r["result"]["serverInfo"]["version"], EXPECTED_VERSION)
+
+    def test_initialize_echoes_supported_protocol(self):
+        r = self._rpc(
+            {
+                "jsonrpc": "2.0",
+                "id": 6,
+                "method": "initialize",
+                "params": {"protocolVersion": "2025-06-18"},
+            }
+        )
+        self.assertEqual(r["result"]["protocolVersion"], "2025-06-18")
+
+    def test_initialize_falls_back_on_unknown_protocol(self):
+        r = self._rpc(
+            {
+                "jsonrpc": "2.0",
+                "id": 7,
+                "method": "initialize",
+                "params": {"protocolVersion": "1999-01-01"},
+            }
+        )
+        self.assertEqual(r["result"]["protocolVersion"], "2024-11-05")
+
+    def test_ping_returns_empty_result(self):
+        r = self._rpc({"jsonrpc": "2.0", "id": 2, "method": "ping"})
+        self.assertEqual(r["result"], {})
+
+    def test_unknown_method_is_error_32601(self):
+        r = self._rpc({"jsonrpc": "2.0", "id": 3, "method": "resources/list"})
+        self.assertEqual(r["error"]["code"], -32601)
+        self.assertNotIn("result", r)
+
+    def test_tools_list_and_call(self):
+        r = self._rpc({"jsonrpc": "2.0", "id": 4, "method": "tools/list"})
+        names = {t["name"] for t in r["result"]["tools"]}
+        self.assertEqual(
+            names,
+            {
+                "verify_code",
+                "check_contract",
+                "check_imports",
+                "scan_hallucination",
+                "check_plugin",
+                "sandbox_run",
+                "schema_validate",
+                "record_verification",
+            },
+        )
+        r = self._rpc(
+            {
+                "jsonrpc": "2.0",
+                "id": 5,
+                "method": "tools/call",
+                "params": {
+                    "name": "scan_hallucination",
+                    "arguments": {"source": "from unittest.mock import Mock\n"},
+                },
+            }
+        )
+        result = json.loads(r["result"]["content"][0]["text"])
+        self.assertTrue(result["clean"])
+
+    def test_record_verification_via_protocol(self):
+        r = self._rpc(
+            {
+                "jsonrpc": "2.0",
+                "id": 12,
+                "method": "tools/call",
+                "params": {
+                    "name": "record_verification",
+                    "arguments": {
+                        "task": "protocol test",
+                        "checks": [{"tool": "manual", "status": "pass"}],
+                    },
+                },
+            }
+        )
+        result = json.loads(r["result"]["content"][0]["text"])
+        # server writes into its own PLUGIN_DATA; ok flag is what matters
+        self.assertTrue(result["ok"], result)
+
+    def test_malformed_json_line_ignored_session_continues(self):
+        self.proc.stdin.write("this is definitely not json\n")
+        self.proc.stdin.flush()
+        r = self._rpc({"jsonrpc": "2.0", "id": 40, "method": "ping"})
+        self.assertEqual(r["id"], 40)
+
+    def test_unknown_tool_returns_is_error_result(self):
+        frame = self._rpc(
+            {
+                "jsonrpc": "2.0",
+                "id": 41,
+                "method": "tools/call",
+                "params": {"name": "no_such_tool", "arguments": {}},
+            }
+        )
+        text = frame["result"]["content"][0]["text"]
+        self.assertIn("Unknown tool", text)
+
+    def test_oversized_frame_rejected_session_survives(self):
+        # A >2MB line must get -32600 with null id, and the session must
+        # keep serving normal requests afterwards.
+        big = json.dumps(
+            {"jsonrpc": "2.0", "id": 30, "method": "ping", "params": {"pad": "a" * 2_100_000}}
+        )
+        self.proc.stdin.write(big + "\n")
+        self.proc.stdin.flush()
+        frame = json.loads(self.proc.stdout.readline())
+        self.assertEqual(frame["error"]["code"], -32600)
+        r = self._rpc({"jsonrpc": "2.0", "id": 31, "method": "ping"})
+        self.assertEqual(r["id"], 31)
+
+    def test_async_sandbox_completes_normally(self):
+        # Regression guard for the Windows stdin-inheritance deadlock:
+        # spawned children must complete, never stall to their timeout.
+        r = self._rpc(
+            {
+                "jsonrpc": "2.0",
+                "id": 20,
+                "method": "tools/call",
+                "params": {
+                    "name": "sandbox_run",
+                    "arguments": {
+                        "command": [sys.executable, "-c", "print('async-ok')"],
+                        "timeout": 15,
+                    },
+                },
+            }
+        )
+        result = json.loads(r["result"]["content"][0]["text"])
+        self.assertEqual(result["exit_code"], 0, result)
+        self.assertFalse(result["timed_out"])
+        self.assertIn("async-ok", result["stdout"])
+
+    def test_sandbox_run_is_cancellable(self):
+        # start a long sleep, cancel it, verify: no result frame for id 9,
+        # and the session stays alive afterwards.
+        self.proc.stdin.write(
+            json.dumps(
+                {
+                    "jsonrpc": "2.0",
+                    "id": 9,
+                    "method": "tools/call",
+                    "params": {
+                        "name": "sandbox_run",
+                        "arguments": {
+                            "command": [sys.executable, "-c", "import time; time.sleep(20)"],
+                            "timeout": 30,
+                        },
+                    },
+                }
+            )
+            + "\n"
+        )
+        self.proc.stdin.flush()
+        import time as _t
+
+        _t.sleep(0.6)  # let the child actually spawn
+        self.proc.stdin.write(
+            json.dumps(
+                {"jsonrpc": "2.0", "method": "notifications/cancelled", "params": {"requestId": 9}}
+            )
+            + "\n"
+        )
+        self.proc.stdin.flush()
+        # FIFO discipline: if the worker wrongly emitted a result for the
+        # cancelled id 9, it MUST appear before this ping's reply.
+        r = self._rpc({"jsonrpc": "2.0", "id": 10, "method": "ping"})
+        self.assertEqual(r["id"], 10)
+        import time as _t
+
+        _t.sleep(1.0)
+        r = self._rpc({"jsonrpc": "2.0", "id": 11, "method": "ping"})
+        self.assertEqual(
+            r["id"], 11, "unexpected late frame for cancelled request leaked into the stream"
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()