claude-multiacc 2.0.50 → 2.0.52

package/tests/test_selector_credit_shim.py

@@ -0,0 +1,139 @@
+"""Real shell shim simulations with isolated accounts and a fake provider CLI."""
+
+from datetime import datetime, timezone
+import json
+import os
+from pathlib import Path
+import subprocess
+import tempfile
+import time
+import unittest
+
+from test_selector import ROOT
+from codex_credit_selection import credit_refusal_view, record_launch, record_refusal
+from autoresume_probe import parse_probe, probe_allows
+import test_autoresume as watcher_fixtures
+
+
+class CreditShimTests(unittest.TestCase):
+    def setUp(self):
+        self.temporary = tempfile.TemporaryDirectory(prefix="codex-credit-shim-")
+        self.addCleanup(self.temporary.cleanup)
+        self.home = Path(self.temporary.name)
+        self.pool, self.fake = self.home / "pool", self.home / "fake"
+        self.pool.mkdir()
+        self.fake.mkdir()
+        (self.pool / "accounts.json").write_text('{"accounts":[],"threshold":90}')
+        binary = self.fake / "codex"
+        binary.write_text('#!/bin/sh\nprintf "chosen=%s\\n" "${CODEX_HOME##*/}"\n'
+                          'if [ -n "$FAKE_ERROR" ]; then printf "%s\\n" "$FAKE_ERROR" >&2; exit 1; fi\n')
+        binary.chmod(0o755)
+        self.env = {key: value for key, value in os.environ.items()
+                    if not key.startswith(("CODEX_", "CLAUDE_"))}
+        self.env.update(HOME=str(self.home), CODEX_ACCOUNTS_ROOT=str(self.pool),
+                        PATH=str(self.fake) + os.pathsep + os.environ["PATH"],
+                        CODEX_MULTIACC_AUTORESUME="0", CLAUDE_MULTIACC_PATH_PROBE="0", FAKE_ERROR="")
+
+    def account(self, name, weekly=100, balance="100", **patch):
+        directory = self.pool / name
+        directory.mkdir(exist_ok=True)
+        (directory / "auth.json").write_text('{"tokens":{"access_token":"fake"}}')
+        now = time.time()
+        credits = {"has_credits": True, "unlimited": False, "balance": balance,
+                   "fetched_at": datetime.fromtimestamp(now, timezone.utc).isoformat(),
+                   "account_id": "wallet-" + name, "ordinary_usage_allowed": weekly < 100,
+                   "spend_control_reached": False, "limit_reached_type": "rate_limit_reached"}
+        credits.update(patch)
+        data = {"fetched_at": int(now), "max_percent": weekly, "weekly_percent": weekly,
+                "session_percent": 10, "credits": credits}
+        (directory / "limits.json").write_text(json.dumps(data, indent=1))
+        if weekly >= 90:
+            (directory / ".limited").write_text(
+                f"{int(now) + 86400}\nbucket=weekly percent={weekly} reason=limits\n")
+        return directory
+
+    def run_shim(self, probe=True, **environment):
+        env = dict(self.env, **environment)
+        if probe:
+            env["CODEX_MULTIACC_AR_PROBE"] = "1"
+        with open(os.devnull) as source:
+            return subprocess.run([str(ROOT / "bin/codex"), "exec", "test"],
+                                  env=env, stdin=source, capture_output=True, text=True, timeout=15)
+
+    def test_paid_after_included_and_reserve_and_kill_switch(self):
+        paid = self.account("acct-01")
+        result = self.run_shim()
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertIn("pick=acct-01 tier=credits", result.stdout)
+        self.assertFalse((paid / ".credit-sessions").exists(), "probe must not reserve funds")
+        self.account("acct-02", weekly=95)
+        self.assertIn("pick=acct-02 tier=soft", self.run_shim().stdout)
+        self.account("acct-03", weekly=20)
+        self.assertIn("pick=acct-03 tier=eligible", self.run_shim().stdout)
+        (self.pool / "acct-02" / "auth.json").unlink()
+        (self.pool / "acct-03" / "auth.json").unlink()
+        self.assertIn("tier=hard", self.run_shim(CODEX_MULTIACC_CREDITS="0").stdout)
+
+    def test_zero_unknown_future_spend_control_and_auth_never_paid(self):
+        for patch in ({"balance": "0"}, {"balance": None}, {"last_error": "unauthenticated"},
+                      {"fetched_at": "2099-01-01T00:00:00Z"}, {"spend_control_reached": True},
+                      {"account_id": None}, {"limit_reached_type": "workspace_owner_credits_depleted"}):
+            with self.subTest(patch=patch):
+                self.account("acct-01", **patch)
+                self.assertIn("tier=hard", self.run_shim().stdout)
+        directory = self.account("acct-01")
+        (directory / ".expired").write_text(f"{int(time.time())}\nreason=org-blocked\n")
+        self.assertIn("tier=none", self.run_shim().stdout)
+
+    def test_paid_refusal_is_durable_until_new_funds(self):
+        directory = self.account("acct-01")
+        result = self.run_shim(False, FAKE_ERROR="You've hit your usage limit")
+        self.assertEqual(result.returncode, 1, result.stderr)
+        self.assertEqual(credit_refusal_view(directory)["credit_blocked_balance"], "100")
+        self.assertIn("tier=hard", self.run_shim().stdout)
+        self.account("acct-01", balance="100")
+        self.assertIn("tier=hard", self.run_shim().stdout)
+        self.account("acct-01", balance="101")
+        self.assertIn("tier=credits", self.run_shim().stdout)
+
+    def test_transient_refusal_never_records_depletion(self):
+        directory = self.account("acct-01")
+        result = self.run_shim(False, FAKE_ERROR="429 Server is temporarily limiting requests (not your usage limit)")
+        self.assertEqual(result.returncode, 1)
+        self.assertFalse((directory / ".credit-refused.json").exists())
+
+    def test_holder_adjusted_balance_and_identity_bound_receipt(self):
+        directory = self.account("acct-01", balance="100")
+        self.account("acct-02", balance="60")
+        record_launch(directory, os.getpid(), time.time())
+        self.assertIn("pick=acct-02 tier=credits", self.run_shim().stdout)
+        record_refusal(directory, os.getpid(), time.time())
+        self.assertEqual(credit_refusal_view(directory)["limited_reason"], "credits")
+        self.account("acct-01", account_id="different-wallet")
+        self.assertEqual(credit_refusal_view(directory), {})
+
+    def test_credit_tier_autoresume_protocol(self):
+        self.assertEqual(parse_probe("pick=acct-02 tier=credits\n"), ("acct-02", "credits"))
+        self.assertTrue(probe_allows("quota", "acct-02", "credits", "acct-01"))
+        self.assertFalse(probe_allows("quota", "acct-01", "credits", "acct-01"))
+        self.assertFalse(probe_allows("auth", "acct-02", "credits", "acct-01"))
+
+    def test_paid_interactive_refusal_survives_watcher_handoff(self):
+        case = watcher_fixtures.CodexWatcherTests()
+        case.setUp()
+        self.addCleanup(case.tearDown)
+        state = case.write_state(["--yolo", "resume", watcher_fixtures.CX_SID], provider="codex")
+        with open(state, "a") as target:
+            target.write("funding_tier=credits\n")
+        case.rollout([watcher_fixtures.cx_meta(case.launched, cwd=str(case.work)),
+                      watcher_fixtures.cx_error(case.t0, "usage_limit_exceeded")])
+        watcher, runner = case.watcher(state)
+        runner.probe_out = "pick=acct-02 tier=credits\n"
+        self.assertEqual(watcher.run(), 0)
+        fields, _ = case.relaunch_of(runner)
+        self.assertEqual(fields["funding_tier"], "credits")
+        self.assertEqual(fields["funding_pid"], str(case.PID))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_selector_credits.py

