claude-multiacc 2.0.51 → 2.0.53

package/lib/codex_credits.py

@@ -9,17 +9,16 @@ import os
 import re
 import time
 
+from codex_usage_fetch import TRANSPORT_ERRORS
+from codex_credit_controls import limit_type as _limit_type, usage_controls as _controls
+
 _DECIMAL = re.compile(r"(?:0|[1-9][0-9]*)(?:\.[0-9]+)?\Z")
 _IDENTITY = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.:@/-]{0,199}\Z")
-_LIMIT_TYPES = {
-    "rate_limit_reached", "workspace_owner_credits_depleted", "workspace_member_credits_depleted",
-    "workspace_owner_usage_limit_reached", "workspace_member_usage_limit_reached",
-}
 _ERRORS = {
     "missing_credits", "invalid_credits", "account_mismatch", "unauthenticated",
     "usage_read_failed", "invalid_usage", "http_401", "http_403", "http_429", "http_error",
     "usage_reset_pending",
-}
+} | TRANSPORT_ERRORS
 
 
 def _iso(value: float) -> str:
@@ -47,39 +46,24 @@ def _optional_bool(value):
     return value if type(value) is bool else None
 
 
-def _limit_type(value):
-    if isinstance(value, dict):
-        value = value.get("type", "unknown")
-    if value is None:
-        return None
-    return value if isinstance(value, str) and value in _LIMIT_TYPES else "unknown"
-
-
 def snapshot_from_usage(usage: dict, account_id: str, now: float) -> dict:
     """Bind the provider's wallet and admission facts to the authenticated account."""
     if not isinstance(usage, dict):
         raise ValueError("invalid_usage")
     root = usage.get("rateLimits")
     root = root if isinstance(root, dict) else usage
-    raw = root.get("credits")
-    if not isinstance(raw, dict):
-        raise ValueError("missing_credits")
-    has_credits = raw.get("has_credits", raw.get("hasCredits"))
-    if type(has_credits) is not bool or type(raw.get("unlimited")) is not bool:
-        raise ValueError("invalid_credits")
     response_id = usage.get("account_id", usage.get("accountId"))
     expected, reported = _identity(account_id), _identity(response_id)
     if response_id is not None and not reported:
         raise ValueError("account_mismatch")
     if expected and reported and expected != reported:
         raise ValueError("account_mismatch")
-    limit = root.get("rate_limit")
-    limit = limit if isinstance(limit, dict) else {}
-    ordinary = usage.get("ordinary_usage_allowed", usage.get("ordinaryUsageAllowed", limit.get("allowed")))
-    reached = root.get("rate_limit_reached_type", root.get("rateLimitReachedType", limit.get("limit_reached_type")))
-    spend = root.get("spend_control")
-    spend = spend if isinstance(spend, dict) else {}
-    spend_reached = root.get("spend_control_reached", root.get("spendControlReached", spend.get("reached")))
+    raw = root.get("credits")
+    if not isinstance(raw, dict):
+        raise ValueError("missing_credits")
+    has_credits = raw.get("has_credits", raw.get("hasCredits"))
+    if type(has_credits) is not bool or type(raw.get("unlimited")) is not bool:
+        raise ValueError("invalid_credits")
     try:
         balance = _balance(raw.get("balance"))
     except ValueError as error:
@@ -87,9 +71,7 @@ def snapshot_from_usage(usage: dict, account_id: str, now: float) -> dict:
     return {
         "has_credits": has_credits, "unlimited": raw["unlimited"], "balance": balance,
         "fetched_at": _iso(now), "account_id": reported or expected,
-        "ordinary_usage_allowed": _optional_bool(ordinary),
-        "spend_control_reached": _optional_bool(spend_reached),
-        "limit_reached_type": _limit_type(reached),
+        **_controls(usage, root),
     }
 
 
@@ -132,9 +114,11 @@ def credit_view(value, now: float | None = None, stale_after: int = 900) -> dict
 
 
 def failed_credits(previous, error: str, now: float) -> dict | None:
-    """A failed read invalidates spending evidence without inventing a zero balance."""
+    """Keep the last measured amount and its age when a telemetry read fails."""
     out = credit_view(previous, now)
     if out is not None:
+        if out.get("last_error") in ("account_mismatch", "unauthenticated"):
+            return out
         out.update(last_error=error if error in _ERRORS else "usage_read_failed",
                    last_error_at=_iso(now), stale=True)
     return out
