claude-multiacc 2.0.61 → 2.0.65

package/lib/codex_speed.py

@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+"""Resolve Codex speed from the selected account's native model catalog.
+
+Capabilities belong to an account AND a model. Never use the merged pool catalog,
+an e-mail address, a plan-name guess, or another account's cache for entitlement.
+Every Ultrafast launch asks the native account client to validate its model
+catalog. Unknown access falls back to Fast; later launches discover new access.
+"""
+
+import argparse
+from datetime import datetime, timezone
+import json
+import os
+from pathlib import Path
+import re
+import selectors
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+
+CACHE_SECONDS = 300
+PROBE_SECONDS = 5
+
+SPEEDS = ("normal", "fast", "ultrafast")
+ALIASES = {"normal": "normal", "default": "normal", "standard": "normal",
+           "fast": "fast", "priority": "fast", "ultrafast": "ultrafast"}
+
+
+def speed(value):
+    return ALIASES.get(value) if isinstance(value, str) else None
+
+
+def _json(path):
+    try:
+        value = json.loads(Path(path).read_text())
+        return value if isinstance(value, dict) else {}
+    except (OSError, ValueError):
+        return {}
+
+
+def _config(path):
+    try:
+        source = Path(path).read_text()
+    except OSError:
+        return {}
+    try:
+        import tomllib
+        return tomllib.loads(source)
+    except ImportError:
+        # Older Python is supported by the shims. Read only simple top-level scalar
+        # keys; complex TOML is left to the native client, never guessed.
+        top = source.split("\n[", 1)[0]
+        return dict(re.findall(r'''(?m)^\s*(model|service_tier|profile)\s*=\s*["']([^"'\n]*)["']\s*(?:#.*)?$''', top))
+    except ValueError:
+        return {}
+
+
+def configuration(account_dir, profile=None):
+    document = _config(Path(account_dir) / "config.toml")
+    profile = profile or document.get("profile")
+    if isinstance(profile, str) and re.fullmatch(r"[A-Za-z0-9_.-]+", profile):
+        profiles = document.get("profiles")
+        old = profiles.get(profile) if isinstance(profiles, dict) else None
+        if isinstance(old, dict):
+            document.update(old)
+        document.update(_config(Path(account_dir) / (profile + ".config.toml")))
+    return document
+
+
+def current_catalog(account_dir):
+    """A recent native cache, invalidated when this slot's login is replaced."""
+    cache = Path(account_dir) / "models_cache.json"
+    document = _json(cache)
+    try:
+        if not isinstance(document.get("fetched_at"), str):
+            return {}
+        fetched = datetime.fromisoformat(document["fetched_at"].replace("Z", "+00:00"))
+        if fetched.tzinfo is None:
+            fetched = fetched.replace(tzinfo=timezone.utc)
+        age = time.time() - fetched.timestamp()
+        if not 0 <= age <= CACHE_SECONDS:
+            return {}
+        auth = Path(account_dir) / "auth.json"
+        if auth.exists() and auth.stat().st_mtime > cache.stat().st_mtime:
+            return {}
+        return document
+    except (KeyError, OSError, TypeError, ValueError):
+        return {}
+
+
+def native_request(account_dir, executable, method, params, timeout=PROBE_SECONDS, isolated=True):
+    """One bounded task-free native request, with its own process group and index.
+
+    Temporary sqlite_home prevents a stopped probe from stranding the account's
+    rollout-backfill lease. Resume settings persist in the native rollout and
+    are read back by the real CLI using its regular index.
+    """
+    if not executable:
+        return {}
+    env = dict(os.environ, CODEX_HOME=str(account_dir), CODEX_MULTIACC_DISABLE="1", CODEX_SHIM_ACTIVE="1")
+    proc, scratch = None, None
+    try:
+        command = [executable, "app-server", "--listen", "stdio://"]
+        if isolated:
+            scratch = tempfile.TemporaryDirectory(prefix="codex-speed-catalog-")
+            command += ["-c", "sqlite_home=" + json.dumps(scratch.name)]
+        proc = subprocess.Popen(command,
+                                stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
+                                env=env, start_new_session=True, close_fds=True)
+        deadline, pending = time.monotonic() + timeout, b""
+        with selectors.DefaultSelector() as poll:
+            poll.register(proc.stdout, selectors.EVENT_READ)
+            requests = [
+                {"id": 1, "method": "initialize", "params": {
+                    "clientInfo": {"name": "claude-multiacc", "version": "1"},
+                    "capabilities": {"experimentalApi": True}}},
+                {"id": 2, "method": method, "params": params},
+            ]
+            for request in requests:
+                proc.stdin.write((json.dumps(request) + "\n").encode())
+                proc.stdin.flush()
+                answer = None
+                while answer is None and time.monotonic() < deadline:
+                    if b"\n" not in pending:
+                        if not poll.select(max(0, deadline - time.monotonic())):
+                            return {}
+                        chunk = os.read(proc.stdout.fileno(), 65536)
+                        if not chunk:
+                            return {}
+                        pending += chunk
+                        if len(pending) > 8 << 20:
+                            return {}
+                    while b"\n" in pending:
+                        line, pending = pending.split(b"\n", 1)
+                        try:
+                            message = json.loads(line)
+                        except ValueError:
+                            continue
+                        if isinstance(message, dict) and message.get("id") == request["id"]:
+                            answer = message
+                            break
+                if not answer or "error" in answer:
+                    return {}
+                if request["id"] == 1:
+                    proc.stdin.write(b'{"method":"initialized","params":{}}\n')
+                    proc.stdin.flush()
+                else:
+                    result = answer.get("result")
+                    return result if isinstance(result, dict) else {}
+    except (OSError, ValueError, subprocess.SubprocessError):
+        return {}
+    finally:
+        if proc is not None:
+            try:
+                os.killpg(proc.pid, signal.SIGTERM)
+            except ProcessLookupError:
+                pass
+            try:
+                proc.communicate(timeout=0.5)
+            except subprocess.TimeoutExpired:
+                try:
+                    os.killpg(proc.pid, signal.SIGKILL)
+                except ProcessLookupError:
+                    pass
+                proc.communicate()
+        if scratch is not None:
+            scratch.cleanup()
+
+
+def refresh_catalog(account_dir, executable, timeout=PROBE_SECONDS):
+    """Native Codex validates the account identity before granting Ultrafast.
+
+    Even a fresh cache could have been copied from another account. Every native
+    Ultrafast launch asks the account client; inspection without a native binary
+    can read cache metadata but cannot authorize an actual launch.
+    """
+    if executable is None:
+        return None
+    return native_request(account_dir, executable, "model/list", {"includeHidden": True}, timeout) or {}
+
+
+def resume_target(argv):
+    """The exact UUID a native resume names; never infer a picker/--last target."""
+    values = {"-c", "--config", "-m", "--model", "-p", "--profile", "-C", "--cd", "-s", "--sandbox",
+              "-a", "--ask-for-approval", "--enable", "--disable", "--output-schema", "-o",
+              "--output-last-message", "--image", "-i", "--color", "--add-dir"}
+    waiting, resume = False, False
+    for arg in argv:
+        if waiting:
+            waiting = False
+            continue
+        if arg == "--":
+            break
+        if arg in values:
+            waiting = True
+            continue
+        if arg.startswith("-"):
+            continue
+        if arg == "resume":
+            resume = True
+            continue
+        if resume:
+            return arg if re.fullmatch(r"[0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}", arg) else None
+        if arg not in ("exec", "e"):
+            return None
+    return None
+
+
+def persist_resume_speed(account_dir, executable, argv, result):
+    """Codex 0.164 restores saved thread tiers ahead of process config on resume.
+
+    Set the named thread's tier through its native API before the real CLI resumes
+    it. No turn is sent, no prompt is replayed, and model/effort/permissions stay
+    native thread defaults. A failed write cancels instead of silently using the
+    wrong (possibly more expensive) speed.
+    """
+    thread_id = resume_target(argv)
+    if not thread_id or not executable:
+        return
+    response = native_request(account_dir, executable, "thread/resume",
+                              {"threadId": thread_id, "serviceTier": result["service_tier"]},
+                              timeout=30)
+    if not response or speed(response.get("serviceTier")) != result["effective"]:
+        raise ValueError("could not preserve speed in the resumed Codex thread; retry the launch")
+
+
+def resolve(account_dir, requested, model=None, catalog=None):
+    """Return safe public launch metadata, with no credentials or account identity."""
+    if requested not in SPEEDS:
+        raise ValueError("speed must be normal, fast, or ultrafast")
+    document = catalog if isinstance(catalog, dict) else current_catalog(account_dir)
+    models = document.get("models", document.get("data", []))
+    models = models if isinstance(models, list) else []
+    if not model:
+        model = configuration(account_dir).get("model")
+    if not model:
+        listed = [row for row in models if isinstance(row, dict) and
+                  (row.get("visibility") == "list" or row.get("isDefault"))]
+        listed.sort(key=lambda row: (not bool(row.get("isDefault")),
+                                    row.get("priority") if isinstance(row.get("priority"), int) else 1000))
+        if listed:
+            model = listed[0].get("slug", listed[0].get("id"))
+    row = next((row for row in models if isinstance(row, dict) and
+                row.get("slug", row.get("id")) == model), {})
+    tiers = row.get("service_tiers", row.get("serviceTiers"))
+    # service_tiers is authoritative when present, including an explicitly empty
+    # list. additional_speed_tiers is the older native catalog representation.
+    advertised = ([item.get("id") for item in tiers if isinstance(item, dict)]
+                  if isinstance(tiers, list) else row.get("additional_speed_tiers", []))
+    supported = {speed(item) for item in advertised if isinstance(item, str)}
+    effective = "fast" if requested == "ultrafast" and "ultrafast" not in supported else requested
+    service_tier = {"normal": "default", "fast": "fast", "ultrafast": "ultrafast"}[effective]
+    # Current native catalogs call Fast 'priority'. Use the account's actual id.
+    if effective == "fast" and "priority" in advertised:
+        service_tier = "priority"
+    return {"requested": requested, "effective": effective, "service_tier": service_tier,
+            "model": model, "ultrafast_available": "ultrafast" in supported,
+            "fallback": requested != effective}
+
+
+def launch_argv(account_dir, argv, environ=None, executable=None):
+    """Apply one explicit speed override without changing prompts or unrelated flags.
+
+    CLI overrides win over CODEX_SPEED, which wins over account/profile defaults.
+    This lets an autoresume's history pin replace a launch's inherited environment.
+    """
+    env = os.environ if environ is None else environ
+    kept, overrides, model, profile, i = [], {}, None, None, 0
+    ignore_user_config = False
+    while i < len(argv):
+        arg = argv[i]
+        if arg == "--":
+            kept.extend(argv[i:])
+            break
+        if arg == "--ignore-user-config":
+            ignore_user_config = True
+        consumed, override = 1, None
+        if arg in ("-c", "--config") and i + 1 < len(argv):
+            consumed, override = 2, argv[i + 1]
+        elif arg.startswith("--config="):
+            override = arg.split("=", 1)[1]
+        elif arg.startswith("-c") and len(arg) > 2:
+            override = arg[2:]
+        if override is not None and "=" in override:
+            key, value = override.split("=", 1)
+            key, value = key.strip(), value.strip().strip("\"'")
+            if key in ("model", "service_tier", "features.fast_mode"):
+                overrides[key] = value
+            if (key == "service_tier" and speed(value)) or key == "features.fast_mode":
+                i += consumed
+                continue
+        if arg in ("-m", "--model", "-p", "--profile") and i + 1 < len(argv):
+            if arg in ("-m", "--model"):
+                model = argv[i + 1]
+            else:
+                profile = argv[i + 1]
+            consumed = 2
+        elif arg.startswith("--model="):
+            model = arg.split("=", 1)[1]
+        elif arg.startswith("--profile="):
+            profile = arg.split("=", 1)[1]
+        kept.extend(argv[i:i + consumed])
+        i += consumed
+    config = {} if ignore_user_config else configuration(account_dir, profile)
+    if "service_tier" in overrides and speed(overrides["service_tier"]) is None:
+        return None, list(argv)
+    requested = (speed(overrides.get("service_tier")) or env.get("CODEX_SPEED") or
+                 speed(config.get("service_tier")))
+    if not requested:
+        return None, list(argv)
+    model = model or overrides.get("model") or env.get("CODEX_SPEED_MODEL") or config.get("model")
+    fresh = refresh_catalog(account_dir, executable) if requested == "ultrafast" else None
+    result = resolve(account_dir, requested, model, fresh)
+    flags = ["-c", "service_tier=" + result["service_tier"]]
+    if result["effective"] != "normal":
+        flags += ["-c", "features.fast_mode=true"]
+    persist_resume_speed(account_dir, executable, argv, result)
+    return result, flags + kept
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--account-dir", required=True)
+    parser.add_argument("--model")
+    parser.add_argument("--speed", choices=SPEEDS)
+    parser.add_argument("--json", action="store_true")
+    parser.add_argument("--launch-argv", action="store_true")
+    parser.add_argument("--native-cli", default="")
+    parser.add_argument("argv", nargs=argparse.REMAINDER)
+    args = parser.parse_args(argv)
+    if args.launch_argv:
+        native = args.argv[1:] if args.argv[:1] == ["--"] else args.argv
+        result, native = launch_argv(args.account_dir, native, executable=args.native_cli)
+        values = [result["effective"] if result else "", *(native or [])]
+        sys.stdout.buffer.write(b"\0".join(os.fsencode(value) for value in values) + b"\0")
+    else:
+        requested = args.speed or "normal"
+        fresh = refresh_catalog(args.account_dir, args.native_cli) if requested == "ultrafast" else None
+        result = resolve(args.account_dir, requested, args.model, fresh)
+        print(json.dumps(result) if args.json else result["effective"])
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except ValueError as error:
+        print("codex speed: " + str(error), file=sys.stderr)
+        sys.exit(2)