@@ -0,0 +1,140 @@
+"""Paid fallback policy simulations, independent of credentials, network and quota."""
+
+from copy import deepcopy
+import json
+import subprocess
+import unittest
+
+from test_selector import ROOT, NOW, _candidate, _request
+from selector_policy import select
+
+
+def _credits(**patch):
+    value = {"has_credits": True, "unlimited": False, "balance": "61812.4520750000",
+             "fetched_at": NOW, "account_id": "wallet-a", "ordinary_usage_allowed": False,
+             "spend_control_reached": False, "limit_reached_type": "rate_limit_reached"}
+    return dict(value, **patch)
+
+
+def _paid(**patch):
+    return _candidate(engine="codex", weekly_pct=100, status="limited", limited_reason="usage",
+                      limited_until="2026-08-26T09:00:00Z", credits=_credits(), credit_capable=True,
+                      **patch)
+
+
+class FundingSelectionTests(unittest.TestCase):
+    def test_included_then_reserve_then_credits(self):
+        paid = _paid(account_id="paid")
+        reserve = _candidate(account_id="reserve", weekly_pct=97, session_pct=80)
+        included = _candidate(account_id="included", weekly_pct=75, session_pct=85)
+        for pool, winner, tier in (([paid, reserve, included], "included", "included"),
+                                   ([paid, reserve], "reserve", "reserve"),
+                                   ([paid], "paid", "credits")):
+            response = select(_request(pool, credit_fallback=True))
+            self.assertEqual((response["account_id"], response["funding_tier"]), (winner, tier))
+            self.assertEqual(response["score_basis"]["funding_tier"], tier)
+        self.assertEqual(select(_request([paid, included], credit_fallback=True,
+                         required_funding_tier="credits"))["account_id"], "paid")
+        paid["session_pct"] = None
+        paid["credits"]["ordinary_usage_allowed"] = None
+        self.assertEqual(select(_request([paid], credit_fallback=True))["funding_tier"], "credits")
+        paid["credits"]["balance"] = "0"
+        self.assertFalse(select(_request([paid], credit_fallback=True))["ok"])
+
+    def test_included_preserves_gate_and_weekly_band(self):
+        pool = [_candidate(account_id="a", weekly_pct=10, session_pct=80),
+                _candidate(account_id="b", weekly_pct=60, session_pct=20),
+                _candidate(account_id="c", weekly_pct=75, session_pct=50), _paid(account_id="paid")]
+        winners = {select(_request(pool, credit_fallback=True, reservation_key=f"task-{n}"))["account_id"]
+                   for n in range(100)}
+        self.assertEqual(winners, {"b", "c"})
+
+    def test_credits_fail_closed_for_all_restrictions(self):
+        bad_credits = ({"balance": "0"}, {"balance": None}, {"balance": "NaN"},
+                       {"balance": "-1"}, {"has_credits": False}, {"account_id": None},
+                       {"fetched_at": None}, {"fetched_at": "2026-08-25T09:00:31Z"},
+                       {"last_error": "unauthenticated"}, {"last_error": "refusal_read_failed"},
+                       {"spend_control_reached": True},
+                       {"limit_reached_type": "workspace_owner_usage_limit_reached"},
+                       {"limit_reached_type": "unknown"})
+        for patch in bad_credits:
+            with self.subTest(patch=patch):
+                row = _paid()
+                row["credits"].update(patch)
+                self.assertEqual(select(_request([row], credit_fallback=True))["error_code"], "no_candidate")
+        for patch in ({"credit_capable": False}, {"status": "expired"}, {"status": "blocked"},
+                      {"limited_reason": "auth"}, {"limited_reason": "disabled"},
+                      {"seen_at": "2026-08-25T08:54:59Z"}, {"provider_capable": False},
+                      {"reservation_history": {"last_selected_at": None,
+                                               "active_expires_at": "2026-08-25T09:01:00Z"}}):
+            with self.subTest(patch=patch):
+                row = dict(_paid(), **patch)
+                self.assertEqual(select(_request([row], credit_fallback=True))["error_code"], "no_candidate")
+
+    def test_unlimited_and_balance_per_holder_rank_without_percentage_clamp(self):
+        a, b = _paid(account_id="a"), _paid(account_id="b")
+        a["credits"]["balance"], b["credits"]["balance"] = "60000.123", "50000"
+        a["credits"]["account_id"], b["credits"]["account_id"] = "wallet-a", "wallet-b"
+        a["credit_active_holders"] = 1
+        response = select(_request([a, b], credit_fallback=True))
+        self.assertEqual(response["account_id"], "b")
+        self.assertEqual(response["score_basis"]["credit_balance"], "50000")
+        a["credits"].update(unlimited=True, balance=None)
+        self.assertEqual(select(_request([a, b], credit_fallback=True))["account_id"], "a")
+
+    def test_paid_refusal_needs_cooldown_and_new_read_or_increased_balance(self):
+        row = _paid()
+        row.update(limited_reason="credits", credit_blocked_at="2026-08-25T08:59:00Z",
+                   credit_blocked_balance="61812.452075")
+        self.assertFalse(select(_request([row], credit_fallback=True))["ok"])
+        row["credits"]["balance"] = "62000"
+        self.assertTrue(select(_request([row], credit_fallback=True))["ok"])
+        row["credits"]["balance"] = "61812.452075"
+        row["credit_blocked_at"] = "2026-08-25T08:49:00Z"
+        self.assertTrue(select(_request([row], credit_fallback=True))["ok"])
+        row["credits"]["fetched_at"] = "2026-08-25T08:48:00Z"
+        self.assertFalse(select(_request([row], credit_fallback=True))["ok"])
+
+    def test_funding_proof_covers_inputs_and_repeats(self):
+        request = _request([_paid()], credit_fallback=True)
+        first = select(request)
+        self.assertEqual(first, select(deepcopy(request)))
+        self.assertEqual(first["credit_capability"], "codex_credits_v1")
+        self.assertEqual(first["candidate_snapshot_digest"],
+                         "ccf7afd64b788f03e3fd9a1e6f4b2b0741bee957dd18ff028d1f328177dff0d6")
+        self.assertEqual(first["selection_digest"],
+                         "6a3f9b1b7c90dfd68841482d4fec30e18152338d401deab0a384c75f11750f4e")
+        request["candidates"][0]["credits"]["balance"] = "1"
+        self.assertNotEqual(first["candidate_snapshot_digest"], select(request)["candidate_snapshot_digest"])
+        request["credit_max_age_seconds"] = 600
+        self.assertNotEqual(first["selection_digest"], select(request)["selection_digest"])
+
+    def test_replicated_wallet_uses_newest_balance_and_shared_holder_count(self):
+        old, latest, other = _paid(account_id="old"), _paid(account_id="latest"), _paid(account_id="other")
+        old["credits"].update(balance="100000", fetched_at="2026-08-25T08:59:00Z")
+        latest["credits"].update(balance="100")
+        other["credits"].update(account_id="different-wallet", balance="75")
+        latest["credit_active_holders"] = 1
+        self.assertEqual(select(_request([old, latest, other], credit_fallback=True))["account_id"], "other")
+        latest["credits"]["balance"] = "0"
+        self.assertFalse(select(_request([old, latest], credit_fallback=True))["ok"])
+
+    def test_opt_in_and_capability_fence(self):
+        self.assertEqual(select(_request([_paid()]))["error_code"], "invalid_request")
+        for patch in ({"credit_fallback": []}, {"required_funding_tier": []},
+                      {"credit_max_age_seconds": True}, {"credit_max_age_seconds": 3601}):
+            response = select(_request([_candidate()], credit_fallback=True, **patch)) \
+                if "credit_fallback" not in patch else select(_request([_candidate()], **patch))
+            self.assertEqual(response["error_code"], "invalid_request")
+        output = subprocess.check_output([str(ROOT / "bin/multiacc-select"), "--capabilities"], text=True)
+        self.assertEqual(json.loads(output)["capabilities"], ["codex_credits_v1"])
+
+        for key, value in (("account_id", []), ("balance", {}), ("unlimited", 1), ("stale", "false")):
+            row = _paid()
+            row["credits"][key] = value
+            response = select(_request([row], credit_fallback=True))
+            self.assertEqual(response["error_code"], "invalid_request")
+            self.assertEqual(response["error_detail"]["field"], f"candidates[0].credits.{key}")
+
+if __name__ == "__main__":
+    unittest.main()