claude-multiacc 2.0.53 → 2.0.55

package/tests/test_autoresume_tmux.py

@@ -0,0 +1,100 @@
+"""Actual tmux + shell + production shim/watcher, with a disposable fake Codex TUI."""
+
+import os
+import signal
+import time
+import unittest
+
+from autoresume_tmux_support import SID, TMUX, TmuxScenario
+
+QUOTA = {"message": "You've hit your usage limit. Try again later.",
+         "codex_error_info": "usage_limit_exceeded"}
+
+
+@unittest.skipUnless(TMUX, "real tmux is unavailable")
+class RealTmuxTests(unittest.TestCase):
+    def scenario(self, args=None, **environment):
+        case = TmuxScenario(**environment)
+        self.addCleanup(case.close)
+        case.start(args)
+        return case
+
+    def assert_rotated(self, case):
+        case.wait(lambda: len(case.records("ready")) == 2, "same session resumed on another account")
+        case.wait(lambda: "autoresume switch" in case.log.read_text(), "watcher confirms switch")
+        first, second = case.records("launch")
+        self.assertEqual((first["account"], second["account"]), ("acct-01", "acct-02"))
+        arguments = [arg for arg in second["argv"] if arg != "--no-daemon"]
+        self.assertEqual(arguments[:3], ["resume", "--yolo", SID])
+        self.assertIn("Continue", second["argv"][-1])
+        self.assertEqual(first["cwd"], second["cwd"])
+        self.assertEqual(case.records("keys"), [], "no keystroke may reach either TUI")
+        self.assertEqual(case.records("signal")[0]["signal"], signal.SIGTERM)
+        self.assertIn("error-cooldown", (case.pool / "acct-01/.limited").read_text())
+        self.assertEqual(list((case.pool / "tmp/autoresume").glob("r-*")), [])
+
+    def test_legacy_quota_resumes_same_session_and_prompt(self):
+        case = self.scenario(FAKE_LEGACY="1")
+        case.append({"type": "task_complete", "error": QUOTA})
+        self.assert_rotated(case)
+
+    def test_modern_client_runs_locally_and_resumes_same_session(self):
+        case = self.scenario()
+        case.append({"type": "task_complete", "error": QUOTA})
+        self.assert_rotated(case)
+        self.assertTrue(all("--no-daemon" in row["argv"] for row in case.records("launch")))
+
+    def test_quota_hold_leaves_tui_untouched_then_recovers(self):
+        case = self.scenario()
+        marker = case.pool / "acct-02/.limited"
+        marker.write_text(f"{int(time.time()) + 3600}\nbucket=error-cooldown reason=error-cooldown\n")
+        case.append({"type": "task_complete", "error": QUOTA})
+        case.wait(lambda: "autoresume hold" in case.log.read_text(), "no-room hold")
+        self.assertEqual((case.records("signal"), case.records("keys")), ([], []))
+        marker.unlink()
+        self.assert_rotated(case)
+
+    def test_user_message_cancels_pending_quota(self):
+        case = self.scenario(CODEX_MULTIACC_AR_GRACE="1.5")
+        case.append({"type": "task_complete", "error": QUOTA})
+        case.wait(lambda: "autoresume detect" in case.log.read_text(), "quota detected")
+        case.append({"type": "user_message", "message": "I will continue manually"})
+        time.sleep(2)
+        self.assertEqual((case.records("signal"), case.records("keys")), ([], []))
+        self.assertEqual(len(case.records("launch")), 1)
+
+    def test_interrupted_turn_cancels_then_next_quota_still_recovers(self):
+        case = self.scenario(CODEX_MULTIACC_AR_GRACE="1.5")
+        case.append({"type": "task_complete", "error": QUOTA})
+        case.wait(lambda: "autoresume detect" in case.log.read_text(), "quota detected")
+        case.append({"type": "turn_aborted", "reason": "interrupted"})
+        time.sleep(2)
+        self.assertEqual((case.records("signal"), case.records("keys")), ([], []))
+        case.append({"type": "task_complete", "error": QUOTA})
+        self.assert_rotated(case)
+
+    def test_normal_completion_and_old_quota_do_not_restart(self):
+        case = self.scenario()
+        case.append({"type": "task_complete", "error": QUOTA}, age=60)
+        case.append({"type": "task_complete", "last_agent_message": "Finished successfully"})
+        time.sleep(1.5)
+        self.assertNotIn("autoresume detect", case.log.read_text())
+        self.assertEqual((case.records("signal"), case.records("keys")), ([], []))
+
+    def test_synchronized_panes_refuse_without_stopping_or_typing(self):
+        case = self.scenario()
+        case.tmux("set-window-option", "-t", case.pane, "synchronize-panes", "on")
+        case.append({"type": "task_complete", "error": QUOTA})
+        case.wait(lambda: "autoresume giveup" in case.log.read_text(), "unsafe pane refused")
+        self.assertIn("reason=sync", case.log.read_text())
+        self.assertEqual((case.records("signal"), case.records("keys")), ([], []))
+        os.kill(case.records("launch")[0]["pid"], 0)
+
+    def test_unresponsive_client_is_killed_then_resumed(self):
+        case = self.scenario(FAKE_IGNORE_TERM="1")
+        case.append({"type": "task_complete", "error": QUOTA})
+        self.assert_rotated(case)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_autoresume_tmux_modes.py