@@ -142,9 +126,21 @@ def failed_credits(previous, error: str, now: float) -> dict | None:
 
 def collect_credits(usage, account_id: str, now: float, previous=None) -> dict | None:
     try:
-        return snapshot_from_usage(usage, account_id, now)
+        result = snapshot_from_usage(usage, account_id, now)
+        if previous and result["has_credits"] and not result["unlimited"] and result["balance"] is None:
+            raise ValueError("invalid_credits")
+        return result
     except ValueError as error:
-        return failed_credits(previous, str(error), now)
+        result = failed_credits(previous, str(error), now)
+        if result is not None and str(error) in ("missing_credits", "invalid_credits"):
+            root = usage.get("rateLimits")
+            root = root if isinstance(root, dict) else usage
+            controls = _controls(usage, root)
+            if controls["spend_control_reached"] is True:
+                result["spend_control_reached"] = True
+            if controls["limit_reached_type"] not in (None, "rate_limit_reached"):
+                result["limit_reached_type"] = controls["limit_reached_type"]
+        return result
 
 
 def record_read_failure(path: str, previous: dict, error: str, now: float) -> None:

package/lib/codex_limits_lock.py

@@ -0,0 +1,56 @@
+"""Keep a live Codex usage collector's lock even when a slow pass exceeds two minutes."""
+
+from __future__ import annotations
+
+import fcntl
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import time
+
+
+def process_birth(pid: int) -> str:
+    try:
+        os.kill(pid, 0)
+        result = subprocess.run(["ps", "-p", str(pid), "-o", "lstart="],
+                                capture_output=True, text=True, timeout=5, check=False)
+        return result.stdout.strip() if result.returncode == 0 else ""
+    except (OSError, subprocess.TimeoutExpired):
+        return ""
+
+
+def change_lock(path: Path, pid: int, release: bool = False) -> bool:
+    """Serialize ownership changes; the owner process lifetime governs the lease."""
+    birth = process_birth(pid)
+    if not birth:
+        return False
+    with path.with_suffix(".guard").open("a") as guard:
+        fcntl.flock(guard, fcntl.LOCK_EX)
+        owner = {}
+        try:
+            owner = json.loads((path / "owner.json").read_text())
+        except (OSError, ValueError):
+            pass
+        ours = owner == {"pid": pid, "birth": birth}
+        if release:
+            if ours:
+                shutil.rmtree(path)
+            return ours
+        if path.exists():
+            owner_pid = owner.get("pid") if isinstance(owner, dict) else None
+            if isinstance(owner_pid, int) and owner_pid > 0:
+                if owner.get("birth") and process_birth(owner_pid) == owner["birth"]:
+                    return False
+            elif time.time() - path.stat().st_mtime < 120:
+                return False
+            shutil.rmtree(path)
+        path.mkdir()
+        (path / "owner.json").write_text(json.dumps({"pid": pid, "birth": birth}))
+        return True
+
+
+if __name__ == "__main__":
+    sys.exit(0 if change_lock(Path(sys.argv[2]), int(sys.argv[3]), sys.argv[1] == "release") else 1)

package/lib/codex_usage_fetch.py