package/lib/codex_speed.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+# Read-only, per-launch speed selection. Never rewrites account configuration.
+codex_speed_prepare() {
+  CODEX_SPEED_ARGV=("$@")
+  [ "${CODEX_MULTIACC_DISABLE:-0}" != 1 ] || return 0
+  local a at command="" wanted=0 value first=1
+  for a in "$@"; do
+    [ "$a" != -- ] || break
+    case "$a" in --help|-h|--version|-V) return 0 ;; esac
+  done
+  at="$(cli_positional_at "$@")" && command="${!at}"
+  case "$command" in login|logout|mcp|features|completion|debug|sandbox|apply|a|cloud|update|help) return 0 ;; esac
+  case "${CODEX_SPEED:-}" in
+    '') ;;
+    normal|fast|ultrafast) wanted=1 ;;
+    *) printf 'codex-multiacc: CODEX_SPEED must be normal, fast, or ultrafast\n' >&2; return 2 ;;
+  esac
+  for a in "$@"; do case "$a" in *service_tier=*|-p|--profile|--profile=*) wanted=1 ;; esac; done
+  if [ "$wanted" = 0 ]; then
+    grep -qE '(service_tier|profile)[[:space:]]*=' "${CODEX_HOME:-${HOME:-/nonexistent}/.codex}/config.toml" 2>/dev/null \
+      || return 0
+  fi
+  local rewritten=()
+  while IFS= read -r -d '' value; do
+    if [ "$first" = 1 ]; then
+      first=0
+      export CODEX_SPEED_EFFECTIVE="$value"
+    else
+      rewritten+=("$value")
+    fi
+  done < <("$MCP_PYBIN" "$SELF_DIR/../lib/codex_speed.py" \
+      --account-dir "${CODEX_HOME:-${HOME:-/nonexistent}/.codex}" --native-cli "$REAL" --launch-argv -- "$@")
+  if [ "$first" = 1 ]; then
+    printf 'codex-multiacc: could not resolve the requested Codex speed; launch cancelled\n' >&2
+    return 2
+  fi
+  CODEX_SPEED_ARGV=(${rewritten[@]+"${rewritten[@]}"})
+  return 0
+}