@@ -0,0 +1,80 @@
+"""Real-tmux launch modes, kill switches and proof that a resumed prompt was consumed."""
+
+import time
+import unittest
+
+from autoresume_tmux_support import SID, TMUX, TmuxScenario
+
+QUOTA = {"type": "task_complete", "error": {"message": "You've hit your usage limit.",
+                                           "codex_error_info": "usage_limit_exceeded"}}
+
+
+@unittest.skipUnless(TMUX, "real tmux is unavailable")
+class RealTmuxModesTests(unittest.TestCase):
+    def scenario(self, args=None, supervised=True, **environment):
+        case = TmuxScenario(**environment)
+        self.addCleanup(case.close)
+        case.start(args, supervised=supervised)
+        return case
+
+    def test_resume_id_and_last_preserve_session_and_submit_prompt(self):
+        for target in (SID, "--last"):
+            with self.subTest(target=target):
+                case = self.scenario(["--yolo", "resume", target])
+                case.append(QUOTA)
+                case.wait(lambda: len(case.records("prompt")) == 1, "resume prompt submitted")
+                case.wait(lambda: "autoresume switch" in case.log.read_text(), "switch receipt")
+                first, second = case.records("launch")
+                self.assertEqual((first["account"], second["account"]), ("acct-01", "acct-02"))
+                self.assertIn(SID, second["argv"])
+                self.assertNotIn("--last", second["argv"])
+                self.assertEqual(case.records("keys"), [])
+                case.close()
+
+    def test_explicit_no_daemon_is_supported_and_not_duplicated(self):
+        case = self.scenario(["--no-daemon", "--yolo"])
+        case.append(QUOTA)
+        case.wait(lambda: "autoresume switch" in case.log.read_text(), "explicit local-mode restart")
+        self.assertEqual([row["argv"].count("--no-daemon") for row in case.records("launch")], [1, 1])
+        self.assertEqual(case.records("keys"), [])
+
+    def test_bare_codex_launch_resumes_without_empty_array_failure(self):
+        case = self.scenario([])
+        case.append(QUOTA)
+        case.wait(lambda: "autoresume switch" in case.log.read_text(), "bare command restart")
+        first, second = case.records("launch")
+        self.assertEqual(first["argv"], ["--no-daemon"])
+        self.assertEqual(second["argv"][:3], ["resume", "--no-daemon", SID])
+        self.assertEqual(case.records("prompt")[0]["text"], second["argv"][-1])
+        self.assertEqual(case.records("keys"), [])
+
+    def test_environment_kill_switch_preserves_daemon_mode(self):
+        case = self.scenario(supervised=False, CODEX_MULTIACC_AUTORESUME="0")
+        case.append(QUOTA)
+        time.sleep(1)
+        self.assertNotIn("--no-daemon", case.records("launch")[0]["argv"])
+        self.assertNotIn("autoresume watch", case.log.read_text())
+        self.assertEqual((case.records("signal"), case.records("keys")), ([], []))
+
+    def test_pool_kill_switch_stops_existing_watcher(self):
+        case = self.scenario()
+        (case.pool / "autoresume.off").touch()
+        case.wait(lambda: not list((case.pool / "tmp/autoresume").glob("*.state")), "watcher stopped")
+        case.append(QUOTA)
+        time.sleep(1)
+        self.assertEqual((case.records("signal"), case.records("keys")), ([], []))
+
+    def test_missing_resume_prompt_is_reported_as_failed_handoff(self):
+        case = self.scenario(FAKE_DROP_PROMPT="1")
+        case.append(QUOTA)
+        case.wait(lambda: len(case.records("ready")) >= 2, "resumed client launched")
+        case.wait(lambda: "stopped=1" in case.log.read_text(), "missing prompt reported", timeout=20)
+        self.assertNotIn("autoresume switch", case.log.read_text())
+        self.assertEqual(case.log.read_text().count("autoresume detect"), 1)
+        self.assertEqual(len(case.records("launch")), 2)
+        self.assertEqual(case.records("prompt"), [])
+        self.assertEqual(case.records("keys"), [])
+
+
+if __name__ == "__main__":
+    unittest.main()