claude-multiacc 2.0.56 → 2.0.58

package/tests/test_autoresume_handoff_argv.py

@@ -0,0 +1,127 @@
+"""Fresh provider conversations retain source history and conservative permission intent."""
+
+import json
+from pathlib import Path
+import tempfile
+import unittest
+
+import test_autoresume as fixtures
+import autoresume_handoff as handoff
+
+
+class HandoffArgvTests(unittest.TestCase):
+    def setUp(self):
+        temporary = tempfile.TemporaryDirectory(prefix="ar-handoff-argv-")
+        self.addCleanup(temporary.cleanup)
+        self.home = Path(temporary.name).resolve()
+        self.cwd = self.home / 'workspace "quoted" $literal'
+        self.cwd.mkdir()
+
+    def history(self, provider):
+        sid = fixtures.SID if provider == "claude" else fixtures.CX_SID
+        name = sid + ".jsonl" if provider == "claude" else "rollout-fixture-" + sid + ".jsonl"
+        path = self.home / name
+        record = fixtures.cc_user(1000, "PRIVATE_SOURCE_TEXT_SENTINEL", cwd=str(self.cwd)) \
+            if provider == "claude" else fixtures.cx_meta(1000, cwd=str(self.cwd))
+        path.write_text(json.dumps(record) + "\n")
+        return handoff.validate_source(provider, sid, str(path), str(self.cwd))
+
+    def test_fresh_target_drops_source_session_model_effort_and_original_prompt(self):
+        cases = (("claude", "codex", ["--model", "source-only-model", "--effort", "high",
+                                      "--resume", fixtures.SID, "Original user request"]),
+                 ("codex", "claude", ["resume", "--no-daemon", "--model", "source-only-model",
+                                      fixtures.CX_SID, "Original user request"]))
+        for source, target, original in cases:
+            with self.subTest(source=source):
+                history = self.history(source)
+                argv = handoff.handoff_argv(source, target, original, history)
+                self.assertIsNotNone(argv)
+                for value in ("resume", "--resume", "--last", "--continue", "--model", "--effort",
+                              "source-only-model", "Original user request", history["sid"]):
+                    self.assertNotIn(value, argv[:-1])
+                self.assertIn(history["sid"], argv[-1])
+                self.assertNotIn("Original user request", argv[-1])
+
+    def test_default_and_allow_bypass_only_keep_conservative_target_permissions(self):
+        cases = (("claude", "codex", [], ["--sandbox", "read-only", "--ask-for-approval", "on-request"]),
+                 ("claude", "codex", ["--allow-dangerously-skip-permissions"],
+                  ["--sandbox", "read-only", "--ask-for-approval", "on-request"]),
+                 ("claude", "codex", ["--permission-mode", "default"],
+                  ["--sandbox", "read-only", "--ask-for-approval", "on-request"]),
+                 ("codex", "claude", [], ["--permission-mode", "default"]))
+        for source, target, original, expected in cases:
+            with self.subTest(source=source, original=original):
+                argv = handoff.handoff_argv(source, target, original, self.history(source))
+                self.assertIsNotNone(argv)
+                self.assertEqual(argv[:-1], expected)
+
+    def test_explicit_bypass_maps_only_to_equivalent_target_bypass(self):
+        cases = (("claude", "codex", "--dangerously-skip-permissions",
+                  "--dangerously-bypass-approvals-and-sandbox"),
+                 ("codex", "claude", "--yolo", "--dangerously-skip-permissions"),
+                 ("codex", "claude", "--dangerously-bypass-approvals-and-sandbox",
+                  "--dangerously-skip-permissions"))
+        for source, target, option, expected in cases:
+            with self.subTest(source=source, option=option):
+                argv = handoff.handoff_argv(source, target, [option], self.history(source))
+                self.assertIsNotNone(argv)
+                self.assertEqual(argv[:-1], [expected])
+        argv = handoff.handoff_argv("claude", "codex", ["--permission-mode", "bypassPermissions"],
+                                   self.history("claude"))
+        self.assertEqual(argv[:-1], ["--dangerously-bypass-approvals-and-sandbox"])
+
+    def test_unsupported_restrictive_modes_and_ambiguous_permissions_hold(self):
+        for mode in ("plan", "acceptEdits", "dontAsk", "auto", "unknown"):
+            with self.subTest(mode=mode):
+                self.assertIsNone(handoff.handoff_argv("claude", "codex", ["--permission-mode", mode],
+                                                       self.history("claude")))
+        conflicting = ["--dangerously-skip-permissions", "--permission-mode", "default"]
+        self.assertIsNone(handoff.handoff_argv("claude", "codex", conflicting, self.history("claude")))
+        for original in (["--sandbox", "read-only", "--ask-for-approval", "never"],
+                         ["--yolo", "--sandbox", "read-only", "--ask-for-approval", "on-request"]):
+            self.assertIsNone(handoff.handoff_argv("codex", "claude", original, self.history("codex")))
+
+    def test_custom_prompt_cannot_remove_exact_history_and_continuation_instructions(self):
+        for source, target in (("claude", "codex"), ("codex", "claude")):
+            with self.subTest(source=source):
+                history = self.history(source)
+                original = Path(history["path"]).read_bytes()
+                argv = handoff.handoff_argv(source, target, [], history,
+                                           prompt_override="Preserve the operator's extra instruction.")
+                prompt = argv[-1]
+                for value in (source, history["sid"], json.dumps(history["path"]), json.dumps(history["cwd"]),
+                              "Preserve the operator's extra instruction."):
+                    self.assertIn(value, prompt)
+                self.assertRegex(prompt.lower(), r"read.*history|history.*read")
+                self.assertRegex(prompt.lower(), r"background|subagent")
+                self.assertRegex(prompt.lower(), r"inspect|check")
+                self.assertRegex(prompt.lower(), r"inode[^0-9]*" + str(history["inode"]))
+                self.assertIn(str(history["offset"]), prompt)
+                self.assertNotIn("PRIVATE_SOURCE_TEXT_SENTINEL", prompt)
+                self.assertEqual(Path(history["path"]).read_bytes(), original)
+
+    def test_build_validates_history_before_constructing_any_target_argv(self):
+        for source, target in (("claude", "codex"), ("codex", "claude")):
+            with self.subTest(source=source):
+                history = self.history(source)
+                result = handoff.build_handoff(source, target, [], history["sid"], history["path"],
+                                               history["cwd"], inode=history["inode"])
+                self.assertIsNotNone(result)
+                self.assertEqual(result["history"], history)
+                self.assertIn(history["sid"], result["argv"][-1])
+                self.assertIsNone(handoff.build_handoff(source, target, [], fixtures.SID2, history["path"],
+                                                        history["cwd"]))
+
+    def test_same_provider_unknown_provider_and_unsupported_cli_modes_are_rejected(self):
+        history = self.history("claude")
+        for source, target, original in (("claude", "claude", []), ("claude", "other", []),
+                                          ("other", "codex", []), ("codex", "claude", []),
+                                          ("claude", "codex", ["--fork-session"]),
+                                          ("claude", "codex", ["-p", "Noninteractive task"]),
+                                          ("claude", "codex", None), ("claude", "codex", [None])):
+            with self.subTest(source=source, target=target, original=original):
+                self.assertIsNone(handoff.handoff_argv(source, target, original, history))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_autoresume_handoff_history.py