@@ -0,0 +1,85 @@
+"""Read-only usage transport with bounded retries and non-secret failure categories."""
+
+from __future__ import annotations
+
+from email.utils import parsedate_to_datetime
+import errno
+import json
+import socket
+import ssl
+import time
+import urllib.error
+import urllib.request
+
+TRANSPORT_ERRORS = {
+    "network_unreachable", "dns_unavailable", "usage_timeout", "connection_reset",
+    "tls_error", "edge_challenge",
+}
+
+
+def failure_kind(error: Exception) -> str:
+    """Classify the exception without retaining URLs, headers, bodies, or tokens."""
+    if isinstance(error, urllib.error.HTTPError):
+        if ((error.headers or {}).get("cf-mitigated") or "").lower() == "challenge":
+            return "edge_challenge"
+        return f"http_{error.code}" if error.code in (401, 403, 429) else "http_error"
+    reason = error.reason if isinstance(error, urllib.error.URLError) else error
+    if isinstance(reason, socket.gaierror):
+        return "dns_unavailable"
+    if isinstance(reason, (socket.timeout, TimeoutError)):
+        return "usage_timeout"
+    if isinstance(reason, ssl.SSLError):
+        return "tls_error"
+    if isinstance(reason, OSError):
+        if reason.errno in (errno.EHOSTUNREACH, errno.ENETUNREACH, errno.ENETDOWN):
+            return "network_unreachable"
+        if reason.errno in (errno.ECONNRESET, errno.ECONNREFUSED, errno.EPIPE):
+            return "connection_reset"
+    if isinstance(error, (ValueError, UnicodeError)):
+        return "invalid_usage"
+    return "usage_read_failed"
+
+
+def retryable(error: Exception) -> bool:
+    if isinstance(error, urllib.error.HTTPError):
+        return error.code in (500, 502, 503, 504) and not (error.headers or {}).get("Retry-After")
+    return failure_kind(error) in TRANSPORT_ERRORS - {"tls_error", "edge_challenge"}
+
+
+def fetch_usage(request, budget: float = 15):
+    """Retry once within a monotonic budget; OS DNS/socket operations retain their own timeouts."""
+    deadline = time.monotonic() + budget
+    for attempt in range(2):
+        remaining = max(0.1, deadline - time.monotonic())
+        try:
+            with urllib.request.urlopen(request, timeout=min(10, remaining)) as response:
+                result = json.loads(response.read().decode())
+            if not isinstance(result, dict):
+                raise ValueError("invalid usage object")
+            return result
+        except Exception as error:
+            if isinstance(error, urllib.error.HTTPError):
+                error.close()
+            if attempt or not retryable(error) or time.monotonic() >= deadline:
+                raise
+
+
+def retry_delay(error: Exception, previous: dict, now: float) -> int:
+    """Honor Retry-After; otherwise back off transient failures without hammering an account."""
+    header = (error.headers or {}).get("Retry-After") if isinstance(error, urllib.error.HTTPError) else None
+    if header:
+        try:
+            delay = int(header)
+        except (TypeError, ValueError):
+            try:
+                delay = int(parsedate_to_datetime(header).timestamp() - now)
+            except (TypeError, ValueError, OverflowError):
+                delay = 0
+        if delay > 0:
+            return delay
+    try:
+        prior = int(previous.get("backoff", 60))
+    except (TypeError, ValueError):
+        prior = 60
+    ceiling = 1800 if failure_kind(error) == "http_429" else 900
+    return min(ceiling, max(120, prior * 2))

package/lib/common.sh

@@ -781,8 +781,14 @@ PYEOF
   if [ ! -e "$d/CLAUDE.md" ] && [ -f "$HOME/.claude/CLAUDE.md" ]; then
     ln -s "$HOME/.claude/CLAUDE.md" "$d/CLAUDE.md" 2>/dev/null || true
   fi
-  if [ ! -e "$d/projects" ] && [ -d "$HOME/.claude/projects" ]; then
-    ln -s "$HOME/.claude/projects" "$d/projects" 2>/dev/null || true
+  # A fresh machine may seed pooled accounts before stock Claude has ever created
+  # ~/.claude/projects. Create the shared tree first or each account will create
+  # its own private history, making --resume depend on the next random pick.
+  if [ ! -e "$d/projects" ] && [ ! -L "$d/projects" ]; then
+    mkdir -p -m 700 "$HOME/.claude" "$HOME/.claude/projects" 2>/dev/null || true
+    if [ "$d" != "$HOME/.claude" ] && [ -d "$HOME/.claude/projects" ]; then
+      ln -s "$HOME/.claude/projects" "$d/projects" 2>/dev/null || true
+    fi
   fi
   seed_mcp_registry "$d"
 }

package/lib/selector_credit_scope.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from decimal import Decimal
 
 from selector_primitives import timestamp
+from selector_credits import HARD_CREDIT_ERRORS, normalize_credits
 
 FINANCIAL_FIELDS = ("has_credits", "unlimited", "balance", "account_id")
 
@@ -17,7 +18,8 @@ def actor_email(raw: dict) -> str | None:
 def wallet_available(credits: dict) -> bool:
     balance = credits.get("balance")
     funds = credits["unlimited"] or (credits["has_credits"] and balance is not None and Decimal(balance) > 0)
-    return bool(credits["fresh"] and not credits["last_error"] and funds)
+    return bool(credits["account_id"] and credits["fetched_at"]
+                and credits["last_error"] not in HARD_CREDIT_ERRORS and funds)
 
 
 def merge_wallet(local: dict, wallet: dict | None) -> dict:
@@ -25,7 +27,7 @@ def merge_wallet(local: dict, wallet: dict | None) -> dict:
         return local
     merged = dict(local)
     merged.update({key: wallet[key] for key in FINANCIAL_FIELDS})