package/lib/common.sh

@@ -30,6 +30,8 @@ DEFAULT_SERVER="root@138.197.36.107"
 DEFAULT_SERVER_REPO="/root/claude-multiacc"
 
 LIB_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" 2>/dev/null && pwd -P)"
+codex_mcp_oauth_ensure() { :; }
+if [ -f "$LIB_DIR/codex_mcp_oauth.sh" ]; then . "$LIB_DIR/codex_mcp_oauth.sh"; fi
 
 # INSTANCE-SCOPED POOLS: <PROVIDER>_ACCOUNTS_ROOT relocates the whole pool, so
 # several app-robot instances on one machine/user keep completely isolated account
@@ -806,6 +808,7 @@ seed_account_dir() { # $1 = acct dir
     fi
     codex_share_state_index "$d"
     seed_mcp_registry "$d"
+    codex_mcp_oauth_ensure "$ACC_ROOT" "$PYBIN" "$LIB_DIR/codex_mcp_oauth.py" "$d"
     return 0
   fi
   if [ ! -f "$d/.claude.json" ] && [ -f "$HOME/.claude.json" ]; then
@@ -841,16 +844,26 @@ PYEOF
   seed_mcp_registry "$d"
 }
 
+# Exclusive directory creation must report a competing owner as failure. Ubuntu
+# 26.04's uutils mkdir can return success to BOTH concurrent creators without -p.
+# Python is already required by account operations; os.mkdir uses one mkdir(2).
+atomic_mkdir() { "$PYBIN" -c 'import os, sys; os.mkdir(sys.argv[1], 0o700)' "$1"; }
+
 # Short-lived mutation lock: serialize only the brief critical sections (id reservation,
 # manifest write), NOT long interactive work like a browser sign-in — so several
 # `add`/`login` in different terminals run in parallel and only briefly wait on each other.
 # Held for milliseconds; a lock older than 30s is assumed abandoned (holder died) and reclaimed.
 MUTATE_LOCK_HELD=0
 mutate_lock() {
-  local lock="$ACC_ROOT/.locks/mutate" tries=0
+  local lock="$ACC_ROOT/.locks/mutate" tries=0 stamp
   mkdir -p "$ACC_ROOT/.locks" 2>/dev/null
-  while ! mkdir "$lock" 2>/dev/null; do
-    if [ $(( $(epoch_now) - $(file_mtime "$lock") )) -gt 30 ]; then
+  while ! atomic_mkdir "$lock" 2>/dev/null; do
+    stamp="$(file_mtime "$lock")"
+    # The holder can release between mkdir and stat. A missing/unreadable mtime
+    # is not stale-lock evidence: reclaiming from zero could delete the next
+    # holder's newly acquired directory. Use the ordinary bounded retry instead.
+    case "$stamp" in ''|*[!0-9]*) stamp=0 ;; esac
+    if [ "$stamp" -gt 0 ] && [ $(( $(epoch_now) - stamp )) -gt 30 ]; then
       rm -rf "$lock" 2>/dev/null
       continue
     fi