@@ -0,0 +1,115 @@
+"""Cross-provider history must identify one real main conversation before any restart."""
+
+import copy
+import json
+import os
+from pathlib import Path
+import tempfile
+import unittest
+
+import test_autoresume as fixtures
+import autoresume_handoff as handoff
+
+
+class HandoffHistoryTests(unittest.TestCase):
+    def setUp(self):
+        temporary = tempfile.TemporaryDirectory(prefix="ar-handoff-history-")
+        self.addCleanup(temporary.cleanup)
+        self.home = Path(temporary.name).resolve()
+        self.cwd = self.home / "project with 'quotes'"
+        self.cwd.mkdir()
+
+    def source(self, provider, records=None):
+        sid = fixtures.SID if provider == "claude" else fixtures.CX_SID
+        directory = self.home / provider / ("projects/project" if provider == "claude" else "sessions/2026/10/11")
+        directory.mkdir(parents=True, exist_ok=True)
+        filename = sid + ".jsonl" if provider == "claude" else "rollout-test-" + sid + ".jsonl"
+        path = directory / filename
+        if records is None:
+            records = [fixtures.cc_user(1000, "Source task content.", cwd=str(self.cwd))] if provider == "claude" else [
+                fixtures.cx_meta(1000, cwd=str(self.cwd)),
+                fixtures.cx_event(1001, {"type": "user_message", "message": "Source task content."})]
+        path.write_text("".join(json.dumps(record) + "\n" for record in records))
+        return sid, path
+
+    def test_both_main_history_formats_return_exact_file_identity(self):
+        for provider in ("claude", "codex"):
+            with self.subTest(provider=provider):
+                sid, path = self.source(provider)
+                result = handoff.validate_source(provider, sid, str(path), str(self.cwd))
+                self.assertIsNotNone(result)
+                self.assertEqual((result["provider"], result["sid"], result["cwd"]),
+                                 (provider, sid, str(self.cwd)))
+                self.assertEqual((result["path"], result["inode"], result["offset"]),
+                                 (str(path.resolve()), path.stat().st_ino, path.stat().st_size))
+
+    def test_wrong_session_and_replaced_inode_are_rejected(self):
+        for provider in ("claude", "codex"):
+            with self.subTest(provider=provider):
+                sid, path = self.source(provider)
+                self.assertIsNone(handoff.validate_source(provider, fixtures.SID2, str(path), str(self.cwd)))
+                inode = path.stat().st_ino
+                replacement = path.with_suffix(".replacement")
+                replacement.write_bytes(path.read_bytes())
+                replacement.replace(path)
+                self.assertNotEqual(path.stat().st_ino, inode)
+                self.assertIsNone(handoff.validate_source(provider, sid, str(path), str(self.cwd), inode=inode))
+
+    def test_codex_subagent_and_noninteractive_histories_are_rejected(self):
+        original = fixtures.cx_meta(1000, cwd=str(self.cwd))
+        alterations = ({"session_id": fixtures.CX_SID2}, {"source": {"subagent": "spawn"}},
+                       {"originator": "codex_exec"}, {"thread_source": "subagent"})
+        for change in alterations:
+            with self.subTest(change=change):
+                record = copy.deepcopy(original)
+                record["payload"].update(change)
+                sid, path = self.source("codex", [record])
+                self.assertIsNone(handoff.validate_source("codex", sid, str(path), str(self.cwd)))
+
+    def test_claude_sidechain_only_and_foreign_conversation_are_rejected(self):
+        records = [fixtures.cc_user(1000, "Subagent task.", cwd=str(self.cwd), isSidechain=True),
+                   fixtures.cc_user(1000, "Other conversation.", cwd=str(self.cwd), sessionId=fixtures.SID2)]
+        for record in records:
+            with self.subTest(sidechain=record["isSidechain"]):
+                sid, path = self.source("claude", [record])
+                self.assertIsNone(handoff.validate_source("claude", sid, str(path), str(self.cwd)))
+
+    def test_missing_directory_empty_and_malformed_histories_are_rejected(self):
+        for provider in ("claude", "codex"):
+            sid, path = self.source(provider)
+            fifo = path.parent / "not-a-history-fifo"
+            os.mkfifo(fifo)
+            for candidate in (path.parent / "absent.jsonl", path.parent, fifo):
+                with self.subTest(provider=provider, candidate=candidate.name):
+                    self.assertIsNone(handoff.validate_source(provider, sid, str(candidate), str(self.cwd)))
+            for text in ("", "not json\n", "[]\n", '{"type":"session_meta","payload":null}\n'):
+                with self.subTest(provider=provider, malformed=text):
+                    path.write_text(text)
+                    self.assertIsNone(handoff.validate_source(provider, sid, str(path), str(self.cwd)))
+
+    def test_shared_history_symlink_resolves_to_the_exact_source(self):
+        for provider in ("claude", "codex"):
+            with self.subTest(provider=provider):
+                sid, path = self.source(provider)
+                link = self.home / (provider + "-account-history.jsonl")
+                link.symlink_to(path)
+                result = handoff.validate_source(provider, sid, str(link), str(self.cwd))
+                self.assertIsNotNone(result)
+                self.assertEqual(result["path"], str(path.resolve()))
+
+    def test_invalid_provider_id_and_missing_working_directory_are_rejected(self):
+        sid, path = self.source("claude")
+        for provider, target_sid, cwd in (("other", sid, str(self.cwd)), ("claude", "--last", str(self.cwd)),
+                                          ("claude", sid, str(self.home / "absent"))):
+            with self.subTest(provider=provider, sid=target_sid, cwd=cwd):
+                self.assertIsNone(handoff.validate_source(provider, target_sid, str(path), cwd))
+
+    def test_claude_leading_progress_does_not_hide_valid_main_history(self):
+        records = [{"type": "progress", "data": {"type": "hook_progress"}},
+                   fixtures.cc_user(1000, "Main task.", cwd=str(self.cwd))]
+        sid, path = self.source("claude", records)
+        self.assertIsNotNone(handoff.validate_source("claude", sid, str(path), str(self.cwd)))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_autoresume_handoff_origins.py

