claude-multiacc 2.0.58 → 2.0.60

package/lib/model_catalog.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+"""The model/effort catalog of both providers, from the freshest credential-free source (3.8+).
+
+Sources, freshest wins per provider: the catalog shipped beside this file (``model_catalog.json``,
+a snapshot of the lineup, the fallback), a pool's refreshed copy (``<root>/model-catalog.json``, written by
+``refresh`` on every install and self-update and kept current by the limits passes), and the
+caches the CLIs themselves maintain while they run -- Codex's ``<acct>/models_cache.json``
+(rewritten every few minutes by any app-server) and Claude Code's served catalog
+``<acct>/cache/model-catalog/*-cc.json`` (hourly). No request is ever sent: the CLIs already
+fetch these with their own credentials and budgets.
+
+Shape: ``{"schema": 1, "<provider>": {"fetched_at": iso, "source": str, "efforts": [ascending],
+"families": {family: tier}, "models": {id: {"family", "version", "efforts", "default_effort",
+"listed", "upgrade"}}}}``. ``efforts``/``families`` are structure and come from the shipped file;
+``models`` from the freshest source. ``lib/model_match.py`` does the matching.
+"""
+
+import glob
+import json
+import os
+import re
+import sys
+import tempfile
+import time
+
+SHIPPED = os.path.join(os.path.dirname(os.path.abspath(__file__)), "model_catalog.json")
+OVERLAY = "model-catalog.json"
+PROVIDERS = ("claude", "codex")
+CLAUDE_ID = re.compile(r"^claude-(?P<family>[a-z]+)(?:-(?P<version>\d+(?:-\d+)*?))?(?:-\d{8})?$")
+CODEX_ID = re.compile(r"^gpt-(?P<version>\d+(?:\.\d+)*)(?:-(?P<family>[a-z]+))?$")
+
+
+def parse_id(provider, model):
+    """(family, version tuple) of a model id; family None when the id is not understood."""
+    model = re.sub(r"\[\d+[km]\]$", "", model or "", flags=re.I).strip()
+    match = (CLAUDE_ID if provider == "claude" else CODEX_ID).match(model)
+    if not match:
+        return None, ()
+    version = match.group("version") or ""
+    return match.group("family"), tuple(int(part) for part in re.split(r"[.-]", version) if part)
+
+
+def _read_json(path):
+    try:
+        with open(path, "rb") as fh:
+            return json.loads(fh.read().decode("utf-8"))
+    except (OSError, ValueError):
+        return None
+
+
+def _iso(epoch):
+    return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(epoch))
+
+
+def _entry(provider, model, efforts, default, listed, upgrade=None):
+    family, version = parse_id(provider, model)
+    return {"family": family, "version": list(version), "efforts": [e for e in efforts if isinstance(e, str)],
+            "default_effort": default if isinstance(default, str) else None, "listed": bool(listed),
+            "upgrade": upgrade if isinstance(upgrade, str) else None}
+
+
+def codex_cache(path):
+    """A ``models_cache.json`` as a provider section, or None (also for a half-written file)."""
+    doc = _read_json(path)
+    models = doc.get("models") if isinstance(doc, dict) else None
+    if not isinstance(models, list) or not isinstance(doc.get("fetched_at"), str):
+        return None
+    table = {}
+    for item in models:
+        if not isinstance(item, dict) or not isinstance(item.get("slug"), str):
+            continue
+        levels = item.get("supported_reasoning_levels") or []
+        efforts = [lvl.get("effort") for lvl in levels if isinstance(lvl, dict)]
+        upgrade = item.get("upgrade") if isinstance(item.get("upgrade"), dict) else {}
+        table[item["slug"]] = _entry("codex", item["slug"], efforts, item.get("default_reasoning_level"),
+                                     item.get("visibility") == "list", upgrade.get("model"))
+    return {"fetched_at": doc["fetched_at"][:19] + "Z", "source": path, "models": table} if table else None
+
+
+def claude_cache(path):
+    """A served-catalog cache (``*-cc.json``) as a provider section, or None."""
+    doc = _read_json(path)
+    catalog = doc.get("catalog") if isinstance(doc, dict) else None
+    config = catalog.get("config") if isinstance(catalog, dict) else None
+    rows = config.get("models") if isinstance(config, dict) else None
+    if not isinstance(rows, list) or not isinstance(doc.get("fetchedAt"), (int, float)):
+        return None
+    state = catalog.get("state") if isinstance(catalog.get("state"), dict) else {}
+    defaults = {}
+    for item in state.get("thinking_by_model") or []:
+        thinking = item.get("thinking") if isinstance(item, dict) else None
+        if isinstance(thinking, dict) and isinstance(item.get("id"), str):
+            defaults[item["id"]] = thinking.get("effort")
+    table = {}
+    for row in rows:
+        if not isinstance(row, dict) or not isinstance(row.get("id"), str):
+            continue
+        thinking = row.get("thinking") if isinstance(row.get("thinking"), dict) else {}
+        options = [opt.get("id") for opt in thinking.get("effort_options") or [] if isinstance(opt, dict)]
+        table[row["id"]] = _entry("claude", row["id"], options, defaults.get(row["id"]),
+                                  row.get("section") == "main")
+    return {"fetched_at": _iso(doc["fetchedAt"] / 1000.0), "source": path, "models": table} if table else None
+
+
+def sources(roots):
+    """Every candidate section per provider: shipped, overlays, then the CLIs' own caches."""
+    found = {provider: [] for provider in PROVIDERS}
+    shipped = _read_json(SHIPPED) or {}
+    for provider in PROVIDERS:
+        if isinstance(shipped.get(provider), dict) and isinstance(shipped[provider].get("models"), dict):
+            found[provider].append(dict(shipped[provider], source=SHIPPED))
+    for root in [r for r in (roots or {}).values() if r]:
+        overlay = _read_json(os.path.join(root, OVERLAY)) or {}
+        for provider in PROVIDERS:
+            if isinstance(overlay.get(provider), dict) and isinstance(overlay[provider].get("models"), dict):
+                found[provider].append(dict(overlay[provider], source=os.path.join(root, OVERLAY)))
+    codex_root, claude_root = (roots or {}).get("codex"), (roots or {}).get("claude")
+    for path in glob.glob(os.path.join(codex_root, "acct-*", "models_cache.json")) if codex_root else []:
+        section = codex_cache(path)
+        if section:
+            found["codex"].append(section)
+    for path in glob.glob(os.path.join(claude_root, "acct-*", "cache", "model-catalog", "*-cc.json")) \
+            if claude_root else []:
+        section = claude_cache(path)
+        if section:
+            found["claude"].append(section)
+    return found
+
+
+def load(roots=None):
+    """The merged catalog: structure from the shipped file, models from the freshest source."""
+    shipped = _read_json(SHIPPED) or {}
+    found = sources(roots)
+    catalog = {"schema": 1}
+    for provider in PROVIDERS:
+        base = shipped.get(provider) if isinstance(shipped.get(provider), dict) else {}
+        best = max(found[provider], key=lambda s: str(s.get("fetched_at") or ""), default=None)
+        catalog[provider] = {"efforts": list(base.get("efforts") or []), "families": dict(base.get("families") or {}),
+                             "fetched_at": best.get("fetched_at") if best else None,
+                             "source": best.get("source") if best else None,
+                             "models": dict(best.get("models") or {}) if best else {}}
+    return catalog
+
+
+def refresh(roots, if_stale=False, max_age=3600):
+    """Write the merged catalog to every pool root given; ``if_stale`` skips roots whose copy
+    is younger than ``max_age`` seconds. Returns the paths written."""
+    written = []
+    for root in sorted(set(r for r in roots.values() if r)):
+        path = os.path.join(root, OVERLAY)
+        try:
+            if if_stale and time.time() - os.stat(path).st_mtime < max_age:
+                continue
+        except OSError:
+            pass
+        catalog = load(roots)
+        catalog["generated_at"] = _iso(time.time())
+        scratch = None
+        try:
+            handle, scratch = tempfile.mkstemp(prefix=".model-catalog.", dir=root)
+            with os.fdopen(handle, "w", encoding="utf-8") as fh:
+                os.fchmod(fh.fileno(), 0o644)
+                fh.write(json.dumps(catalog, indent=1, sort_keys=True) + "\n")
+            os.replace(scratch, path)
+            written.append(path)
+        except OSError:
+            if scratch:
+                try:
+                    os.unlink(scratch)
+                except OSError:
+                    pass
+    return written
+
+
+def main(argv):
+    roots, verb, if_stale, i = {}, None, False, 0
+    while i < len(argv):
+        if argv[i] in ("--claude-root", "--codex-root") and i + 1 < len(argv):
+            roots[argv[i][2:-5]] = argv[i + 1]
+            i += 2
+        elif argv[i] == "--if-stale":
+            if_stale, i = True, i + 1
+        elif argv[i] in ("refresh", "show") and verb is None:
+            verb, i = argv[i], i + 1
+        else:
+            verb = None
+            break
+    if verb is None:
+        sys.stderr.write("usage: model_catalog.py <refresh|show> [--claude-root R] [--codex-root R] [--if-stale]\n")
+        return 2
+    if verb == "show":
+        print(json.dumps(load(roots), indent=1, sort_keys=True))
+        return 0
+    written = refresh(roots, if_stale)
+    for path in written:
+        print(path)
+    return 0 if written or if_stale or not roots else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/lib/model_match.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Which model and effort a resumed session should run with (Python 3.8+).
+
+Same provider: the session's own model and effort, as its history recorded them. Another
+provider: the model of the same LEVEL -- every family has a level in the catalog (Claude: haiku 2,
+sonnet 3, opus 4, fable 5; Codex: luna 1, terra 2, sol 3, astra 4, so astra <-> opus, sol <->
+sonnet, terra -> haiku <- luna, haiku -> terra, fable -> astra), the source model's level picks
+the destination family, and the newest listed model of that family is the match -- and the
+effort of the same level by name (low, medium, high, xhigh, max), with Codex's ``ultra`` landing
+on ``max`` and its ``minimal``/``none`` on ``low``, clamped to what the destination model
+supports (the nearest level below, else the lowest). An unknown model or effort is simply
+omitted, and the destination CLI applies its own default.
+
+``settings_flags`` renders the result as argv: Claude ``--model M --effort E``; Codex ``-m M -c
+model_reasoning_effort=E`` -- always both, because any single model flag makes Codex drop the
+thread's other saved value (the effort falls back to the model's catalog default).
+"""
+
+import sys
+
+sys.path.insert(0, __import__("os").path.dirname(__import__("os").path.abspath(__file__)))
+from model_catalog import load, parse_id  # noqa: E402
+
+RENAME = {"codex": {"claude": {"ultra": "max", "minimal": "low", "none": "low"}},
+          "claude": {"codex": {}}}
+
+
+def tier(catalog, provider, model, hops=4):
+    """The model's family tier; a retiring model counts as the one the catalog upgrades it to."""
+    section = catalog.get(provider) or {}
+    entry = (section.get("models") or {}).get(model) or {}
+    family = entry.get("family") or parse_id(provider, model)[0]
+    level = (section.get("families") or {}).get(family)
+    if level is None and entry.get("upgrade") and hops:
+        return tier(catalog, provider, entry["upgrade"], hops - 1)
+    return level
+
+
+def current_models(catalog, provider):
+    """family -> the newest listed model of that family. Every listed family is a level of its
+    own, whatever its version: launches are staggered, and a tier must never borrow another
+    family's model while a listed one of its own exists."""
+    best = {}
+    for model, entry in ((catalog.get(provider) or {}).get("models") or {}).items():
+        family = entry.get("family") or parse_id(provider, model)[0]
+        if not family or not entry.get("listed"):
+            continue
+        version = tuple(entry.get("version") or parse_id(provider, model)[1])
+        if family not in best or version > best[family][0]:
+            best[family] = (version, model)
+    return {family: model for family, (_, model) in best.items()}
+
+
+def match_model(catalog, source, model, target):
+    """The target provider's current model at the source model's tier (nearest above, then
+    below, when that exact tier has no current model); None when the source is unknown."""
+    if not model:
+        return None
+    if source == target:
+        return model
+    wanted = tier(catalog, source, model)
+    if wanted is None:
+        return None
+    current = current_models(catalog, target)
+    families = (catalog.get(target) or {}).get("families") or {}
+    ranked = sorted(((level, family) for family, level in families.items() if family in current),
+                    key=lambda item: (abs(item[0] - wanted), -item[0]))
+    return current[ranked[0][1]] if ranked else None
+
+
+def match_effort(catalog, source, effort, target, model):
+    """The same effort by name, renamed between vocabularies, clamped to the target model."""
+    if not effort:
+        return None
+    name = RENAME.get(source, {}).get(target, {}).get(effort, effort) if source != target else effort
+    section = catalog.get(target) or {}
+    scale = list(section.get("efforts") or [])
+    supported = ((section.get("models") or {}).get(model) or {}).get("efforts") or []
+    if name not in scale:
+        return name if not supported or name in supported else None
+    if not supported or name in supported:
+        return name
+    below = [level for level in supported if level in scale and scale.index(level) <= scale.index(name)]
+    return max(below, key=scale.index) if below else min(supported, key=lambda level: scale.index(level)
+                                                           if level in scale else len(scale))
+
+
+def resume_settings(source, settings, target, catalog=None):
+    """{"model", "effort"} for the target provider from a source session's settings."""
+    catalog = catalog or load()
+    model = match_model(catalog, source, (settings or {}).get("model"), target)
+    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}
+
+
+def settings_flags(provider, model, effort):
+    """argv fragment that pins ``model``/``effort`` for ``provider``; empty when nothing is known."""
+    if provider == "claude":
+        return (["--model", model] if model else []) + (["--effort", effort] if effort else [])
+    if provider == "codex" and model and effort:
+        return ["-m", model, "-c", "model_reasoning_effort=" + effort]
+    return []