-    merged["available"] = bool(local["fresh"] and not local["last_error"]
+    merged["available"] = bool(local["fetched_at"] and local["last_error"] not in HARD_CREDIT_ERRORS
                                and not local["spend_control_reached"] and wallet["available"])
     return merged
 
@@ -41,7 +43,7 @@ def actor_key(raw: dict) -> tuple:
 def actor_refusals(candidates: list[dict]) -> dict:
     refusals = {}
     for raw in candidates:
-        if not raw.get("credit_blocked_at") or (raw.get("credits") or {}).get("last_error"):
+        if not raw.get("credit_blocked_at") or (raw.get("credits") or {}).get("last_error") == "account_mismatch":
             continue
         try:
             _, blocked = timestamp(raw["credit_blocked_at"])
@@ -53,3 +55,31 @@ def actor_refusals(candidates: list[dict]) -> dict:
             refusals[key] = {"credit_blocked_at": blocked,
                              "credit_blocked_balance": raw.get("credit_blocked_balance")}
     return refusals
+
+
+def actor_observations(candidates: list[dict], now, max_age: int) -> dict:
+    observations = {}
+    for raw in candidates:
+        credits = normalize_credits(raw.get("credits"), now, max_age)
+        if not credits["fetched_at"] or credits["last_error"] == "account_mismatch":
+            continue
+        key = actor_key(raw)
+        sticky = bool(credits["last_error"] and credits["spend_control_reached"])
+        rank = (sticky, credits["fetched_at"], credits["spend_control_reached"],
+                credits["ordinary_usage_allowed"] is False)
+        previous = observations.get(key)
+        if previous is None or rank > previous[0]:
+            observations[key] = rank, credits
+    return {key: value[1] for key, value in observations.items()}
+
+
+def merge_actor(local: dict, observation: dict | None) -> dict:
+    # A partial response can confirm a new restriction while retaining old money's
+    # timestamp. A peer's newer money is not proof that this local restriction lifted.
+    if observation is None or (local["last_error"] and local["spend_control_reached"]):
+        return local
+    merged = dict(local)
+    for key in ("ordinary_usage_allowed", "spend_control_reached", "limit_reached_type"):
+        merged[key] = observation[key]
+    merged["available"] = wallet_available(local) and not merged["spend_control_reached"]
+    return merged

package/lib/selector_credits.py

@@ -8,6 +8,7 @@ from decimal import Decimal, InvalidOperation
 from selector_primitives import DECIMAL_RE, timestamp
 
 CAPABILITY = "codex_credits_v1"
+HARD_CREDIT_ERRORS = {"account_mismatch", "unauthenticated", "refusal_read_failed"}
 CREDIT_FIELDS = {
     "has_credits", "unlimited", "balance", "fetched_at", "account_id", "ordinary_usage_allowed",
     "spend_control_reached", "limit_reached_type", "last_error", "last_error_at", "stale", "age_seconds"}
@@ -63,7 +64,10 @@ def normalize_credits(raw: object, now: datetime, max_age: int = 900) -> dict:
     account = account.strip() if isinstance(account, str) and len(account) <= 256 else None
     try:
         observed, fetched_at = timestamp(raw.get("fetched_at"))
-        fresh = -30 <= (now - observed).total_seconds() <= max_age and raw.get("stale") is not True
+        age = (now - observed).total_seconds()
+        fresh = -30 <= age <= max_age and raw.get("stale") is not True
+        if age < -30:
+            fetched_at = None
     except (ValueError, TypeError):
         fetched_at, fresh = None, False
     reached = raw.get("limit_reached_type")
@@ -78,8 +82,9 @@ def normalize_credits(raw: object, now: datetime, max_age: int = 900) -> dict:
         "ordinary_usage_allowed": raw.get("ordinary_usage_allowed")
         if isinstance(raw.get("ordinary_usage_allowed"), bool) else None,
         "spend_control_reached": restricted, "limit_reached_type": reached,
-        "last_error": bool(raw.get("last_error")), "fresh": fresh,
-        "available": bool(fresh and account and available and not restricted and not raw.get("last_error"))}
+        "last_error": raw.get("last_error") or False, "fresh": fresh,
+        "available": bool(fetched_at and account and available and not restricted
+                          and raw.get("last_error") not in HARD_CREDIT_ERRORS)}
 
 
 def refusal_recovered(raw: dict, credits: dict, now: datetime) -> bool:
@@ -96,4 +101,5 @@ def refusal_recovered(raw: dict, credits: dict, now: datetime) -> bool:
     current = credits.get("balance")
     increased = old is not None and current is not None and Decimal(current) > Decimal(old)
     cooled = (now - blocked_time).total_seconds() >= 600
