relay-codex 0.7.0 → 0.7.1

package/README.md

@@ -69,7 +69,8 @@ Use a session's menu to switch accounts after its work finishes. Account menus c
 enable or disable future routing without stopping current tasks. Actions show
 their result, and stopped workers offer a restart.
 Account menus also show earned usage resets when available. Choose **Use available
-reset…** and confirm to spend one; Relay refreshes allowance afterward. Recovery
+reset…** and confirm to spend one; Relay refreshes allowance afterward. The button
+is enabled only with weekly allowance at 0% and its reset more than 48 hours away. Recovery
 never spends these resets automatically.
 
 For tab completion in Zsh, run `source <(relay completion zsh)` after `compinit`.

package/docs/commands.md

@@ -51,13 +51,17 @@ A session cap of zero means unlimited. Removing an account retains its login
 unless you request `--revoke`.
 
 The account menu shows **Usage resets available** and **Use available reset…**
-when Codex reports an earned reset. Choose it and confirm to use one. If the count
+when Codex reports an earned reset. It is enabled only when weekly allowance is
+fully exhausted (0%) and the weekly reset is **more than 48 hours away**. Exactly
+48 hours, any weekly allowance left, or unknown weekly data keeps it disabled.
+The reason appears below the button. Choose it and confirm to use one. If the count
 is unknown, choose **Check allowance now** first. Reset availability is separate
 from purchased workspace credits. Resets are never spent by automatic recovery.
 
 The equivalent terminal command is `relay account reset ACCOUNT --yes`. If a
 response is lost, use the same action again: Relay saves and reuses the pending
-request rather than submitting a new redemption. The menu calls this **Check
+request rather than submitting a new redemption. Pending retries must satisfy
+the same weekly rule; their saved request is retained when locked. The menu calls this **Check
 previous reset…**. An optional `--request-id UUID` also identifies a specific
 logical attempt. Codex chooses the available reset; Relay checks the returned
 result and reads allowance again afterward.

package/docs/publishing.md

@@ -8,8 +8,8 @@ Friends can run `npx relay-codex` or install it with `npm install -g relay-codex
 The GitHub repository is enough for friends to install or try Relay:
 
 ```sh