@@ -0,0 +1,53 @@
+"""Main Codex TUI histories retain their original transport when resumed elsewhere."""
+
+import json
+from pathlib import Path
+import tempfile
+import unittest
+
+import test_autoresume as fixtures
+import autoresume_handoff as handoff
+
+
+class HandoffOriginTests(unittest.TestCase):
+    def setUp(self):
+        temporary = tempfile.TemporaryDirectory(prefix="ar-handoff-origins-")
+        self.addCleanup(temporary.cleanup)
+        self.cwd = Path(temporary.name).resolve()
+        self.path = self.cwd / ("rollout-origin-" + fixtures.CX_SID + ".jsonl")
+
+    def history(self, **changes):
+        record = fixtures.cx_meta(1000, cwd=str(self.cwd))
+        record["payload"].update(source="vscode", thread_source="user", originator="codex-tui")
+        record["payload"].update(changes)
+        self.path.write_text(json.dumps(record) + "\n")
+        return handoff.validate_source("codex", fixtures.CX_SID, str(self.path), str(self.cwd))
+
+    def test_user_tui_history_accepts_cli_and_vscode_transports(self):
+        for source in (None, "cli", "vscode"):
+            with self.subTest(source=source):
+                history = self.history(source=source)
+                self.assertIsNotNone(history)
+                self.assertEqual(history["sid"], fixtures.CX_SID)
+                self.assertEqual(history["path"], str(self.path))
+                self.assertEqual(history["inode"], self.path.stat().st_ino)
+                argv = handoff.handoff_argv("codex", "claude", ["--yolo"], history)
+                self.assertEqual(argv[:-1], ["--dangerously-skip-permissions"])
+                self.assertIn(fixtures.CX_SID, argv[-1])
+
+    def test_exec_unknown_and_subagent_transports_remain_rejected(self):
+        for source in ("exec", "unknown", "app-server", {"subagent": "spawn"}):
+            with self.subTest(source=source):
+                self.assertIsNone(self.history(source=source))
+
+    def test_vscode_transport_does_not_bypass_main_conversation_checks(self):
+        changes = ({"thread_source": "subagent"}, {"originator": "codex_exec"},
+                   {"originator": "unknown"}, {"session_id": fixtures.CX_SID2},
+                   {"id": fixtures.CX_SID2}, {"cwd": str(self.cwd / "unrelated")})
+        for fields in changes:
+            with self.subTest(fields=fields):
+                self.assertIsNone(self.history(**fields))
+
+
+if __name__ == "__main__":
+    unittest.main()