claude-multiacc 2.0.22 → 2.0.24

package/README.md

@@ -378,6 +378,12 @@ Codex-specific notes:
   and writes a per-account/window idempotency key before redemption so a lost response
   or simultaneous fleet poll cannot spend a second reset. Set
   `CODEX_MULTIACC_AUTO_RESET=0` only for emergency rollback/testing.
+  A finished-limit verdict takes precedence over a conflicting percentage. The
+  redemption key excludes unused model windows whose reset clocks move between reads.
+  Eligible accounts, including spent ones, check the credit endpoint every five
+  minutes even if the usage summary still says zero credits. A newly granted reset
+  is redeemed during that pass and clears the old limit; no-credit results are
+  checked again next pass, without waiting for the weekly reset date.
 - **API-key logins are rejected** — ChatGPT subscription accounts only, matching the
   addon's no-API-keys rule.
 

package/lib/codex_reset.py

@@ -1,8 +1,9 @@
 """Automatic redemption of earned Codex usage-limit reset credits.
 
 The Codex CLI exposes reset credits through the same authenticated backend as
-usage telemetry.  This module is called only after a fresh usage response says
-an account has 5% or less remaining.  A pending idempotency key is written
+usage telemetry. Each scheduled eligible usage pass reads the credit endpoint,
+even when the usage response's embedded credit summary is empty or out of date.
+A pending idempotency key is written
 before the mutation so a lost response can be retried without spending twice.
 """
 
@@ -16,6 +17,8 @@ import urllib.parse
 import urllib.request
 import uuid
 
+from codex_reset_windows import reset_windows
+
 RESET_AT_USED_PERCENT = 95
 REDEEM_COOLDOWN_SECONDS = 900
 STATE_FILE = ".usage-reset.json"
@@ -100,21 +103,8 @@ def _pending_request(account_dir: str, now: int) -> tuple[dict, str]:
 def _redeem_request_id(account_id: str, usage: dict, headers: dict, now: int) -> str:
     """Return one fleet-stable UUID for this account's current limit windows."""
     subject = str(headers.get("chatgpt-account-id") or account_id)
-    resets = []
-    stack = [usage]
-    while stack:
-        node = stack.pop()
-        if isinstance(node, dict):
-            value = node.get("reset_at")
-            if value is not None:
-                try:
-                    resets.append(int(float(value)))
-                except (TypeError, ValueError):
-                    pass
-            stack.extend(node.values())
-        elif isinstance(node, list):
-            stack.extend(node)
-    cycle = sorted(set(resets)) or [f"hour-{now // 3600}"]
+    _, resets = reset_windows(usage, RESET_AT_USED_PERCENT)
+    cycle = resets or [f"hour-{now // 3600}"]
     seed = json.dumps({"account": subject, "resets": cycle}, sort_keys=True)
     return str(uuid.uuid5(uuid.NAMESPACE_URL, seed))
 
@@ -124,16 +114,16 @@ def try_auto_redeem(account_dir: str, account_id: str, used_percent: int,
                     now: int | None = None) -> dict:
     """Redeem one available reset and return a non-secret outcome document."""
     current = int(now if now is not None else time.time())
-    if not auto_reset_enabled() or used_percent < RESET_AT_USED_PERCENT:
+    finished, _ = reset_windows(usage, RESET_AT_USED_PERCENT)
+    if not auto_reset_enabled() or (used_percent < RESET_AT_USED_PERCENT and not finished):
         return {"status": "not_eligible"}
     state, disposition = _pending_request(account_dir, current)
     if disposition == "cooldown":
         return {"status": "cooldown", "outcome": state.get("outcome")}
     list_url, consume_url = _reset_urls(usage_url)
     if disposition == "new":
-        summary = usage.get("rate_limit_reset_credits")
-        if isinstance(summary, dict) and int(summary.get("available_count") or 0) <= 0:
-            return {"status": "no_credit"}
+        # Newly granted credits can precede the usage response's embedded summary.
+        # The scheduled usage cadence bounds these reads, including spent accounts.
         try:
             available_count, credit_id = _credit_to_redeem(_request(list_url, headers))
         except Exception as error:

package/lib/codex_reset_windows.py