-npm install -g github:blackspider-ops/relay#v0.7.0
-npx --yes github:blackspider-ops/relay#v0.7.0 --version
+npm install -g github:blackspider-ops/relay#v0.7.1
+npx --yes github:blackspider-ops/relay#v0.7.1 --version
 ```
 
 `npx` runs packages; it is not a separate publishing service. Publishing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-codex",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Keep your Codex sessions moving between your own accounts.",
   "license": "MIT",
   "author": "blackspider-ops",

package/python/Menu.swift

@@ -12,6 +12,8 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
     var reconnect: DispatchWorkItem?
     var stopping = false
     var snapshotInFlight = false
+    var resetExpiry: DispatchWorkItem?
+    var menuOpen = false
     let command = Bundle.main.object(forInfoDictionaryKey: "RelayCommand") as? String ?? "/usr/bin/false"
     let state = Bundle.main.object(forInfoDictionaryKey: "RelayState") as? String ?? ""
 
@@ -140,6 +142,15 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
         guard let seconds = value as? Double, seconds.isFinite, seconds > 0 else { return nil }
         return seconds
     }
+    static func resetBlockReason(_ account: [String: Any], now: Double = Date().timeIntervalSince1970) -> String? {
+        guard let weekly = account["secondary"] as? [String: Any], let used = (weekly["usedPercent"] as? NSNumber)?.doubleValue, used.isFinite else {
+            return "Reset locked: check allowance to confirm the weekly limit and reset time."
+        }
+        guard used >= 100 else { return "Reset locked: weekly allowance must be fully exhausted (0%)." }
+        guard let at = timestamp(weekly["resetsAt"]) else { return "Reset locked: check allowance to confirm the weekly limit and reset time." }
+        guard at - now > 48 * 60 * 60 else { return "Reset locked: the weekly reset must be more than 48 hours away." }
+        return nil
+    }
     static func accountTimingRows(_ account: [String: Any]) -> [TimingRow] {
         var rows: [TimingRow] = []
         if let primary = account["primary"] as? [String: Any], let at = timestamp(primary["resetsAt"]) {
@@ -182,6 +193,7 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
         updateTimes(menu)
         if let visible = item.menu { MenuController.synchronise(visible, with: menu) }
         else { item.menu = menu }
+        if menuOpen { scheduleResetExpiry() }
     }
     func makeMenu() -> NSMenu {
         let sessions = current["sessions"] as? [[String: Any]] ?? []
@@ -233,8 +245,10 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
                 if let count = resetCount { text("Usage resets available: \(count)", into: submenu) }
                 else { text("Usage resets: check allowance to see availability.", into: submenu) }
                 if pendingReset || (resetCount ?? 0) > 0 {
+                    let blocked = MenuController.resetBlockReason(account)
                     let reset = action(pendingReset ? "Check previous reset…" : "Use available reset…", args: ["confirm-reset", id, name, pendingReset ? "pending" : "new"], into: submenu)
-                    reset.isEnabled = !actionRunning && !(account["maintenance"] as? Bool ?? false)
+                    reset.isEnabled = !actionRunning && !(account["maintenance"] as? Bool ?? false) && blocked == nil
+                    if let blocked = blocked { text(blocked, into: submenu) }
                 }
                 submenu.addItem(.separator())
                 let enabled = account["enabled"] as? Bool ?? true
@@ -298,12 +312,37 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
         return menu
     }
     func menuWillOpen(_ menu: NSMenu) {
+        menuOpen = true
+        render()
         refreshSnapshot()
         updateTimes(menu)
         for entry in menu.items where entry.title == "Open at login" {
             entry.state = FileManager.default.fileExists(atPath: NSHomeDirectory() + "/Library/LaunchAgents/local.relay.menu.plist") ? .on : .off
         }
     }
+    func scheduleResetExpiry() {
+        resetExpiry?.cancel()
+        let now = Date().timeIntervalSince1970
+        let accounts = current["accounts"] as? [[String: Any]] ?? []
+        let boundaries = accounts.compactMap { account -> Double? in
+            guard MenuController.resetBlockReason(account, now: now) == nil, let weekly = account["secondary"] as? [String: Any], let at = MenuController.timestamp(weekly["resetsAt"]) else { return nil }
+            return at - 48 * 60 * 60
+        }
+        if let boundary = boundaries.min() {
+            let expiry = DispatchWorkItem { [weak self] in self?.render() }
+            resetExpiry = expiry
+            DispatchQueue.main.asyncAfter(deadline: .now() + max(0, boundary - now), execute: expiry)
+        }
+    }
+    func menuDidClose(_ menu: NSMenu) { menuOpen = false; resetExpiry?.cancel(); resetExpiry = nil }
+    func resetAllowed(_ id: String) -> Bool {
+        let accounts = current["accounts"] as? [[String: Any]] ?? []
+        guard let account = accounts.first(where: { $0["id"] as? String == id }) else {
+            actionNotice = "Reset locked: account details are unavailable."; actionFailed = true; render(); return false
+        }
+        if let reason = MenuController.resetBlockReason(account) { actionNotice = reason; actionFailed = true; render(); return false }
+        return true
+    }
     @objc func runAction(_ sender: NSMenuItem) {
         guard var args = sender.representedObject as? [String], !args.isEmpty else { return }
         if args[0] == "copy" { NSPasteboard.general.clearContents(); NSPasteboard.general.setString(args[1], forType: .string); return }
@@ -317,12 +356,14 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
             args = ["retry", args[1], "--wait"]
         }
         if args[0] == "confirm-reset" {
+            guard resetAllowed(args[1]) else { return }
             let pending = args[3] == "pending"
             let alert = NSAlert(); alert.messageText = pending ? "Check the previous reset?" : "Use one usage reset?"
             alert.informativeText = args[2] + "\n\n" + (pending ? "Relay will check the same pending request. If it already used a reset, another one will not be spent." : "This spends one earned reset on eligible usage limits for this account. Allowance will be checked afterward. Paused tasks and review holds stay paused.")
             alert.addButton(withTitle: pending ? "Check reset" : "Use reset"); alert.addButton(withTitle: "Cancel")
             NSApp.activate(ignoringOtherApps: true)
             guard alert.runModal() == .alertFirstButtonReturn else { return }
+            guard resetAllowed(args[1]) else { return }
             args = ["account", "reset", args[1], "--yes", "--request-id", UUID().uuidString]
         }
         actionRunning = true; actionFailed = false; actionNotice = "Applying change…"; render()
@@ -413,11 +454,18 @@ if CommandLine.arguments.contains("--self-check") {
     let correctEmpty = empty.items.contains { $0.title.contains("No Relay sessions running") } && empty.items.first { $0.identifier?.rawValue == "account:one" }?.state == .off
     controller.current["sessions"] = originalSessions
     let originalAccounts = controller.current["accounts"]
-    controller.current["accounts"] = [["id": "one", "name": "One", "reset_credits": 2], ["id": "two", "name": "Two", "reset_credits": 0], ["id": "unknown", "name": "Unknown"], ["id": "pending", "name": "Pending", "reset_pending": true]]
+    controller.current["accounts"] = [["id": "one", "name": "One", "reset_credits": 2, "secondary": ["usedPercent": 100, "resetsAt": Date().timeIntervalSince1970 + 72 * 3600]], ["id": "two", "name": "Two", "reset_credits": 0], ["id": "unknown", "name": "Unknown"], ["id": "pending", "name": "Pending", "reset_pending": true]]
     let resets = controller.makeMenu()
     let correctResets = findAction(["confirm-reset", "one", "One", "new"], in: resets)?.isEnabled == true && findAction(["confirm-reset", "two", "Two", "new"], in: resets) == nil && findAction(["confirm-reset", "unknown", "Unknown", "new"], in: resets) == nil && findAction(["confirm-reset", "pending", "Pending", "pending"], in: resets) != nil
     controller.actionRunning = true
     let resetLocked = findAction(["confirm-reset", "one", "One", "new"], in: controller.makeMenu())?.isEnabled == false
+    let policyNow = 2000000000.0
+    let far: [String: Any] = ["secondary": ["usedPercent": 100, "resetsAt": policyNow + 172801]]
+    let exact: [String: Any] = ["secondary": ["usedPercent": 100, "resetsAt": policyNow + 172800]]
+    let near: [String: Any] = ["secondary": ["usedPercent": 100, "resetsAt": policyNow + 172799]]
+    let left: [String: Any] = ["secondary": ["usedPercent": 99.99, "resetsAt": policyNow + 259200]]
+    let correctPolicy = MenuController.resetBlockReason(far, now: policyNow) == nil && MenuController.resetBlockReason(exact, now: policyNow) != nil && MenuController.resetBlockReason(near, now: policyNow) != nil && MenuController.resetBlockReason(left, now: policyNow) != nil && MenuController.resetBlockReason([:], now: policyNow) != nil
+    let pendingLocked = findAction(["confirm-reset", "pending", "Pending", "pending"], in: resets)?.isEnabled == false
     controller.current["accounts"] = originalAccounts
     controller.actionRunning = true; controller.actionNotice = "Applying change…"
     let pending = controller.makeMenu()
@@ -429,7 +477,8 @@ if CommandLine.arguments.contains("--self-check") {
     print("Pending action protected and result retained: \(correctPending && retainedResult)")
     print("In-use accounts and current choice marked: \(correctMarker && correctMultiple && correctEmpty)")
     print("Available and pending reset actions protected: \(correctResets && resetLocked)")
-    exit(normal != nil && attention != nil && liveUpdate && safeIdentity && correctTiming && correctChoices && stoppedControls && correctPending && retainedResult && correctMarker && correctMultiple && correctEmpty && correctResets && resetLocked ? 0 : 1)
+    print("Weekly zero and more-than-48-hour guard enforced: \(correctPolicy && pendingLocked)")
+    exit(normal != nil && attention != nil && liveUpdate && safeIdentity && correctTiming && correctChoices && stoppedControls && correctPending && retainedResult && correctMarker && correctMultiple && correctEmpty && correctResets && resetLocked && correctPolicy && pendingLocked ? 0 : 1)
 } else {
     let app = NSApplication.shared
     let delegate = MenuController(); app.delegate = delegate; app.run()

package/python/commands.py

@@ -114,6 +114,7 @@ def snapshot(state, include_inactive=False):
                     "usage_checked_at": pool.checked_at(label),
                     "reset_credits": resets.available(usage),
                     "reset_pending": resets.pending(state / "accounts" / label),
+                    "reset_lock_reason": resets.weekly_block_reason(usage),
                     "maintenance": options.get("maintenance", False),
                     "next_check": min(
                         (b["next_check"] for b in blocks if b["account"] == label),

package/python/resets.py

@@ -2,6 +2,7 @@
 
 import hashlib
 import json
+import math
 import time
 import uuid
 
@@ -9,6 +10,29 @@ from pool import Pool, blocked, reset_time
 from settings import atomic_json
 
 OUTCOMES = {"reset", "alreadyRedeemed", "nothingToReset", "noCredit"}
+WEEKLY_RESET_BUFFER = 48 * 60 * 60
+
+
+def weekly_block_reason(snapshot, now=None):
+    window = ((snapshot or {}).get("rateLimits") or {}).get("secondary")
+    if not isinstance(window, dict):
+        return (
+            "Reset locked: check allowance to confirm the weekly limit and reset time."
+        )
+    used, at = window.get("usedPercent"), window.get("resetsAt")
+    if type(used) not in (int, float) or not math.isfinite(used):
+        return (
+            "Reset locked: check allowance to confirm the weekly limit and reset time."
+        )
+    if used < 100:
+        return "Reset locked: weekly allowance must be fully exhausted (0%)."
+    if type(at) not in (int, float) or not math.isfinite(at):
+        return (
+            "Reset locked: check allowance to confirm the weekly limit and reset time."
+        )
+    if at - (time.time() if now is None else now) <= WEEKLY_RESET_BUFFER:
+        return "Reset locked: the weekly reset must be more than 48 hours away."
+    return None
 
 
 def available(snapshot):
@@ -122,13 +146,16 @@ async def consume(state, label, binary, request_id=None):
                 )
             if known and outcome == "reset":
                 outcome = "alreadyRedeemed"
-            if not retry and not known:
+            if not known:
                 current = await rpc.call("account/rateLimits/read")
                 update_allowance(pool, label, current)
+                reason = weekly_block_reason(current)
+                if reason:
+                    raise RouterError(reason)
                 count = available(current)
-                if count == 0:
+                if count == 0 and not retry:
                     return {"outcome": "noCredit", "refreshed": True}
-                if count is None:
+                if count is None and not retry:
                     raise RouterError(
                         "Codex did not report reset availability. Check allowance again before using a reset."
                     )

package/python/router.py

@@ -24,7 +24,7 @@ from pool import Pool, blocked, reset_time, failure_kind, file_lock
 from launch import translate, RESUME_FIELDS
 import settings
 
-VERSION = "0.7.0"
+VERSION = "0.7.1"
 _support = Path.home() / "Library/Application Support"
 _legacy = _support / "Codex Accounts"
 _default_state = _legacy if (_legacy / "accounts").exists() else _support / "Relay"

package/tests/fake_native.py

@@ -127,10 +127,21 @@ for raw in sys.stdin:
             result = {"type": params["type"]}
         elif method == "account/rateLimits/read":
             reset_count = change(lambda d: d.get("reset_credit_count", 1))
+            weekly = change(
+                lambda d: (
+                    {
+                        "usedPercent": d["reset_weekly_used"],
+                        "resetsAt": d["reset_weekly_at"],
+                    }
+                    if "reset_weekly_used" in d
+                    else None
+                )
+            )
             result = {
                 "ordinaryUsageAllowed": True,
                 "rateLimits": {
-                    "primary": {"usedPercent": 20, "resetsAt": int(time.time()) + 3600}
+                    "primary": {"usedPercent": 20, "resetsAt": int(time.time()) + 3600},
+                    "secondary": weekly,
                 },
                 "rateLimitResetCredits": {
                     "availableCount": reset_count,
@@ -149,6 +160,8 @@ for raw in sys.stdin:
                     return {"outcome": "noCredit"}
                 keys.append(key)
                 data["reset_credit_count"] = count - 1
+                if "reset_weekly_used" in data:
+                    data["reset_weekly_used"] = 0
                 return {"outcome": "reset"}
 
             result = change(redeem)

package/tests/test_resets.py

@@ -27,6 +27,8 @@ class ResetService:
         self.residual_limit = False
         self.outcome = None
         self.reject = False
+        self.weekly_used = 100
+        self.weekly_at = time.time() + 72 * 3600
 
     async def call(self, method, params=None):
         await asyncio.sleep(0)
@@ -39,7 +41,11 @@ class ResetService:
                     "primary": {
                         "usedPercent": 100 if self.blocked else 0,
                         "resetsAt": time.time() + 3600,
-                    }
+                    },
+                    "secondary": {
+                        "usedPercent": self.weekly_used,
+                        "resetsAt": self.weekly_at,
+                    },
                 },
                 "rateLimitResetCredits": {
                     "availableCount": self.count,
@@ -194,11 +200,67 @@ class ResetTests(unittest.IsolatedAsyncioTestCase):
             with self.assertRaisesRegex(RouterError, "--yes"):
                 await commands.manage(args, self.root, "fake")
 
+    async def test_weekly_guard_blocks_all_mutation_until_zero_and_more_than_48_hours(
+        self,
+    ):
+        for used, hours in ((0, 72), (99.99, 72), (100, 48), (100, 47), (100, -1)):
+            with self.subTest(used=used, hours=hours):
+                self.service.weekly_used = used
+                self.service.weekly_at = time.time() + hours * 3600
+                with self.assertRaisesRegex(RouterError, "Reset locked"):
+                    await resets.consume(self.root, "one", "fake")
+                self.assertFalse(self.service.calls)
+                self.assertFalse((self.home / "reset-attempt.json").exists())
+        self.service.weekly_used = 100
+        self.service.weekly_at = time.time() + 72 * 3600
+        result = await resets.consume(self.root, "one", "fake")
+        self.assertEqual(result["outcome"], "reset")
+
+    async def test_pending_retry_cannot_bypass_a_changed_weekly_guard(self):
+        self.service.lose_reply = True
+        with self.assertRaises(RouterError):
+            await resets.consume(self.root, "one", "fake")
+        self.service.weekly_used = 0
+        with self.assertRaisesRegex(RouterError, "fully exhausted"):
+            await resets.consume(self.root, "one", "fake")
+        self.assertEqual(len(self.service.calls), 1)
+        self.assertTrue(resets.pending(self.home))
+        self.assertEqual(self.service.count, 1)
+
+    def test_weekly_guard_exact_boundary_unknown_values_and_unrounded_allowance(self):
+        now = 2000000000
+
+        def usage(used, at):
+            return {"rateLimits": {"secondary": {"usedPercent": used, "resetsAt": at}}}
+
+        self.assertIsNone(resets.weekly_block_reason(usage(100, now + 172801), now))
+        for used, at in (
+            (100, now + 172800),
+            (100, now + 172799),
+            (99.999, now + 200000),
+            (100, None),
+            (None, now + 200000),
+            (float("nan"), now + 200000),
+            (100, float("inf")),
+        ):
+            self.assertIsNotNone(resets.weekly_block_reason(usage(used, at), now))
+        self.assertIsNotNone(resets.weekly_block_reason({}, now))
+
     async def test_real_jsonl_helper_redeems_and_refreshes_synthetic_account(self):
         from test_services import fake_executable
 
         self.patch.stop()
         binary = fake_executable(self.root)
+        atomic_json(
+            self.home / "fake-history.json",
+            {
+                "threads": {},
+                "calls": [],
+                "reset_credit_count": 1,
+                "reset_weekly_used": 100,
+                "reset_weekly_at": time.time() + 72 * 3600,
+            },
+        )
         result = await resets.consume(self.root, "one", binary)
         self.assertEqual(result, {"outcome": "reset", "refreshed": True})
         history = json.loads((self.home / "fake-history.json").read_text())