relay-codex 0.5.0 → 0.5.1

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.5.0
-npx --yes github:blackspider-ops/relay#v0.5.0 --version
+npm install -g github:blackspider-ops/relay#v0.5.1
+npx --yes github:blackspider-ops/relay#v0.5.1 --version
 ```
 
 `npx` runs packages; it is not a separate publishing service. Publishing

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "relay-codex",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Keep your Codex sessions moving between your own accounts.",
   "license": "MIT",
   "author": "blackspider-ops",
   "repository": {
     "type": "git",
-    "url": "https://github.com/blackspider-ops/relay.git"
+    "url": "git+https://github.com/blackspider-ops/relay.git"
   },
   "homepage": "https://github.com/blackspider-ops/relay#readme",
   "bugs": {

package/python/Menu.swift

@@ -126,7 +126,7 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
             let name = session["name"] as? String ?? String(id.prefix(10))
             let status = (session["state"] as? String ?? "unknown").replacingOccurrences(of: "_", with: " ")
             let submenu = NSMenu()
-            text("Account: \(session["account"] as? String ?? "unknown")", into: submenu)
+            text("Account: \(session["account_name"] as? String ?? session["account"] as? String ?? "unknown")", into: submenu)
             text("Model: \(session["model"] as? String ?? "unknown")", into: submenu)
             if let next = session["next_wake"] { countdown("Next action", value: next, into: submenu) }
             if let reason = session["reason"] as? String { text(reason.replacingOccurrences(of: "_", with: " "), into: submenu) }

package/python/commands.py

@@ -110,6 +110,13 @@ def snapshot(state, include_inactive=False):
             )
         with pool.db() as db:
             for session in sessions:
+                account = next(
+                    (a for a in accounts if a["id"] == session.get("account")), {}
+                )
+                session["account_name"] = account.get(
+                    "name", session.get("account", "")
+                )
+                session["account_email"] = account.get("email")
                 saved_intent = db.execute(
                     "SELECT details FROM intents WHERE owner=? AND thread=?",
                     (session["id"], session.get("thread", "")),
@@ -198,11 +205,11 @@ def render(value):
     if value["sessions"]:
         lines += [
             "",
-            f"{'SESSION':<12}{'ACCOUNT':<14}{'STATE':<23}{'MODEL':<23}PROJECT / NAME",
+            f"{'SESSION':<12}{'ACCOUNT':<32}{'STATE':<23}{'MODEL':<23}PROJECT / NAME",
         ]
         for row in value["sessions"]:
             lines.append(
-                f"{row['id'][:10]:<12}{row.get('account', ''):<14}{str(row.get('state', 'unknown'))[:22]:<23}{str(row.get('model') or '?')[:22]:<23}{row.get('cwd') or row.get('name') or ''}"
+                f"{row['id'][:10]:<12}{str(row.get('account_name') or row.get('account', '')):<32}{str(row.get('state', 'unknown'))[:22]:<23}{str(row.get('model') or '?')[:22]:<23}{row.get('cwd') or row.get('name') or ''}"
             )
             if row.get("next_wake"):
                 lines.append(

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.5.0"
+VERSION = "0.5.1"
 _support = Path.home() / "Library/Application Support"
 _legacy = _support / "Codex Accounts"
 _default_state = _legacy if (_legacy / "accounts").exists() else _support / "Relay"
@@ -435,6 +435,17 @@ class Controller:
         self.awake_process = None
         self.fallback_tried = {}
 
+    def account_name(self):
+        if self.pool:
+            from commands import account_identity
+
+            return (
+                account_identity(self.pool.state, self.account.label).get("email")
+                or self.pool.options(self.account.label).get("name")
+                or self.account.label
+            )
+        return self.account.label
+
     def attached(self):
         return bool(self.client) or self.background or self.starting
 
@@ -457,7 +468,7 @@ class Controller:
         if self.preferences.get("notifications"):
             from notifications import notify
 
-            notify(kind, self.account.label)
+            notify(kind, self.account_name())
 
     def merge_settings(self, thread, params):
         allowed = {
@@ -792,6 +803,8 @@ class Controller:
             self.note("switched", to=label)
         elif op == "retry":
             self.paused = False
+            if thread:
+                self.clear_review(thread)
             self.wake.set()
             if self.recovery and not self.recovery.done():
                 self.force_retry.set()
@@ -803,7 +816,6 @@ class Controller:
                 )
                 self.pool.invalidate(self.account.label)
             if thread and (not self.recovery or self.recovery.done()):
-                self.clear_review(thread)
                 self.recovery = asyncio.create_task(
                     self.continue_thread(thread, self.user_generation)
                 )
@@ -1173,7 +1185,7 @@ class Controller:
             raise
         except (RouterError, asyncio.TimeoutError):
             return await self.uncertain(thread, generation, baseline)
-        self.report(f"Continued the saved thread with {self.account.label}.")
+        self.report(f"Continued the saved thread with {self.account_name()}.")
 
     async def restore_recovery(self, thread, persisted):
         """Honor an accepted retry's original deadline after a process restart."""
@@ -1383,7 +1395,7 @@ class Controller:
                     episode["attempt"] += 1
                     target = episode["start"] + episode["attempt"] * self.retry_interval
                     self.report(
-                        f"Service/authentication failure on {self.account.label}. Retry {episode['attempt']}/{self.retry_attempts} at {time.strftime('%H:%M:%S', time.localtime(target))}."
+                        f"Service/authentication failure on {self.account_name()}. Retry {episode['attempt']}/{self.retry_attempts} at {time.strftime('%H:%M:%S', time.localtime(target))}."
                     )
                     self.note(
                         "retry_scheduled",
@@ -1416,7 +1428,7 @@ class Controller:
                 )
             self.episodes.pop(thread, None)
             self.report(
-                f"Selecting another account after {kind} failure on {self.account.label}."
+                f"Selecting another account after {kind} failure on {self.account_name()}."
             )
             self.note("selecting_account", thread=thread, reason=kind)
             await self.mark(self.index, model, kind)

package/tests/test_audit.py

@@ -45,6 +45,31 @@ class RecoveryRegressions(unittest.IsolatedAsyncioTestCase):
             self.assertTrue(any(method == "turn/start" for method, _ in backend.calls))
             pool.close()
 
+    async def test_explicit_retry_clears_a_review_hold_during_an_existing_timer(self):
+        with tempfile.TemporaryDirectory() as folder:
+            pool = Pool(Path(folder))
+            backend = FakeBackend()
+            c = Controller(
+                [FakeAccount("one")], backend, pool=pool, report=lambda _: None
+            )
+            c.client = FakeClient()
+            c.last_turn["thread-1"] = {"threadId": "thread-1"}
+            c.recovery = asyncio.create_task(c.recover("thread-1", 0, "capacity"))
+            try:
+                while not c.episodes:
+                    await asyncio.sleep(0)
+                c.hold_for_review("thread-1")
+                await c.control("retry", {"thread": "thread-1"})
+                await asyncio.wait_for(c.recovery, 1)
+                self.assertFalse(pool.intent("thread-1")["review_required"])
+                self.assertEqual(
+                    sum(method == "turn/start" for method, _ in backend.calls), 1
+                )
+            finally:
+                c.recovery.cancel()
+                await asyncio.gather(c.recovery, return_exceptions=True)
+                pool.close()
+
     async def test_picker_permission_control_applies_before_thread_selection(self):
         c = Controller([FakeAccount("one")], FakeBackend(), report=lambda _: None)
         c.launch_overrides = {