@@ -0,0 +1,36 @@
+"""Redemption eligibility and identity use exhausted windows, never idle model clocks."""
+
+
+def _number(value):
+    try:
+        return float(value)
+    except (TypeError, ValueError, OverflowError):
+        return 0
+
+
+def reset_windows(usage: dict, threshold: int) -> tuple[bool, list[int]]:
+    finished, resets, stack = False, set(), [usage]
+    while stack:
+        node = stack.pop()
+        if isinstance(node, list):
+            stack.extend(node)
+            continue
+        if not isinstance(node, dict):
+            continue
+        hard_limit = node.get("limit_reached") is True or node.get("allowed") is False
+        finished = finished or hard_limit
+        windows = [node] if _number(node.get("used_percent")) >= threshold else []
+        if hard_limit:
+            reported = [node[key] for key in ("primary_window", "secondary_window")
+                        if isinstance(node.get(key), dict)]
+            peak = max((_number(window.get("used_percent")) for window in reported), default=0)
+            windows.extend(window for window in reported if _number(window.get("used_percent")) == peak)
+        for window in windows:
+            try:
+                reset = int(float(window.get("reset_at")))
+                if reset > 0:
+                    resets.add(reset)
+            except (TypeError, ValueError, OverflowError):
+                pass
+        stack.extend(node.values())
+    return finished, sorted(resets)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-multiacc",
-  "version": "2.0.22",
+  "version": "2.0.24",
   "description": "Unified Claude Code and OpenAI Codex subscription pooling with quota-aware selection.",
   "type": "module",
   "bin": {

package/tests/run-tests.sh

@@ -6558,7 +6558,7 @@ unset FAKE_KEYCHAIN_DIR
 
 # The reset-credit contract is easier to prove against a stateful local HTTP server
 # than file:// fixtures: it pins thresholding, credit ordering and idempotent POST retry.
-if CODEX_MULTIACC_AUTO_RESET=1 python3 "$REPO_DIR/tests/test_codex_reset.py"; then
+if CODEX_MULTIACC_AUTO_RESET=1 python3 -m unittest discover -s "$REPO_DIR/tests" -p 'test_codex_reset*.py'; then
   t_ok "codex: automatic earned-reset integration suite"
 else
   t_fail "codex automatic reset suite" "see unittest output above"

package/tests/test_codex_reset_polling.py

@@ -0,0 +1,94 @@
+"""Scheduled passes discover newly granted resets despite an old usage summary."""
+
+import json
+import os
+import subprocess
+import time
+import unittest
+
+import test_codex_reset as fixtures
+
+
+class ResetPollingTest(fixtures.CodexPoolSandbox, unittest.TestCase):
+    def setUp(self):
+        super().setUp()
+        now = int(time.time())
+        self.server.state["usage"] = {"rate_limit": {"allowed": False, "limit_reached": True,
+            "primary_window": {"used_percent": 100, "limit_window_seconds": 604800,
+                               "reset_at": now + 6 * 86400}},
+            "rate_limit_reset_credits": {"available_count": 0}}
+        self.server.state["credits"] = {"available_count": 0, "credits": []}
+
+    def run_scheduled(self, enabled="1"):
+        base = f"http://127.0.0.1:{self.server.server_port}/wham"
+        env = dict(os.environ, CODEX_ACCOUNTS_ROOT=str(self.pool), CODEX_MULTIACC_NO_SYNC="1",
+                   CODEX_MULTIACC_AUTO_RESET=enabled, CODEX_MULTIACC_USAGE_URL=f"{base}/usage",
+                   PYTHONDONTWRITEBYTECODE="1")
+        for key in ("CODEX_MULTIACC_MIN_FETCH", "CODEX_MULTIACC_RESET_CREDITS_URL",
+                    "CODEX_MULTIACC_RESET_CONSUME_URL"):
+            env.pop(key, None)
+        result = subprocess.run([fixtures.REPO / "bin/codex-accounts", "limits", "--quiet"],
+                                capture_output=True, text=True, env=env, timeout=20, check=False)
+        self.assertEqual(result.returncode, 0, result.stderr)
+
+    def next_pass(self):
+        path = self.pool / "acct-01/limits.json"
+        usage = json.loads(path.read_text())
+        usage["fetched_at"] = int(time.time()) - 301
+        path.write_text(json.dumps(usage))
+
+    def grant_credit(self):
+        self.server.state["credits"] = {"available_count": 1, "credits": [
+            {"id": "newly-granted", "status": "available", "expires_at": "2099-01-01T00:00:00Z"}]}
+        self.server.state["responses"] = [(200, {"code": "reset", "windows_reset": 1})]
+
+    def test_limited_account_polls_again_and_uses_a_new_credit(self):
+        self.run_scheduled()
+        self.assertEqual(self.server.state["credit_gets"], 1)
+        marker = self.pool / "acct-01/.limited"
+        self.assertTrue(marker.exists())
+        self.assertEqual(self.server.state["posts"], [])
+        self.run_scheduled()
+        self.assertEqual(self.server.state["credit_gets"], 1)  # Normal fetch cadence still applies.
+        self.next_pass()
+        self.run_scheduled()
+        self.assertEqual(self.server.state["credit_gets"], 2)
+        self.assertTrue(marker.exists())
+        self.grant_credit()
+        self.next_pass()
+        self.run_scheduled()
+        self.assertEqual(self.server.state["credit_gets"], 3)
+        self.assertEqual(self.server.state["posts"][0]["credit_id"], "newly-granted")
+        self.assertFalse(marker.exists())
+        receipt = json.loads((self.pool / "acct-01/.usage-reset.json").read_text())
+        self.assertEqual(receipt["state"], "complete")
+        usage = json.loads((self.pool / "acct-01/limits.json").read_text())
+        self.assertEqual(usage["fetched_at"], 0)  # Pre-reset exhaustion cannot exclude it again.
+
+    def test_malformed_usage_summary_does_not_hide_a_credit(self):
+        self.server.state["usage"]["rate_limit_reset_credits"]["available_count"] = "unknown"
+        self.grant_credit()
+        self.run_scheduled()
+        self.assertEqual(len(self.server.state["posts"]), 1)
+
+    def test_credit_lookup_failure_preserves_limit_and_retries_next_pass(self):
+        self.server.state["credits"] = []  # An unreadable credit response is not a reset.
+        self.run_scheduled()
+        self.assertTrue((self.pool / "acct-01/.limited").exists())
+        self.assertEqual(self.server.state["posts"], [])
+        self.grant_credit()
+        self.next_pass()
+        self.run_scheduled()
+        self.assertEqual(self.server.state["credit_gets"], 2)
+        self.assertFalse((self.pool / "acct-01/.limited").exists())
+
+    def test_disabled_automation_does_not_query_or_spend_credits(self):
+        self.grant_credit()
+        self.run_scheduled(enabled="0")
+        self.assertEqual(self.server.state["credit_gets"], 0)
+        self.assertEqual(self.server.state["posts"], [])
+        self.assertTrue((self.pool / "acct-01/.limited").exists())
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_codex_reset_windows.py

@@ -0,0 +1,43 @@
+"""Earned resets honor finished limits and ignore unrelated rolling windows."""
+import time
+import unittest
+
+import test_codex_reset as fixtures
+
+
+class ResetWindowsTest(fixtures.CodexPoolSandbox, unittest.TestCase):
+    run_limits = fixtures.CodexResetIntegrationTest.run_limits
+
+    def test_finished_limit_redeems_even_below_numeric_reset_threshold(self):
+        now = int(time.time())
+        self.server.state["usage"] = {"rate_limit": {"allowed": False, "limit_reached": True,
+            "primary_window": {"used_percent": 94, "limit_window_seconds": 604800, "reset_at": now + 86400}},
+            "rate_limit_reset_credits": {"available_count": 1}}
+        self.server.state["credits"] = {"available_count": 1, "credits": []}
+        self.server.state["responses"] = [(200, {"code": "reset", "windows_reset": 1})]
+        result = self.run_limits()
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(len(self.server.state["posts"]), 1)
+
+    def test_unused_model_windows_do_not_change_the_fleet_redemption_key(self):
+        now = int(time.time())
+        self.server.state["usage"] = {"rate_limit": {"allowed": True,
+            "primary_window": {"used_percent": 95, "limit_window_seconds": 604800, "reset_at": now + 86400}},
+            "additional_rate_limits": [{"limit_name": "Unused model", "rate_limit": {
+                "primary_window": {"used_percent": 0, "limit_window_seconds": 18000, "reset_at": now + 18000}}}],
+            "rate_limit_reset_credits": {"available_count": 2}}
+        self.server.state["credits"] = {"available_count": 2, "credits": []}
+        self.server.state["responses"] = [(200, {"code": "reset", "windows_reset": 1}),
+                                         (200, {"code": "already_redeemed", "windows_reset": 1})]
+        self.assertEqual(self.run_limits().returncode, 0)
+        # A fleet peer has no local receipt and sees a shifted idle-model window.
+        (self.pool / "acct-01/.usage-reset.json").unlink()
+        self.server.state["usage"]["additional_rate_limits"][0]["rate_limit"]["primary_window"]["reset_at"] += 30
+        self.assertEqual(self.run_limits().returncode, 0)
+        posts = self.server.state["posts"]
+        self.assertEqual(len(posts), 2)
+        self.assertEqual(posts[0]["redeem_request_id"], posts[1]["redeem_request_id"])
+
+
+if __name__ == "__main__":
+    unittest.main()