claude-multiacc 2.0.60 → 2.0.64

package/tests/test_codex_retry_process.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""Buffered Codex retry owns and terminates only its active native child."""
+
+import json
+import os
+from pathlib import Path
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+
+import test_codex_exec_stdin as pipe_fixture
+
+REPO = Path(__file__).resolve().parents[1]
+HELPER = REPO / 'lib/codex_retry_process.sh'
+RUNNER = '''source "$1"
+exec 3< "$2/input"
+fixture_root="$2"
+trap 'printf cleaned > "$fixture_root/exit-cleanup"' EXIT
+trap 'printf restored > "$fixture_root/restored-trap"' TERM
+CODEX_HOME="$2/fake-profile" codex_retry_run "$3" "$2/native.py" "$2" "$4"
+rc=$?
+[ "$4" != restore ] || kill -TERM $$
+exit "$rc"
+'''
+NATIVE = '''import json, os, pathlib, signal, sys, time
+root = pathlib.Path(sys.argv[1])
+mode = sys.argv[2]
+def stop(number, frame):
+    (root / 'stopped').write_text(str(number))
+    sys.exit(0)
+for number in (signal.SIGTERM, signal.SIGINT, signal.SIGHUP):
+    signal.signal(number, stop)
+data = sys.stdin.buffer.read()
+(root / 'received').write_bytes(data)
+(root / 'profile').write_text(os.environ.get('CODEX_HOME', ''))
+(root / 'native.pid').write_text(str(os.getpid()))
+if mode == 'wait':
+    while True:
+        time.sleep(0.05)
+print(json.dumps({'mode': mode}))
+print('native stderr', file=sys.stderr)
+sys.exit(7 if mode == 'fail' else 0)
+'''
+
+
+class CodexRetryProcessTests(unittest.TestCase):
+    def launch(self, mode):
+        temporary = tempfile.TemporaryDirectory(prefix='multiacc-retry-process-')
+        self.addCleanup(temporary.cleanup)
+        root = Path(temporary.name)
+        (root / 'input').write_bytes(b'finite stdin\n\x00\xff')
+        (root / 'native.py').write_text(NATIVE)
+        process = subprocess.Popen(
+            ['bash', '-c', RUNNER, 'retry-test', str(HELPER), str(root), sys.executable, mode],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        self.addCleanup(self.cleanup_process, process, root)
+        deadline = time.monotonic() + 5
+        while not (root / 'native.pid').exists() and process.poll() is None and time.monotonic() < deadline:
+            time.sleep(0.02)
+        self.assertTrue((root / 'native.pid').exists(), 'owned native child did not launch')
+        return process, root
+
+    def cleanup_process(self, process, root):
+        # Only this fixture's owned native PID; ordinary assertions verify it was
+        # already reaped. A regression must not leave a sleeping fake behind.
+        if process.poll() is None:
+            process.terminate()
+        pid_file = root / 'native.pid'
+        if pid_file.exists():
+            try:
+                os.kill(int(pid_file.read_text()), signal.SIGTERM)
+            except ProcessLookupError:
+                pass
+        try:
+            process.communicate(timeout=3)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            process.communicate(timeout=3)
+
+    def test_termination_signals_reach_and_reap_only_the_owned_native_child(self):
+        for number in (signal.SIGTERM, signal.SIGINT, signal.SIGHUP):
+            with self.subTest(signal=number):
+                process, root = self.launch('wait')
+                process.send_signal(number)
+                process.communicate(timeout=3)
+                self.assertEqual(process.returncode, 128 + number)
+                self.assertEqual(int((root / 'stopped').read_text()), number)
+                with self.assertRaises(ProcessLookupError):
+                    os.kill(int((root / 'native.pid').read_text()), 0)
+                self.assertEqual((root / 'exit-cleanup').read_text(), 'cleaned')
+
+    def test_success_failure_and_prior_traps_are_preserved(self):
+        for mode, expected in [('success', 0), ('fail', 7), ('restore', 0)]:
+            with self.subTest(mode=mode):
+                process, root = self.launch(mode)
+                stdout, stderr = process.communicate(timeout=3)
+                self.assertEqual(process.returncode, expected)
+                self.assertEqual(json.loads(stdout), {'mode': mode})
+                self.assertEqual(stderr, b'native stderr\n')
+                self.assertEqual((root / 'received').read_bytes(), (root / 'input').read_bytes())
+                self.assertEqual((root / 'profile').read_text(), str(root / 'fake-profile'))
+                self.assertEqual((root / 'exit-cleanup').read_text(), 'cleaned')
+                if mode == 'restore':
+                    self.assertEqual((root / 'restored-trap').read_text(), 'restored')
+
+    def test_actual_shim_pipe_cancellation_reaps_native_without_retry_or_scratch(self):
+        fixture = pipe_fixture.CodexExecStdinTests()
+        fixture.setUp()
+        self.addCleanup(fixture.doCleanups)
+        root = fixture.root
+        native = NATIVE.replace('root = pathlib.Path(sys.argv[1])',
+                                "root = pathlib.Path(os.environ['FAKE_ROOT'])\n"
+                                "with (root / 'attempts').open('a') as handle: handle.write('attempt\\n')")
+        native = native.replace('mode = sys.argv[2]', "mode = 'wait'")
+        (root / 'bin/codex').write_text(f'#!{sys.executable}\n' + native)
+        process = subprocess.Popen([str(REPO / 'bin/codex'), *fixture.args], env=fixture.env,
+                                   stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        self.addCleanup(self.cleanup_process, process, root)
+        process.stdin.write(pipe_fixture.PROMPT)
+        process.stdin.close()
+        process.stdin = None
+        deadline = time.monotonic() + 5
+        while not (root / 'native.pid').exists() and process.poll() is None and time.monotonic() < deadline:
+            time.sleep(0.02)
+        self.assertTrue((root / 'native.pid').exists(), 'shim did not launch native child')
+        process.send_signal(signal.SIGTERM)
+        process.communicate(timeout=3)
+        self.assertEqual(process.returncode, 143)
+        self.assertEqual(int((root / 'stopped').read_text()), signal.SIGTERM)
+        with self.assertRaises(ProcessLookupError):
+            os.kill(int((root / 'native.pid').read_text()), 0)
+        self.assertEqual((root / 'attempts').read_text(), 'attempt\n')
+        self.assertEqual((root / 'received').read_bytes(), pipe_fixture.PROMPT)
+        self.assertEqual(list(fixture.pool.glob('tmp/shim.*')), [])
+        self.assertNotIn('retry from=', (fixture.pool / 'selection.log').read_text())
+        self.assertFalse((fixture.pool / 'acct-01/.limited').exists())
+
+
+if __name__ == '__main__':
+    unittest.main()

package/tests/test_mcp_mirror.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""Stock mutations must not promote concurrent runner publications into the registry."""
+
+import json
+from pathlib import Path
+import unittest
+from unittest.mock import patch
+
+from test_mcp_registry import HAS_TOMLLIB, HTTP, R, RegistryCase, STDIO
+
+APP = "appinspire-mcp"
+MOTION = "motionsites"
+V1 = {"type": "stdio", "command": "/releases/1000249/python", "args": ["launcher.pyc"], "env": {}}
+V2 = {"type": "stdio", "command": "/releases/1000250/python", "args": ["launcher.pyc"], "env": {}}
+V3 = {"type": "stdio", "command": "/bin/sh", "args": ["-p", "-c", "exec node server.mjs"], "env": {}}
+
+
+class MirrorCases:
+    def setUp(self):
+        super().setUp()
+        if self.provider == "codex" and not HAS_TOMLLIB:
+            self.skipTest("Codex requires tomllib")
+        if self.replica:
+            (self.root / "sync-role").write_text("replica\n")
+
+    def publish(self, servers):
+        rc, _, err = self.run_cli(self.provider, "import-local", "--owner", "app-robot",
+                                 stdin=json.dumps({"mcpServers": servers}))
+        self.assertEqual(rc, 0, err)
+
+    def write_account(self, servers, projects=None):
+        if self.provider == "claude":
+            R._claude_save(self.acct(), {"mcpServers": servers, "projects": projects or {}})
+        else:
+            eff = R.Effective()
+            eff.servers = servers
+            text, notes = R.reconcile_codex_text("", eff)
+            self.assertFalse(notes)
+            (Path(self.acct()) / "config.toml").write_text(text)
+
+    def before(self):
+        rc, snapshot, err = self.run_cli(self.provider, "snapshot", "--account-dir", self.acct())
+        self.assertEqual(rc, 0, err)
+        path = self.root / "before.json"
+        path.write_text(snapshot)
+        return str(path)
+
+    def learn(self, before, name):
+        scope = ["--name", name] if name is not None else []
+        rc, _, err = self.run_cli(self.provider, "learn", "--account-dir", self.acct(),
+                                 "--before", before, *scope)
+        self.assertEqual(rc, 0, err)
+        return R._Target(str(self.root)).section
+
+    def test_named_add_ignores_delayed_runner_generation(self):
+        self.publish({APP: V1})
+        before = self.before()
+        self.publish({APP: V2})
+        # import-local commits G3 under the lock, then applies accounts outside it.
+        # Pause before apply: the client still sees G2, which differs from current G3.
+        with patch.object(R, "_apply_all", return_value=0):
+            self.publish({APP: V3})
+        self.write_account({APP: V2, MOTION: HTTP})
+        section = self.learn(before, MOTION)
+        self.assertEqual(set(section["mcpServers"]), {MOTION})
+        self.assertEqual(section["retired"] + section["retiredUser"], [])
+        self.assertEqual(self.overlay()["owners"]["app-robot"]["mcpServers"], {APP: V3})
+        for account in ("acct-01", "acct-02"):
+            snapshot = R.snapshot(self.provider, self.acct(account))
+            self.assertEqual(snapshot["user"][APP]["command"], "/bin/sh")
+            self.assertEqual(snapshot["user"][MOTION]["url"], HTTP["url"])
+
+    def test_named_remove_does_not_promote_runner_retirement(self):
+        self.publish({APP: V1})
+        self.run_cli(self.provider, "add-json", MOTION, json.dumps(HTTP))
+        before = self.before()
+        self.publish({})
+        self.write_account({})
+        section = self.learn(before, MOTION)
+        self.assertEqual(section["mcpServers"], {})
+        self.assertEqual(section["retiredUser"], [MOTION])
+        self.assertEqual(section["retired"], [])
+        self.assertEqual(self.overlay()["owners"]["app-robot"]["retired"], [APP])
+
+    def test_explicit_owner_override_and_removal_still_mirror(self):
+        self.publish({APP: V1})
+        before = self.before()
+        self.write_account({APP: HTTP})
+        section = self.learn(before, APP)
+        self.assertEqual(section["mcpServers"][APP]["url"], HTTP["url"])
+        self.assertEqual(self.overlay()["owners"]["app-robot"]["mcpServers"], {APP: V1})
+        before = self.before()
+        self.write_account({})
+        section = self.learn(before, APP)
+        self.assertEqual(section["mcpServers"], {})
+        self.assertEqual(section["retiredUser"], [APP])
+        self.assertEqual(section["retired"], [])
+
+    def test_bulk_import_excludes_external_updates_and_retirements(self):
+        self.publish({APP: V1, "old-runner-tool": STDIO})
+        self.run_cli(self.provider, "import-local", "--owner", "local",
+                     stdin=json.dumps({"mcpServers": {"local-tool": V1}}))
+        before = self.before()
+        self.publish({APP: V2})
+        with patch.object(R, "_apply_all", return_value=0):
+            self.publish({APP: V3})
+        self.write_account({APP: V2, MOTION: HTTP, "local-tool": HTTP})
+        section = self.learn(before, None)
+        self.assertEqual(set(section["mcpServers"]), {MOTION, "local-tool"} if self.replica else {MOTION})
+        local = self.overlay()["owners"]["local"]["mcpServers"]["local-tool"]
+        self.assertEqual(local.get("url") if self.replica else local, HTTP["url"] if self.replica else V1)
+        self.assertEqual(section["retired"] + section["retiredUser"], [])
+
+    def test_named_project_changes_and_approvals_stay_scoped(self):
+        if self.provider != "claude":
+            self.skipTest("project MCP entries are Claude-only")
+        for name in (MOTION, "other"):
+            self.run_cli("claude", "add-json", name, json.dumps(STDIO), "--scope", "project",
+                         "--project", "/project")
+        before = self.before()
+        self.write_account({}, {"/project": {"mcpServers": {MOTION: HTTP, "other": HTTP},
+                                             "enabledMcpjsonServers": [MOTION, "other"]}})
+        section = self.learn(before, MOTION)
+        project = section["projects"]["/project"]
+        self.assertEqual(project["mcpServers"], {MOTION: HTTP, "other": STDIO})
+        self.assertEqual(project["enabledMcpjsonServers"], [MOTION])
+        other = self.claude_doc("acct-02")["projects"]["/project"]
+        self.assertEqual(other["enabledMcpjsonServers"], [MOTION])
+
+
+class ClaudeSourceTests(MirrorCases, RegistryCase):
+    provider, replica = "claude", False
+
+
+class ClaudeReplicaTests(MirrorCases, RegistryCase):
+    provider, replica = "claude", True
+
+
+class CodexSourceTests(MirrorCases, RegistryCase):
+    provider, replica = "codex", False
+
+
+class CodexReplicaTests(MirrorCases, RegistryCase):
+    provider, replica = "codex", True
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_mcp_mirror_args.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""MCP target parsing uses native verb options, without reading command payloads."""
+
+from pathlib import Path
+import subprocess
+import tempfile
+import unittest
+
+from test_mcp_registry import R
+
+HELPER = Path(__file__).resolve().parents[1] / "lib" / "mcp_mirror.sh"
+
+
+class MutationNameTests(unittest.TestCase):
+    def parse(self, *args):
+        return subprocess.run(["/bin/bash", "-uc", '. "$1"; shift; mcp_mutation_name "$@"',
+                               "mcp-target-test", str(HELPER), *args], capture_output=True, text=True)
+
+    def test_native_options_before_name(self):
+        cases = [
+            ("claude", "add", "-s", "user", "-t", "http", "motionsites", "https://example.test"),
+            ("claude", "add", "-suser", "-thttp", "motionsites", "https://example.test"),
+            ("claude", "add", "--scope=user", "--callback-port", "1234", "--client-id", "cid",
+             "--client-secret", "motionsites", "https://example.test"),
+            ("claude", "add", "-e", "A=1", "B=2", "-H", "X: 1", "Y: 2", "--", "motionsites", "echo"),
+            ("claude", "add", "-eA=1", "B=2", "--scope=user", "motionsites", "--", "echo", "--unknown"),
+            ("claude", "add-json", "-suser", "--client-secret", "motionsites", '{"command":"echo"}'),
+            ("claude", "remove", "--scope=user", "motionsites"),
+            ("codex", "add", "-c", "x=1", "--env", "A=1", "--url=https://example.test", "motionsites"),
+            ("codex", "add", "--enable", "x", "--disable=y", "--bearer-token-env-var", "MCP_TOKEN",
+             "--oauth-client-id", "cid", "--oauth-client-secret", "dummy", "--oauth-resource", "r",
+             "--oauth-client-registration", "dynamic", "motionsites"),
+            ("codex", "remove", "-cx=1", "--enable=x", "--disable", "y", "motionsites"),
+            ("codex", "add", "motionsites", "--", "node", "--env", "appinspire-mcp"),
+            ("claude", "add", "motionsites", "--", "node", "--help"),
+            ("codex", "add", "motionsites", "--help"),
+            ("claude", "remove", "motionsites", "-h"),
+            ("claude", "add", "--client-id", "--help", "motionsites", "https://example.test"),
+        ]
+        for args in cases:
+            with self.subTest(args=args):
+                result = self.parse(*args)
+                self.assertEqual((result.returncode, result.stdout, result.stderr), (0, "motionsites\n", ""))
+
+    def test_unknown_or_incomplete_options_never_become_a_broad_mirror(self):
+        cases = [
+            ("claude", "add", "--future-value", "appinspire-mcp", "motionsites"),
+            ("claude", "remove", "--scope"),
+            ("claude", "add", "-e", "A=1", "motionsites", "echo"),
+            ("claude", "add-json", "--client-secret=unexpected", "motionsites", "{}"),
+            ("codex", "add", "--unknown=value", "motionsites"),
+            ("codex", "remove", "--config"),
+            ("codex", "add", "--"),
+            ("claude", "add-from-claude-desktop"),
+        ]
+        for args in cases:
+            with self.subTest(args=args):
+                result = self.parse(*args)
+                self.assertNotEqual(result.returncode, 0)
+                self.assertEqual(result.stdout, "")
+
+    def test_help_without_a_target_has_a_distinct_quiet_status(self):
+        for provider in ("claude", "codex"):
+            for flag in ("-h", "--help"):
+                result = self.parse(provider, "add", flag)
+                self.assertEqual((result.returncode, result.stdout, result.stderr), (2, "", ""))
+
+    def run_shim(self, provider, args, native_exit=0):
+        with tempfile.TemporaryDirectory() as work:
+            root = Path(work)
+            pool, fakebin = root / "pool", root / "bin"
+            (pool / "acct-01").mkdir(parents=True)
+            fakebin.mkdir()
+            (pool / "accounts.json").write_text('{"version":1,"accounts":[{"id":"acct-01"}]}')
+            native = fakebin / provider
+            native.write_text('#!/bin/sh\nprintf "NATIVE\\n"\nprintf "%s\\n" "$@"\nexit "$FAKE_EXIT"\n')
+            native.chmod(0o755)
+            logger = fakebin / "mcp-python"
+            logger.write_text('#!/bin/sh\nprintf "%s\\n" "$@" >> "$MCP_TEST_LOG"\n'
+                              'case "$*" in *" snapshot "*) printf "{}\\n" ;; esac\n')
+            logger.chmod(0o755)
+            log = root / "mirror.log"
+            env = {"PATH": f"{fakebin}:/usr/bin:/bin", "HOME": work, "USER": "test", "LOGNAME": "test",
+                   "TMPDIR": work, "FAKE_EXIT": str(native_exit), "MCP_TEST_LOG": str(log),
+                   "CLAUDE_MULTIACC_PYTHON": str(logger), f"{provider.upper()}_ACCOUNTS_ROOT": str(pool),
+                   f"{provider.upper()}_SHIM_ACTIVE": "1",
+                   "CLAUDE_CONFIG_DIR" if provider == "claude" else "CODEX_HOME": str(pool / "acct-01")}
+            result = subprocess.run([str(HELPER.parents[1] / "bin" / provider), *args], env=env,
+                                    capture_output=True, text=True, timeout=10)
+            return result, log.read_text() if log.exists() else ""
+
+    def test_literal_help_global_value_still_mirrors(self):
+        args = ["--system-prompt", "--help", "mcp", "add-json", "--scope", "user", "motionsites",
+                '{"command":"echo","args":[]}']
+        result, log = self.run_shim("claude", args)
+        self.assertEqual((result.returncode, result.stderr), (0, ""))
+        self.assertEqual(result.stdout.splitlines(), ["NATIVE", *args])
+        self.assertIn("\nlearn\n", log)
+        self.assertIn("\n--name=motionsites\n", log)
+
+    def test_leading_dash_name_reaches_the_registry_parser(self):
+        args = ["mcp", "add", "--", "-probe-name", "echo"]
+        for provider in ("claude", "codex"):
+            result, log = self.run_shim(provider, args)
+            self.assertEqual((result.returncode, result.stderr), (0, ""))
+            self.assertEqual(result.stdout.splitlines(), ["NATIVE", *args])
+            words = log.splitlines()
+            tail = words[words.index("learn") + 1:]
+            parsed = R.build_parser().parse_args(["--root", "unused", "--provider", provider, "learn", *tail])
+            self.assertEqual(parsed.name, "-probe-name")
+
+    def test_help_is_quiet_native_passthrough(self):
+        for provider in ("claude", "codex"):
+            result, log = self.run_shim(provider, ["mcp", "add", "--help"])
+            self.assertEqual((result.returncode, result.stderr, log), (0, "", ""))
+            self.assertEqual(result.stdout.splitlines(), ["NATIVE", "mcp", "add", "--help"])
+
+    def test_unknown_options_keep_native_argv_and_exit_without_mirroring(self):
+        args = ["mcp", "add", "--future-value", "appinspire-mcp", "motionsites"]
+        for provider in ("claude", "codex"):
+            for native_exit in (0, 7):
+                result, log = self.run_shim(provider, args, native_exit)
+                self.assertEqual((result.returncode, log), (native_exit, ""))
+                self.assertEqual(result.stdout.splitlines(), ["NATIVE", *args])
+                self.assertEqual("change not mirrored" in result.stderr, native_exit == 0)
+
+
+if __name__ == "__main__":
+    unittest.main()