package/lib/report.py

@@ -32,8 +32,9 @@ Account status vocabulary (the panel's contract):
 Credential classes (what may be COPIED between machines):
   portable      claude setup-token (server.token) — safe to export/import anywhere
   machine-local claude .credentials.json OR a macOS Keychain item (credentials.oauth_store
-                says which) / codex auth.json — rotating refresh grant; copying it makes
-                two machines fight over one grant and breaks both
+                says which) carrying a claudeAiOauth login — one holding only MCP OAuth
+                state is no login — / codex auth.json — rotating refresh grant; copying it
+                makes two machines fight over one grant and breaks both
   none          nothing on disk (or in the Keychain) here
 """
 
@@ -46,7 +47,7 @@ import time
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 import keychain  # noqa: E402
-from audit import creds_doc_state, token_verified  # noqa: E402
+from audit import creds_doc_state, file_has_login, token_verified  # noqa: E402
 from claude_client_error import org_access_verified_at  # noqa: E402
 from claude_reset import marker_superseded, record_from  # noqa: E402
 from codex_credits import credit_view  # noqa: E402
@@ -170,10 +171,12 @@ def _claude_credentials(d):
     macOS Keychain (`oauth_store` says which; `keychain` says whether THIS process could
     open it). A Keychain login this session cannot open is still a login on this Mac —
     reporting it as `none` is what made a whole pool of working accounts read as
-    missing — so the class stays machine-local and the row's status says `locked`."""
+    missing — so the class stays machine-local and the row's status says `locked`.
+    A file or item holding only the client's MCP OAuth state is no login at all
+    (audit.file_has_login, keychain 'nologin'): `oauth` stays false for it."""
     cpath = os.path.join(d, '.credentials.json')
     tpath = os.path.join(d, 'server.token')
-    has_oauth = _size(cpath) > 0
+    has_oauth = file_has_login(cpath)
     has_token = _size(tpath) > 0
     detail = {'oauth': has_oauth, 'token': has_token, 'oauth_store': None, 'keychain': None,
               'oauth_expires_at': None, 'oauth_refresh_expires_at': None,

package/lib/session_settings.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""The model and effort a session is running with, read from its own history (Python 3.8+).
+
+claude: the last main-thread assistant record (not a sidechain, not meta, a real model): its
+``requestedModel``, else ``message.model``; and ``effort``, else ``perTurnEffort``. A natively
+1M model is recorded without ``[1m]``, which it does not need. A ``/model`` switch with no reply
+after it is not visible: only assistant records carry the model.
+codex: whichever comes last of a ``turn_context`` (``model``/``effort``) and a
+``thread_settings_applied`` event for the file's own thread (``thread_settings.model``/
+``reasoning_effort``) -- the rule Codex's own state db follows, so a mid-session ``/model`` or
+effort change is honoured. An absent effort means the model's default.
+
+Bounded: the file is read backwards in chunks (a transcript can be 100 MB) and the scan stops
+at SCAN_LIMIT bytes; ``upto`` caps it at a byte boundary (a handoff's snapshot). The result is
+``{"model": str|None, "effort": str|None}``; a file that cannot be read gives both None.
+"""
+
+import json
+import os
+import sys
+
+CHUNK = 1 << 20
+SCAN_LIMIT = 64 << 20
+SYNTHETIC = "<synthetic>"
+
+
+def _reverse_lines(path, upto=None):
+    """Complete lines of ``path`` from the last one backwards, at most SCAN_LIMIT bytes in."""
+    with open(path, "rb") as fh:
+        end = os.fstat(fh.fileno()).st_size if upto is None else min(upto, os.fstat(fh.fileno()).st_size)
+        rest, pos, scanned = b"", end, 0
+        while pos > 0 and scanned < SCAN_LIMIT:
+            step = min(CHUNK, pos)
+            pos -= step
+            fh.seek(pos)
+            block = fh.read(step) + rest
+            scanned += step
+            lines = block.split(b"\n")
+            rest = lines[0]
+            for line in reversed(lines[1:]):
+                if line.strip():
+                    yield line
+        if pos == 0 and rest.strip():
+            yield rest
+
+
+def _record(line):
+    try:
+        doc = json.loads(line.decode("utf-8", "replace"))
+    except ValueError:
+        return None
+    return doc if isinstance(doc, dict) else None
+
+
+def _text(value):
+    return value if isinstance(value, str) and value.strip() else None
+
+
+def _own_thread_id(path):
+    """The id in the file's first line (its own session_meta; a fork copies its parent's at
+    line two), so another thread's settings snapshots are not mistaken for this one's."""
+    try:
+        with open(path, "rb") as fh:
+            doc = _record(fh.readline(1 << 20))
+    except OSError:
+        return None
+    payload = doc.get("payload") if doc else None
+    return _text(payload.get("id")) if isinstance(payload, dict) else None
+
+
+def codex_settings(path, upto=None):
+    own = _own_thread_id(path)
+    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"))}
+        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}
+
+
+def claude_settings(path, upto=None):
+    for line in _reverse_lines(path, upto):
+        doc = _record(line)
+        if not doc or doc.get("type") != "assistant" or doc.get("isSidechain") or doc.get("isMeta"):
+            continue
+        message = doc.get("message")
+        model = _text(message.get("model")) if isinstance(message, dict) else None
+        if model is None or model == SYNTHETIC:
+            continue
+        return {"model": _text(doc.get("requestedModel")) or model,
+                "effort": _text(doc.get("effort")) or _text(doc.get("perTurnEffort"))}
+    return {"model": None, "effort": None}
+
+
+def session_settings(provider, path, upto=None):
+    """Fail-open: anything unreadable or unknown is ``{"model": None, "effort": None}``."""
+    reader = {"claude": claude_settings, "codex": codex_settings}.get(provider)
+    if reader is None or not path:
+        return {"model": None, "effort": None}
+    try:
+        return reader(path, upto)
+    except (OSError, ValueError):
+        return {"model": None, "effort": None}
+
+
+def main(argv):
+    if len(argv) not in (2, 4) or argv[0] not in ("claude", "codex") or (len(argv) == 4 and argv[2] != "--upto"):
+        sys.stderr.write("usage: session_settings.py <claude|codex> <history.jsonl> [--upto <bytes>]\n")
+        return 2
+    upto = int(argv[3]) if len(argv) == 4 else None
+    print(json.dumps(session_settings(argv[0], argv[1], upto)))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-multiacc",
-  "version": "2.0.58",
+  "version": "2.0.60",
   "description": "Unified Claude Code and OpenAI Codex subscription pooling with quota-aware selection.",
   "type": "module",
   "bin": {
@@ -58,7 +58,7 @@
     "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: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 tests/test_mcp_registry.py && npm run test:codex-settings",
+    "test:seeding": "python3 tests/test_account_seeding.py && python3 tests/test_claude_pool_prepare.py && python3 tests/test_mcp_registry.py && python3 tests/test_mcp_oauth.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"
   },