package/lib/model_match.py

@@ -92,7 +92,10 @@ def resume_settings(source, settings, target, catalog=None):
     effort = match_effort(catalog, source, (settings or {}).get("effort"), target, model)
     if model and not effort and target == "codex":
         effort = (((catalog.get("codex") or {}).get("models") or {}).get(model) or {}).get("default_effort")
-    return {"model": model, "effort": effort}
+    result = {"model": model, "effort": effort}
+    if source == target == "codex" and (settings or {}).get("speed") in ("normal", "fast", "ultrafast"):
+        result["speed"] = settings["speed"]
+    return result
 
 
 def settings_flags(provider, model, effort):

package/lib/session_settings.py

@@ -19,6 +19,10 @@ import json
 import os
 import sys
 
+# The public helper is also launched with Python -I, which omits its own directory.
+# Import only the installed sibling helpers, never modules from the caller's cwd.
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
 CHUNK = 1 << 20
 SCAN_LIMIT = 64 << 20
 SYNTHETIC = "<synthetic>"
@@ -70,19 +74,34 @@ def _own_thread_id(path):
 
 def codex_settings(path, upto=None):
     own = _own_thread_id(path)
+    found, tier_found = None, False
+    selected_speed = None
     for line in _reverse_lines(path, upto):
         doc = _record(line)
         payload = doc.get("payload") if doc else None
         if not isinstance(payload, dict):
             continue
