claude-multiacc 2.0.64 → 2.0.66

package/tests/test_codex_speed.py

@@ -0,0 +1,236 @@
+#!/usr/bin/env python3
+"""Account-specific speed, native argv, and quota-resume regression coverage."""
+
+from datetime import datetime, timezone
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "lib"))
+sys.path.insert(0, str(ROOT / "tests"))
+import codex_speed as cs
+import session_settings
+import autoresume as ar
+import test_codex_exec_stdin as stdin_fixtures
+from test_autoresume_relaunch_settings import shell_gate
+
+MODEL = "gpt-6.1-sol"
+NODE = stdin_fixtures.NODE
+SID = "01a135db-f14d-7a60-b656-d5ff72abd71d"
+
+
+def catalog(directory, ultra=False, model=MODEL, **changes):
+    document = {"fetched_at": datetime.now(timezone.utc).isoformat(), "identity": "native-account-identity",
+                "models": [{"slug": model, "visibility": "list", "priority": 0,
+                            "service_tiers": [{"id": "priority"}] + ([{"id": "ultrafast"}] if ultra else [])}]}
+    document.update(changes)
+    (Path(directory) / "models_cache.json").write_text(json.dumps(document))
+    return document
+
+
+class SpeedResolutionTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tmp.cleanup)
+        self.home = Path(self.tmp.name)
+
+    def test_capability_is_per_account_and_per_model(self):
+        catalog(self.home, ultra=True)
+        self.assertEqual(cs.resolve(self.home, "ultrafast", MODEL)["effective"], "ultrafast")
+        self.assertEqual(cs.resolve(self.home, "ultrafast", "other-model")["effective"], "fast")
+        catalog(self.home)
+        result = cs.resolve(self.home, "ultrafast", MODEL)
+        self.assertEqual((result["effective"], result["service_tier"], result["fallback"]),
+                         ("fast", "priority", True))
+
+    def test_stale_malformed_or_reauthenticated_catalog_cannot_grant_ultrafast(self):
+        for changes in ({"fetched_at": "2000-01-01T00:00:00Z"}, {"fetched_at": None}, {"models": None}):
+            catalog(self.home, ultra=True, **changes)
+            self.assertEqual(cs.resolve(self.home, "ultrafast", MODEL)["effective"], "fast")
+        catalog(self.home, ultra=True)
+        (self.home / "auth.json").write_text("{}")
+        future = (self.home / "models_cache.json").stat().st_mtime + 2
+        os.utime(self.home / "auth.json", (future, future))
+        self.assertEqual(cs.resolve(self.home, "ultrafast", MODEL)["effective"], "fast")
+
+    def test_service_tiers_are_authoritative_and_legacy_cache_is_supported(self):
+        doc = catalog(self.home)
+        row = doc["models"][0]
+        row.update(service_tiers=[], additional_speed_tiers=["fast", "ultrafast"])
+        self.assertEqual(cs.resolve(self.home, "ultrafast", MODEL, doc)["effective"], "fast")
+        del row["service_tiers"]
+        self.assertEqual(cs.resolve(self.home, "ultrafast", MODEL, doc)["effective"], "ultrafast")
+
+    def test_env_override_cli_precedence_and_prompt_fidelity(self):
+        catalog(self.home, ultra=True)
+        (self.home / "config.toml").write_text('model = "gpt-6.1-sol"\nservice_tier = "ultrafast"\n')
+        result, args = cs.launch_argv(self.home, ["exec", "--", "-c service_tier=ultrafast"],
+                                      {"CODEX_SPEED": "normal"})
+        self.assertEqual(result["effective"], "normal")
+        self.assertEqual(args, ["-c", "service_tier=default", "exec", "--", "-c service_tier=ultrafast"])
+        result, args = cs.launch_argv(self.home, ["-c", 'service_tier="fast"', "continue"],
+                                      {"CODEX_SPEED": "ultrafast"})
+        self.assertEqual(result["effective"], "fast")
+        self.assertNotIn('service_tier="fast"', args)
+        self.assertEqual(args[-1], "continue")
+
+    def test_app_server_model_hint_and_profile_defaults(self):
+        catalog(self.home, ultra=True)
+        (self.home / "config.toml").write_text('model="other-model"\n')
+        result, _ = cs.launch_argv(self.home, ["app-server"], {"CODEX_SPEED": "ultrafast", "CODEX_SPEED_MODEL": MODEL})
+        self.assertEqual(result["effective"], "ultrafast")
+        (self.home / "quick.config.toml").write_text('model="gpt-6.1-sol"\nservice_tier="fast"\n')
+        result, _ = cs.launch_argv(self.home, ["--profile", "quick", "continue"], {})
+        self.assertEqual(result["effective"], "fast")
+
+    def test_ignore_user_config_does_not_reintroduce_account_speed(self):
+        (self.home / "config.toml").write_text('service_tier="ultrafast"\n')
+        argv = ["exec", "--ignore-user-config", "do the work"]
+        result, args = cs.launch_argv(self.home, argv, {})
+        self.assertIsNone(result)
+        self.assertEqual(args, argv)
+        result, _ = cs.launch_argv(self.home, argv, {"CODEX_SPEED": "normal"})
+        self.assertEqual(result["effective"], "normal")
+
+    def test_normal_and_fast_never_request_catalog_refresh(self):
+        for choice in ("normal", "fast"):
+            result, args = cs.launch_argv(self.home, ["app-server"], {"CODEX_SPEED": choice}, executable="/missing")
+            self.assertEqual(result["effective"], choice)
+            self.assertIn("service_tier=" + ("default" if choice == "normal" else "fast"), args)
+
+    def test_cold_native_catalog_refresh_and_failure_fallback(self):
+        native = self.home / "native"
+        native.write_text(f'#!{sys.executable}\n' + '''import json,sys
+for line in sys.stdin:
+ request=json.loads(line)
+ if 'id' not in request: continue
+ result={'data':[{'id':'gpt-6.1-sol','serviceTiers':[{'id':'priority'},{'id':'ultrafast'}]}]} if request['method']=='model/list' else {}
+ print(json.dumps({'id':request['id'],'result':result}),flush=True)
+''')
+        native.chmod(0o755)
+        result, _ = cs.launch_argv(self.home, ["app-server"], {"CODEX_SPEED": "ultrafast", "CODEX_SPEED_MODEL": MODEL}, str(native))
+        self.assertEqual(result["effective"], "ultrafast")
+        catalog(self.home, ultra=True, fetched_at="2000-01-01T00:00:00Z")
+        result, _ = cs.launch_argv(self.home, ["app-server"], {"CODEX_SPEED": "ultrafast", "CODEX_SPEED_MODEL": MODEL}, "/missing")
+        self.assertEqual(result["effective"], "fast")
+
+    def test_native_resume_preparation_saves_only_speed_and_refuses_failed_writes(self):
+        native, requests = self.home / "native", self.home / "requests.jsonl"
+        native.write_text(f'#!{sys.executable}\n' + '''import json,sys,pathlib
+for line in sys.stdin:
+ request=json.loads(line)
+ if 'id' not in request: continue
+ with pathlib.Path(__file__).with_name('requests.jsonl').open('a') as log: log.write(json.dumps(request)+'\\n')
+ result={'serviceTier':request['params']['serviceTier']} if request['method']=='thread/resume' else {}
+ print(json.dumps({'id':request['id'],'result':result}),flush=True)
+''')
+        native.chmod(0o755)
+        result, args = cs.launch_argv(self.home, ["resume", SID, "continue now"], {"CODEX_SPEED": "normal"}, str(native))
+        calls = [json.loads(line) for line in requests.read_text().splitlines()]
+        self.assertEqual([call["method"] for call in calls], ["initialize", "thread/resume"])
+        self.assertEqual(calls[-1]["params"], {"threadId": SID, "serviceTier": "default"})
+        self.assertIn("service_tier=default", args)
+        with self.assertRaisesRegex(ValueError, "could not preserve speed"):
+            cs.launch_argv(self.home, ["resume", SID], {"CODEX_SPEED": "normal"}, "/missing")
+
+
+@unittest.skipUnless(NODE, "Node is required for the actual child-process transport")
+class SpeedShimTests(unittest.TestCase):
+    setUp = stdin_fixtures.CodexExecStdinTests.setUp
+    run_node = stdin_fixtures.CodexExecStdinTests.run_node
+
+    def prepare(self):
+        self.env["CLAUDE_MULTIACC_PYTHON"] = sys.executable
+        for number in (1, 2):
+            catalog(self.pool / f"acct-{number:02d}", ultra=number == 1)
+        native = self.root / "bin" / "codex"
+        source = native.read_text().split("\n", 1)[1]
+        native.write_text(f'#!{sys.executable}\n' + '''import sys,os,json,pathlib
+if sys.argv[1:2] == ['app-server']:
+ for line in sys.stdin:
+  request=json.loads(line)
+  if 'id' not in request: continue
+  result=json.loads((pathlib.Path(os.environ['CODEX_HOME'])/'models_cache.json').read_text()) if request['method']=='model/list' else {}
+  print(json.dumps({'id':request['id'],'result':result}),flush=True)
+ sys.exit(0)
+''' + source)
+
+    def test_ultrafast_quota_rotation_recomputes_target_capability(self):
+        self.prepare()
+        result, calls = self.run_node(CODEX_SPEED="ultrafast", CODEX_SPEED_MODEL=MODEL)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual([row["account"] for row in calls], ["acct-01", "acct-02"])
+        self.assertIn("service_tier=ultrafast", calls[0]["argv"])
+        self.assertIn("service_tier=priority", calls[1]["argv"])
+        self.assertNotIn("service_tier=ultrafast", calls[1]["argv"])
+
+    def test_normal_overrides_pinned_home_fast_and_single_word_prompts(self):
+        self.prepare()
+        home = self.pool / "acct-01"
+        (home / "config.toml").write_text('service_tier="fast"\n')
+        for pin in ({"CODEX_HOME": str(home)}, {"CODEX_ACCOUNT": "acct-01"}):
+            (self.root / "calls.jsonl").unlink(missing_ok=True)
+            result, calls = self.run_node(["continue"], FAKE_MODE="success", CODEX_SPEED="normal", **pin)
+            self.assertEqual(result.returncode, 0, result.stderr)
+            self.assertIn("service_tier=default", calls[0]["argv"])
+
+    def test_administrative_commands_and_disabled_shim_remain_unchanged(self):
+        self.prepare()
+        for args, extra in [(["login"], {}), (["exec", "--help"], {}), (["continue"], {"CODEX_MULTIACC_DISABLE": "1"})]:
+            (self.root / "calls.jsonl").unlink(missing_ok=True)
+            result, calls = self.run_node(args, CODEX_HOME=str(self.pool / "acct-01"),
+                                          FAKE_MODE="success", CODEX_SPEED="ultrafast", **extra)
+            self.assertEqual(result.returncode, 0, result.stderr)
+            self.assertEqual(calls[0]["argv"], args)
+
+    def test_invalid_explicit_speed_or_unavailable_helper_never_silently_launches(self):
+        self.prepare()
+        for extra in ({"CODEX_SPEED": "turbo"}, {"CODEX_SPEED": "normal", "CLAUDE_MULTIACC_PYTHON": "/missing"}):
+            result, calls = self.run_node(["continue"], CODEX_HOME=str(self.pool / "acct-01"), **extra)
+            self.assertEqual(result.returncode, 2, result.stderr)
+            self.assertFalse(calls)
+
+
+class ResumeSpeedTests(unittest.TestCase):
+    def test_history_restores_latest_own_tier_even_when_turn_context_omits_it(self):
+        with tempfile.TemporaryDirectory() as directory:
+            path = Path(directory) / "history.jsonl"
+            records = [
+                {"type": "session_meta", "payload": {"id": SID}},
+                {"type": "event_msg", "payload": {"type": "thread_settings_applied", "thread_id": SID,
+                    "thread_settings": {"model": MODEL, "reasoning_effort": "high", "service_tier": "ultrafast"}}},
+                {"type": "turn_context", "payload": {"model": MODEL, "effort": "low"}},
+                {"type": "event_msg", "payload": {"type": "thread_settings_applied", "thread_id": "other",
+                    "thread_settings": {"model": MODEL, "service_tier": "default"}}},
+            ]
+            path.write_text("".join(json.dumps(row) + "\n" for row in records))
+            self.assertEqual(session_settings.session_settings("codex", path),
+                             {"model": MODEL, "effort": "low", "speed": "ultrafast"})
+            isolated = subprocess.run([sys.executable, "-I", str(ROOT / "lib/session_settings.py"), "codex", str(path)],
+                                      capture_output=True, text=True)
+            self.assertEqual(isolated.returncode, 0, isolated.stderr)
+            self.assertEqual(json.loads(isolated.stdout), {"model": MODEL, "effort": "low", "speed": "ultrafast"})
+            records.append({"type": "turn_context", "payload": {"model": MODEL, "service_tier": None}})
+            path.write_text("".join(json.dumps(row) + "\n" for row in records))
+            self.assertEqual(session_settings.session_settings("codex", path)["speed"], "normal")
+
+    def test_relaunch_replaces_speed_without_losing_effort_and_both_gates_agree(self):
+        original = ["-m", MODEL, "-c", "model_reasoning_effort=low", "-c", 'service_tier="ultrafast"']
+        resumed = ar.relaunch_argv("codex", original, SID, "quota", settings={"speed": "normal"})
+        self.assertIn("model_reasoning_effort=low", resumed)
+        self.assertIn("service_tier=default", resumed)
+        self.assertNotIn('service_tier="ultrafast"', resumed)
+        for args in (original, resumed):
+            self.assertTrue(ar.argv_ok("codex", args))
+            gate = subprocess.run(["bash", "-c", shell_gate(), "gate", *args], capture_output=True)
+            self.assertEqual(gate.returncode, 0, gate.stderr)
+        self.assertIsNone(ar.relaunch_argv("claude", original, SID, "quota"))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_mutate_lock.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""Exercise real mutation-lock ownership when a failed mkdir races with release."""
+
+import os
+from pathlib import Path
+import subprocess
+import tempfile
+import unittest
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+class MutationLockTests(unittest.TestCase):
+    def run_shell(self, body):
+        with tempfile.TemporaryDirectory(prefix="multiacc-mutation-lock-") as directory:
+            root = Path(directory)
+            env = {"PATH": os.environ.get("PATH", "/usr/bin:/bin"), "HOME": str(root),
+                   "CLAUDE_ACCOUNTS_ROOT": str(root / "pool"), "MULTIACC_PROVIDER": "claude"}
+            script = '''set -u
+. "$1/lib/common.sh"
+lock="$ACC_ROOT/.locks/mutate"
+mkdir -p "$lock"
+''' + body
+            result = subprocess.run(["bash", "-c", script, "mutation-lock-test", str(ROOT)],
+                                    env=env, capture_output=True, text=True, timeout=10)
+            self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+
+    def test_acquisition_does_not_trust_nonexclusive_system_mkdir(self):
+        self.run_shell('''
+: > "$lock/competing-owner"
+mkdir() {
+  # uutils 0.10 can report success when a competing creator won. Model that
+  # behavior deterministically: mkdir -p accepts the other holder's directory.
+  command mkdir -p "$@"
+}
+sleep() {
+  [ -f "$lock/competing-owner" ] || exit 10
+  : > "$ACC_ROOT/waited-for-owner"
+  rm "$lock/competing-owner"
+  rmdir "$lock"
+}
+mutate_lock || exit 11
+[ -f "$ACC_ROOT/waited-for-owner" ] || exit 12
+[ -d "$lock" ] || exit 13
+mutate_unlock
+''')
+
+    def test_missing_stat_never_removes_a_replacement_owner(self):
+        self.run_shell('''
+file_mtime() {
+  # The first holder releases after our failed mkdir, before stat. A second
+  # holder acquires after that failed stat and before its zero reaches us.
+  rmdir "$1" || return 1
+  local observed
+  if [ "$(uname -s)" = Darwin ]; then
+    observed="$(stat -f %m "$1" 2>/dev/null || echo 0)"
+  else
+    observed="$(stat -c %Y "$1" 2>/dev/null || echo 0)"
+  fi
+  mkdir "$1" || return 1
+  : > "$1/replacement-owner"
+  printf '%s\\n' "$observed"
+}
+sleep() {
+  # Only the replacement owner's own release permits the waiter to acquire.
+  [ -f "$lock/replacement-owner" ] || exit 20
+  : > "$ACC_ROOT/owner-preserved"
+  rm "$lock/replacement-owner"
+  rmdir "$lock"
+}
+mutate_lock || exit 21
+[ -f "$ACC_ROOT/owner-preserved" ] || exit 22
+[ "$MUTATE_LOCK_HELD" = 1 ] || exit 23
+mutate_unlock
+[ ! -e "$lock" ]
+''')
+
+    def test_unreadable_mtime_uses_the_existing_backoff(self):
+        self.run_shell('''
+: > "$lock/owner"
+file_mtime() { printf 'unreadable\\n'; }
+waits=0
+sleep() {
+  [ -f "$lock/owner" ] || exit 30
+  waits=$((waits + 1))
+  if [ "$waits" = 2 ]; then rm "$lock/owner"; rmdir "$lock"; fi
+}
+mutate_lock || exit 31
+[ "$waits" = 2 ] || exit 32
+mutate_unlock
+''')
+
+    def test_observed_old_lock_remains_reclaimable(self):
+        self.run_shell('''
+: > "$lock/abandoned"
+file_mtime() { printf '1\\n'; }
+epoch_now() { printf '100\\n'; }
+sleep() { exit 40; }
+mutate_lock || exit 41
+[ "$MUTATE_LOCK_HELD" = 1 ] || exit 42
+[ ! -e "$lock/abandoned" ] || exit 43
+mutate_unlock
+''')
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_shim_path.py

@@ -40,6 +40,39 @@ def legacy_block(repo_dir):
     return '\n'.join(lines[:3] + [MARK_END]) + '\n'
 
 
+class ShimPathParserTests(unittest.TestCase):
+    def test_complete_osc_shell_integration_wraps_answers(self):
+        marker = shim_path.SENTINEL
+        for terminator in ('\x07', '\x1b\\'):
+            with self.subTest(terminator=repr(terminator)):
+                start = '\x1b]3008;start=fixture' + terminator
+                end = '\x1b]3008;end=fixture' + terminator
+                text = (f'{start}{start}{marker} claude=/pool/claude{end}\n'
+                        f'{start}{marker} codex=/pool/codex{end}{end}\n')
+                self.assertEqual(shim_path._parse(text, shim_path.NAMES),
+                                 {'claude': '/pool/claude', 'codex': '/pool/codex'})
+
+    def test_osc_removal_keeps_strict_framing_and_first_answer(self):
+        marker = shim_path.SENTINEL
+        text = (f'\x1b]3008;{marker} claude=/inside-control\x07\n'
+                f'echo "{marker} claude=/echoed"\n'
+                f'prompt {marker} claude=/prompt\n'
+                f'\x1b]3008;start=x\x07{marker} claude=/first\n'
+                f'{marker} claude=/later\n'
+                f'{marker} codex=/plain\n')
+        self.assertEqual(shim_path._parse(text, shim_path.NAMES),
+                         {'claude': '/first', 'codex': '/plain'})
+
+    def test_incomplete_osc_cannot_consume_another_line(self):
+        marker = shim_path.SENTINEL
+        text = (f'\x1b]3008;partial {marker} claude=/unframed\n'
+                f'{marker} claude=/complete\n'
+                f'\x1b]broken\x1b[31m{marker} codex=/malformed\n'
+                f'\x1b]3008;start=x\x1b\\{marker} codex=/complete\n')
+        self.assertEqual(shim_path._parse(text, shim_path.NAMES),
+                         {'claude': '/complete', 'codex': '/complete'})
+
+
 class ShimPathTests(unittest.TestCase):
     def setUp(self):
         self.tmp = Path(tempfile.mkdtemp(prefix='multiacc-shim-path-'))
@@ -212,12 +245,19 @@ class ShimPathTests(unittest.TestCase):
         block = installed_block(self.repo)
         for rc in ('.zshenv', '.zprofile', '.zshrc', '.profile'):
             self.write(rc, block)
-        before = sorted(p.name for p in self.home.iterdir())
         self.probe()
-        after = sorted(p.name for p in self.home.iterdir())
-        self.assertEqual(before, after)
-        for hist in ('.zsh_history', '.bash_history', '.sh_history'):
+        histories = ('.zsh_history', '.bash_history', '.sh_history')
+        for hist in histories:
             self.assertFalse((self.home / hist).exists(), hist)
+        # System rc files may create unrelated completion caches such as
+        # .zcompdump. The guarantee is that probe commands neither create history
+        # nor change history the operator already has.
+        prior = b'echo existing-user-history\n'
+        for hist in histories:
+            (self.home / hist).write_bytes(prior)
+        self.probe()
+        for hist in histories:
+            self.assertEqual((self.home / hist).read_bytes(), prior, hist)
 
     def test_rc_that_reads_stdin_costs_an_answer_not_a_verdict(self):
         """A prompt or `read` in an rc file eats one line of the fed script. The lost