-    return bool(fetched > blocked_time and credits["available"] and (increased or cooled))
+    return bool(fetched > blocked_time and credits["available"] and credits["fresh"]
+                and not credits["last_error"] and (increased or cooled))

package/lib/selector_funding.py

@@ -5,8 +5,9 @@ from __future__ import annotations
 from decimal import Decimal, localcontext
 
 from selector_credits import CAPABILITY, normalize_credits, refusal_recovered
-from selector_credit_scope import actor_email, actor_key, actor_refusals, merge_wallet, wallet_available
-from selector_primitives import timestamp
+from selector_credit_scope import (
+    actor_email, actor_key, actor_observations, actor_refusals, merge_actor, merge_wallet, wallet_available,
+)
 
 
 def wallet_snapshots(candidates: list[dict], now, max_age: int) -> dict:
@@ -14,21 +15,20 @@ def wallet_snapshots(candidates: list[dict], now, max_age: int) -> dict:
     for raw in candidates:
         credits = normalize_credits(raw.get("credits"), now, max_age)
         key = credits["account_id"]
-        error = (raw.get("credits") or {}).get("last_error")
-        if not key or error in {"account_mismatch", "unauthenticated", "http_401", "http_403"}:
+        if not key:
             continue
-        credits["available"] = wallet_available(credits)
+        # The snapshot predates a failed refresh: its confirmed money remains true
+        # even when this slot's current credentials no longer authenticate.
+        credits["available"] = wallet_available(dict(credits, last_error=False))
         observed = credits["fetched_at"] or ""
-        if error:
-            try:
-                _, failed_at = timestamp(raw["credits"].get("last_error_at"))
-                observed = max(observed, failed_at)
-            except ValueError:
-                pass
-        credits["wallet_observed_at"] = observed
+        confirmed = bool(observed) and (credits["unlimited"]
+            or (raw.get("credits") or {}).get("has_credits") is False
+            or (credits["has_credits"] and credits["balance"] is not None))
+        credits["wallet_observed_at"], credits["wallet_confirmed"] = observed, confirmed
         previous = wallets.get(key)
-        rank = (observed, not credits["available"])
-        if previous is None or rank > (previous["wallet_observed_at"], not previous["available"]):
+        rank = (confirmed, observed, not credits["available"])
+        if previous is None or rank > (previous["wallet_confirmed"], previous["wallet_observed_at"],
+                                       not previous["available"]):
             wallets[key] = credits
     return wallets
 
@@ -37,12 +37,14 @@ def apply_funding(rows: list[dict], candidates: list[dict], now, request: dict)
     max_age = request.get("credit_max_age_seconds", 900)
     wallets = wallet_snapshots(candidates, now, max_age)
     refusals = actor_refusals(candidates)
+    observations = actor_observations(candidates, now, max_age)
     holders = {}
     for raw in candidates:
         account = (raw.get("credits") or {}).get("account_id")
         holders[account] = max(holders.get(account, 0), raw.get("credit_active_holders", 0))
     for row, raw in zip(rows, candidates):
         credits = normalize_credits(raw.get("credits"), now, max_age)
+        credits = merge_actor(credits, observations.get(actor_key(raw)))
         credits = merge_wallet(credits, wallets.get(credits["account_id"]))
         receipt = dict(raw, **refusals.get(actor_key(raw), {}))
         known = row["quota_known"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-multiacc",
-  "version": "2.0.51",
+  "version": "2.0.53",
   "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_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 && 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"
   },

package/tests/test_account_seeding.py

@@ -87,6 +87,19 @@ class AccountSeedingTests(unittest.TestCase):
                 self.seed(provider)
                 self.assertEqual((account / name).read_text(), original)
 
+    def test_claude_history_is_shared_even_before_stock_claude_runs(self):
+        shared = self.home / ".claude" / "projects"
+        self.assertFalse(shared.exists())
+        first = self.seed("claude")
+        second = self.seed("claude", self.home / ".claude-accounts" / "acct-02")
+        self.assertTrue(shared.is_dir())
+        self.assertEqual((first / "projects").resolve(), shared.resolve())
+        self.assertEqual((second / "projects").resolve(), shared.resolve())
+        session = first / "projects" / "-work" / "session.jsonl"
+        session.parent.mkdir()
+        session.write_text("session\n")
+        self.assertEqual((second / "projects" / "-work" / "session.jsonl").read_text(), "session\n")
+
     def test_local_sync_repairs_only_manifest_accounts(self):
         for provider, name, _ in PROVIDERS:
             with self.subTest(provider=provider):