-        if doc.get("type") == "turn_context" and _text(payload.get("model")):
-            return {"model": _text(payload.get("model")), "effort": _text(payload.get("effort"))}
+        settings, effort_key = None, "effort"
+        if doc.get("type") == "turn_context":
+            settings = payload
         if doc.get("type") == "event_msg" and payload.get("type") == "thread_settings_applied":
-            settings = payload.get("thread_settings")
             thread = _text(payload.get("thread_id"))
-            if isinstance(settings, dict) and _text(settings.get("model")) and (own is None or thread in (None, own)):
-                return {"model": _text(settings.get("model")), "effort": _text(settings.get("reasoning_effort"))}
-    return {"model": None, "effort": None}
+            if own is None or thread in (None, own):
+                settings, effort_key = payload.get("thread_settings"), "reasoning_effort"
+        if not isinstance(settings, dict):
+            continue
+        if found is None and _text(settings.get("model")):
+            found = {"model": _text(settings.get("model")), "effort": _text(settings.get(effort_key))}
+        if not tier_found and "service_tier" in settings:
+            tier_found = True
+            from codex_speed import speed
+            selected_speed = "normal" if settings["service_tier"] is None else speed(settings["service_tier"])
+        if found is not None and tier_found:
+            break
+    found = found or {"model": None, "effort": None}
+    if selected_speed:
+        found["speed"] = selected_speed
+    return found
 
 
 def claude_settings(path, upto=None):

