claude-multiacc 2.0.57 → 2.0.58

package/docs/AUTORESUME-HANDOFF.md

@@ -28,6 +28,8 @@ available; a Codex ID is never passed as a Claude native `--resume` ID, or vice
 The watcher uses the history already bound to the source client. It does not guess from
 the newest transcript or directory name. Invalid, ambiguous or unavailable source
 history prevents the handoff before the source client is stopped.
+Codex main conversations marked `source=cli` or `source=vscode` are supported when
+resumed in a supervised TUI; their exact conversation and file identity still must match.
 
 If another live client holds the same source conversation, the watcher holds to avoid
 creating duplicate destination conversations. Stale process records do not count.

package/lib/autoresume_handoff.py

@@ -52,7 +52,7 @@ def _codex_identity(data, sid, cwd):
     meta = record.get("payload")
     if not isinstance(meta, dict) or meta.get("id") != sid or meta.get("session_id") != sid:
         return False
-    if meta.get("source") not in (None, "cli") or meta.get("thread_source") not in (None, "user"):
+    if meta.get("source") not in (None, "cli", "vscode") or meta.get("thread_source") not in (None, "user"):
         return False
     if meta.get("originator") not in (None, "codex-tui", "codex_cli_rs", "codex_cli"):
         return False

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-multiacc",
-  "version": "2.0.57",
+  "version": "2.0.58",
   "description": "Unified Claude Code and OpenAI Codex subscription pooling with quota-aware selection.",
   "type": "module",
   "bin": {

package/tests/fixtures/cross_provider_cli.py

@@ -75,7 +75,8 @@ def initialize_history(account, sid):
         if PROVIDER == "codex":
             history.write(json.dumps({"timestamp": timestamp(), "type": "session_meta", "payload": {
                 "id": sid, "session_id": sid, "timestamp": timestamp(),
-                "cwd": os.getcwd(), "source": "cli"}}) + "\n")
+                "cwd": os.getcwd(), "source": os.environ.get("FAKE_CODEX_SOURCE", "cli"),
+                "thread_source": "user", "originator": "codex-tui"}}) + "\n")
         history.write(json.dumps(user_record(sid, "Complete the synthetic acceptance task.")) + "\n")
     prompt = sys.argv[-1] if len(sys.argv) > 1 and " " in sys.argv[-1] else ""
     if prompt and os.environ.get("FAKE_DROP_PROMPT") != PROVIDER:

package/tests/test_autoresume_cross_origin.py

@@ -0,0 +1,70 @@
+"""Native TUI vscode rollout metadata survives account rotation and provider handoff."""
+
+import json
+from pathlib import Path
+import unittest
+
+from autoresume_cross_tmux_support import CrossScenario, TMUX
+
+
+@unittest.skipUnless(TMUX, "real tmux is unavailable")
+class CrossOriginTmuxTests(unittest.TestCase):
+    def scenario(self, provider):
+        case = CrossScenario(FAKE_CODEX_SOURCE="vscode")
+        self.addCleanup(case.close)
+        case.start(provider)
+        return case
+
+    def assert_vscode_main_history(self, ready):
+        metadata = json.loads(Path(ready["path"]).read_text().splitlines()[0])["payload"]
+        self.assertEqual(metadata["id"], ready["sid"])
+        self.assertEqual(metadata["session_id"], ready["sid"])
+        self.assertEqual(metadata["source"], "vscode")
+        self.assertEqual(metadata["thread_source"], "user")
+        self.assertEqual(metadata["originator"], "codex-tui")
+
+    def test_vscode_tui_rotates_codex_account_then_continues_exact_history_in_claude(self):
+        case = self.scenario("codex")
+        first = case.records("ready")[0]
+        self.assert_vscode_main_history(first)
+        case.quota()
+        case.wait(lambda: len(case.records("ready")) == 2, "same-provider account rotation")
+        case.wait(lambda: "autoresume switch" in case.logs("codex"), "same-provider continuation receipt")
+        second = case.records("ready")[1]
+        self.assertEqual((second["provider"], second["sid"]), ("codex", first["sid"]))
+        self.assertEqual(second["path"], first["path"])
+        self.assertEqual([row["account"] for row in case.records("launch")], ["acct-01", "acct-02"])
+        case.park("codex", ("acct-01",))
+        case.quota(second)
+        case.wait(lambda: len(case.records("ready")) == 3, "exhausted Codex pool transfers to Claude")
+        case.wait(lambda: case.logs("codex").count("autoresume switch") == 2, "cross-provider prompt receipt")
+        target = case.records("ready")[2]
+        prompt = case.records("prompt")[-1]
+        self.assertEqual((target["provider"], prompt["provider"]), ("claude", "claude"))
+        self.assertNotEqual(target["sid"], first["sid"])
+        self.assertIn(first["sid"], prompt["text"])
+        self.assertIn(first["path"], prompt["text"])
+        self.assertIn(str(case.work), prompt["text"])
+        self.assertEqual(prompt["sid"], target["sid"])
+        self.assertEqual(case.records("keys"), [])
+
+    def test_claude_handoff_confirms_new_codex_vscode_main_history(self):
+        case = self.scenario("claude")
+        source = case.records("ready")[0]
+        case.park("claude")
+        case.quota()
+        case.wait(lambda: len(case.records("ready")) == 2, "new Codex TUI starts")
+        target = case.records("ready")[1]
+        self.assert_vscode_main_history(target)
+        case.wait(lambda: "autoresume switch" in case.logs("claude"), "vscode target prompt receipt")
+        prompt = case.records("prompt")[-1]
+        self.assertEqual((target["provider"], prompt["provider"]), ("codex", "codex"))
+        self.assertNotEqual(target["sid"], source["sid"])
+        self.assertIn(source["sid"], prompt["text"])
+        self.assertIn(source["path"], prompt["text"])
+        self.assertEqual(prompt["sid"], target["sid"])
+        self.assertEqual(case.records("keys"), [])
+
+
+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()