package/lib/shim_path.py

@@ -41,6 +41,7 @@ from __future__ import annotations
 import getpass
 import json
 import os
+import re
 import shutil
 import signal
 import subprocess
@@ -66,6 +67,10 @@ MODES = (
 # which reports an alias or a function by name, so the sh script drops those first.
 _RESOLVERS = {'zsh': 'whence -p', 'bash': 'type -P', 'sh': 'command -v'}
 SENTINEL = '__claude_multiacc_probe__'
+# Login shells may emit OSC shell-integration records on stdout immediately before
+# or after an answer (Ubuntu's OSC 3008). Remove only complete, line-local records;
+# an unterminated control string must never swallow a later sentinel line.
+_OSC = re.compile(r'\x1b\][^\x07\x1b\r\n]*(?:\x07|\x1b\\)')
 # The PATH a login shell STARTS from before any rc file runs — what sshd/login/launchd
 # hand it. /usr/local/bin matters on Linux: the root install's /usr/local/bin/claude
 # symlink is how a shell with no rc block still reaches the shim, so leaving it out
@@ -139,6 +144,7 @@ def _parse(text, names):
     """First sentinel answer per name. Anything else the shell printed is ignored."""
     answers = {}
     for line in text.splitlines():
+        line = _OSC.sub('', line)
         if not line.startswith(SENTINEL + ' '):
             continue
         body = line[len(SENTINEL) + 1:]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-multiacc",
-  "version": "2.0.61",
+  "version": "2.0.65",
   "description": "Unified Claude Code and OpenAI Codex subscription pooling with quota-aware selection.",
   "type": "module",
   "bin": {
@@ -56,11 +56,16 @@
   "scripts": {
     "postinstall": "node scripts/postinstall.mjs",
     "test": "npm run test:core && npm run test:seeding && npm run test:commands",
-    "test:core": "bash tests/run-tests.sh && npm run test:selector && python3 tests/test_shim_path.py",
+    "test:core": "bash tests/run-tests.sh && npm run test:selector && npm run test:shim",
+    "test:shim": "python3 tests/test_shim_path.py && npm run test:codex-stdin",
+    "test:codex-stdin": "python3 tests/test_codex_exec_stdin.py && python3 tests/test_codex_retry_process.py",
     "test:selector": "python3 -m unittest discover -s tests -p 'test_selector*.py'",
-    "test:seeding": "python3 tests/test_account_seeding.py && python3 tests/test_claude_pool_prepare.py && python3 -m unittest discover -s tests -p 'test_mcp_*.py' && npm run test:codex-settings",
-    "test:codex-settings": "python3 tests/test_codex_config_edit.py && python3 tests/test_codex_settings.py",
-    "test:commands": "python3 tests/test_packaged_commands.py"
+    "test:seeding": "npm run test:account-seeding && npm run test:mcp && npm run test:codex-settings",
+    "test:codex-settings": "python3 tests/test_codex_config_edit.py && python3 tests/test_codex_settings.py && python3 tests/test_codex_speed.py",
+    "test:commands": "python3 tests/test_packaged_commands.py",
+    "test:codex-mcp-auth": "python3 -m unittest discover -s tests -p 'test_codex_mcp_oauth*.py'",
+    "test:account-seeding": "python3 tests/test_account_seeding.py && python3 tests/test_claude_pool_prepare.py",
+    "test:mcp": "python3 -m unittest discover -s tests -p 'test_mcp_*.py' && npm run test:codex-mcp-auth"
   },
   "dependencies": {
     "update-notifier": "^7.3.1"