relay-codex 0.7.2 → 0.7.3

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

package/docs/troubleshooting.md

@@ -49,6 +49,15 @@ Relay rechecks this after checking the target account, so work starting during
 that check also prevents switching. A rejected menu action keeps its explanation
 visible. Use Restart for a stopped worker rather than sending it live controls.
 
+**A usage-limit panel remains open and Relay says “waiting for activity.”**
+
+Update Relay if you are using a version older than 0.7.3. A missed tool-completion
+notification could leave a finished tool marked as active. Relay now checks full
+native history for the matching tool before continuing account recovery. It keeps
+waiting when work is still running or completion cannot be verified; approvals
+and paused recovery still need attention. Existing workers retain the code they
+started with, so an update takes effect after that worker is relaunched.
+
 **Tab completion is missing.**
 
 Load `source <(relay completion zsh)` after `compinit`, or use

package/package.json

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

package/python/commands.py

@@ -773,8 +773,6 @@ async def dispatch(args, state, binary):
         elif args.command == "clean":
             if args.days < 1:
                 raise ValueError("Retention must be at least one day")
-            from pool import file_lock
-
             async with file_lock(state / "cleanup.lock"):
                 if args.apply:
                     try:

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.2"
+VERSION = "0.7.3"
 _support = Path.home() / "Library/Application Support"
 _legacy = _support / "Codex Accounts"
 _default_state = _legacy if (_legacy / "accounts").exists() else _support / "Relay"
@@ -434,6 +434,8 @@ class Controller:
         self.recovery_jobs = {}
         self.pending_intents = {}
         self.active_items = set()
+        self.active_item_threads = {}
+        self.item_revision = 0
         self.backend_factory = None
         self.restart_lock = asyncio.Lock()
         self.restart_task = None
@@ -786,7 +788,10 @@ class Controller:
             if self.active_threads or self.active_items:
                 raise RouterError("Session is busy")
             if thread:
-                await self.backend.call("thread/resume", {"threadId": thread, **params})
+                await self.backend.call(
+                    "thread/resume",
+                    {"threadId": thread, "excludeTurns": True, **params},
+                )
                 self.merge_settings(thread, params)
             self.launch_overrides = {**self.launch_overrides, **params}
             if params.get("permissions"):
@@ -877,8 +882,10 @@ class Controller:
             self.pending_server_requests.clear()
             self.replayed_requests.clear()
             self.active_items.clear()
+            self.active_item_threads.clear()
+            self.item_revision += 1
             for thread in list(self.last_turn):
-                params = {"threadId": thread}
+                params = {"threadId": thread, "excludeTurns": True}
                 params.update(
                     {
                         k: v
@@ -1034,11 +1041,18 @@ class Controller:
             "fileChange",
             "dynamicToolCall",
         }:
-            self.active_items.add(params["item"]["id"])
-            if params.get("threadId"):
-                self.persist(params["threadId"], active_items=True)
+            item = params["item"]
+            if item.get("status") not in {"completed", "failed", "declined"}:
+                self.active_items.add(item["id"])
+                self.item_revision += 1
+                if params.get("threadId"):
+                    self.active_item_threads[item["id"]] = params["threadId"]
+                    self.persist(params["threadId"], active_items=True)
         elif method == "item/completed":
-            self.active_items.discard(params.get("item", {}).get("id"))
+            item = params.get("item", {}).get("id")
+            self.active_items.discard(item)
+            self.active_item_threads.pop(item, None)
+            self.item_revision += 1
             if params.get("threadId"):
                 self.persist(params["threadId"], active_items=bool(self.active_items))
         elif method == "model/rerouted":
@@ -1173,6 +1187,14 @@ class Controller:
         ):
             if generation != self.user_generation or not self.attached():
                 return False
+            await self.reconcile_active_items()
+            if not (
+                self.active_threads
+                or self.active_items
+                or self.server_requests
+                or self.paused
+            ):
+                break
             self.status_changed.clear()
             try:
                 await asyncio.wait_for(
@@ -1194,6 +1216,69 @@ class Controller:
                     pass
         return generation == self.user_generation and self.attached()
 
+    async def reconcile_active_items(self):
+        """Retire missed completion events only from matching, full native history."""
+        owners = dict(self.active_item_threads)
+        revision = self.item_revision
+        for thread in set(owners.values()):
+            pending = {
+                item
+                for item, owner in owners.items()
+                if owner == thread and item in self.active_items
+            }
+            if not pending:
+                continue
+            cursor = None
+            visited = set()
+            for _ in range(8):
+                params = {
+                    "threadId": thread,
+                    "limit": 1,
+                    "sortDirection": "desc",
+                    "itemsView": "full",
+                }
+                if cursor:
+                    params["cursor"] = cursor
+                try:
+                    result = await self.backend.call(
+                        "thread/turns/list", params, timeout=15
+                    )
+                except (RouterError, asyncio.TimeoutError):
+                    break
+                # A concurrent start invalidates this history read. Never clear
+                # a newly started action using a snapshot taken before it began.
+                if revision != self.item_revision:
+                    return
+                confirmed = {
+                    item.get("id")
+                    for turn in result.get("data", [])
+                    if turn.get("itemsView") == "full"
+                    for item in turn.get("items", [])
+                    if item.get("type")
+                    in {
+                        "commandExecution",
+                        "mcpToolCall",
+                        "fileChange",
+                        "dynamicToolCall",
+                    }
+                    and item.get("status") in {"completed", "failed", "declined"}
+                }
+                cleared = pending & confirmed
+                for item in cleared:
+                    if self.active_item_threads.get(item) == thread:
+                        self.active_items.discard(item)
+                        self.active_item_threads.pop(item, None)
+                if cleared:
+                    pending -= cleared
+                    self.persist(thread, active_items=bool(self.active_items))
+                    if self.pool:
+                        self.pool.record("tool_activity_reconciled", count=len(cleared))
+                    self.status_changed.set()
+                cursor = result.get("nextCursor")
+                if not pending or not cursor or cursor in visited:
+                    break
+                visited.add(cursor)
+
     async def continue_thread(self, thread, generation):
         if not self.can_continue(thread, generation):
             return

package/python/service.py

@@ -246,6 +246,9 @@ async def attach(
             await send_control(state, ident, "detach")
             value = json.loads(meta.read_text())
             env["RELAY_TRANSPORT_TOKEN"] = value["token"]
+        from terminal import TerminalState
+
+        terminal_state = TerminalState()
         proc = await asyncio.create_subprocess_exec(
             binary,
             "--remote",
@@ -295,6 +298,7 @@ async def attach(
                     proc.kill()
                     await proc.wait()
             await asyncio.gather(waiter, return_exceptions=True)
+            terminal_state.restore()
         if replacement:
             print("Reconnecting to the recovered task…", flush=True)
             value = await connection(previous=value)
@@ -590,7 +594,7 @@ async def _serve(state, ident, binary):
         controller.backend_factory = factory
         thread_id = old_thread or spec.get("resume")
         if thread_id:
-            params = {"threadId": thread_id, **overrides}
+            params = {"threadId": thread_id, "excludeTurns": True, **overrides}
             if old:
                 controller.merge_settings(thread_id, persisted.get("settings", {}))
                 params.update(

package/python/terminal.py

@@ -0,0 +1,28 @@
+"""Restore terminal modes even when the native frontend cannot clean up."""
+
+import contextlib
+import os
+import sys
+import termios
+
+RESET_MODES = b"\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1015l\x1b[?2004l\x1b[?25h\x1b[0m"
+
+
+class TerminalState:
+    def __init__(self):
+        self.input_fd = None
+        self.output_fd = None
+        self.attributes = None
+        with contextlib.suppress(OSError, ValueError, AttributeError, termios.error):
+            if sys.stdin.isatty() and sys.stdout.isatty():
+                self.input_fd = sys.stdin.fileno()
+                self.output_fd = sys.stdout.fileno()
+                self.attributes = termios.tcgetattr(self.input_fd)
+
+    def restore(self):
+        if self.attributes is None:
+            return
+        with contextlib.suppress(OSError, termios.error):
+            os.write(self.output_fd, RESET_MODES)
+            termios.tcsetattr(self.input_fd, termios.TCSANOW, self.attributes)
+        self.attributes = None

package/tests/fake_native.py

@@ -55,6 +55,9 @@ def finish(thread, turn, text, mode):
         value = data["threads"][thread]
         value["status"] = {"type": "idle"}
         value["turns"][-1].update(status=status, error=error)
+        for item in value["turns"][-1]["items"]:
+            if item.get("id", "").startswith("lost-completion-"):
+                item["status"] = "completed"
         return value["turns"][-1].copy()
 
     value = change(apply)
@@ -208,6 +211,8 @@ for raw in sys.stdin:
                     ]
                 )
             }
+            for value in result["data"]:
+                value["itemsView"] = params.get("itemsView", "summary")
         elif method == "thread/loaded/list":
             result = {"data": change(lambda d: list(d["threads"]))}
         elif method in {"turn/start", "review/start"}:
@@ -243,6 +248,21 @@ for raw in sys.stdin:
                     "params": {"threadId": thread, "turn": value},
                 }
             )
+            if count <= fault.get("lost_completion_turns", 0):
+                tool = {
+                    "id": "lost-completion-" + turn,
+                    "type": "commandExecution",
+                    "status": "inProgress",
+                }
+                change(
+                    lambda d: d["threads"][thread]["turns"][-1]["items"].append(tool)
+                )
+                send(
+                    {
+                        "method": "item/started",
+                        "params": {"threadId": thread, "item": tool},
+                    }
+                )
             if fault.get("external"):
                 send(
                     {

package/tests/test_activity.py

@@ -0,0 +1,318 @@
+"""A lost item completion must not strand recovery or clear unknown work."""
+
+import asyncio
+import json
+import os
+from pathlib import Path
+import pty
+import termios
+import tempfile
+import tty
+import unittest
+from unittest.mock import patch
+
+from router import Controller, RPC, RouterError
+from test_router import FakeAccount, FakeBackend, FakeClient, completed
+
+
+class ActivityTests(unittest.IsolatedAsyncioTestCase):
+    def test_forced_frontend_exit_restores_terminal_and_disables_mouse_reporting(self):
+        from terminal import TerminalState, RESET_MODES
+
+        master, slave = pty.openpty()
+
+        class Stream:
+            def isatty(self):
+                return True
+
+            def fileno(self):
+                return slave
+
+        try:
+            original = termios.tcgetattr(slave)
+            with patch("sys.stdin", Stream()), patch("sys.stdout", Stream()):
+                state = TerminalState()
+                tty.setraw(slave)
+                state.restore()
+                state.restore()
+            restored = termios.tcgetattr(slave)
+            # macOS may set the transient PENDIN flag when canonical mode returns.
+            restored[3] &= ~getattr(termios, "PENDIN", 0)
+            original[3] &= ~getattr(termios, "PENDIN", 0)
+            self.assertEqual(restored, original)
+            self.assertEqual(os.read(master, 4096), RESET_MODES)
+        finally:
+            os.close(master)
+            os.close(slave)
+
+    def test_noninteractive_output_receives_no_terminal_escape_codes(self):
+        import io
+        from terminal import TerminalState
+
+        output = io.StringIO()
+        with patch("sys.stdin", io.StringIO()), patch("sys.stdout", output):
+            TerminalState().restore()
+        self.assertEqual(output.getvalue(), "")
+
+    async def test_restart_dispatch_uses_the_shared_file_lock(self):
+        import commands
+        from router import parse_arguments
+
+        with tempfile.TemporaryDirectory() as folder:
+            with patch("service.restart", return_value="saved-session") as restart:
+                result = await commands.dispatch(
+                    parse_arguments(["restart", "saved-session"]), Path(folder), None
+                )
+                self.assertEqual(result, 0)
+                restart.assert_called_once()
+
+    async def test_lost_completion_over_real_jsonl_recovers_without_backend_restart(
+        self,
+    ):
+        from test_services import fake_executable, wait_for
+        from settings import atomic_json
+
+        with tempfile.TemporaryDirectory() as folder:
+            root = Path(folder)
+            atomic_json(
+                root / "fault.json", {"quota_turns": 1, "lost_completion_turns": 1}
+            )
+            rpc = await RPC.start(fake_executable(root), root)
+            c = Controller(
+                [FakeAccount("one"), FakeAccount("two")], rpc, report=lambda _: None
+            )
+            c.client = FakeClient()
+            rpc.handler = c.event
+            try:
+                initial_pid = rpc.proc.pid
+                await rpc.initialize()
+                await c.forward(
+                    {"id": "thread", "method": "thread/start", "params": {}}, {}
+                )
+                thread = next(iter(c.last_turn))
+                await c.forward(
+                    {
+                        "id": "turn",
+                        "method": "turn/start",
+                        "params": {
+                            "threadId": thread,
+                            "input": [
+                                {
+                                    "type": "text",
+                                    "text": "fake work",
+                                    "text_elements": [],
+                                }
+                            ],
+                        },
+                    },
+                    {},
+                )
+                history = root / "fake-history.json"
+
+                def recovered():
+                    turns = json.loads(history.read_text())["threads"][thread]["turns"]
+                    return len(turns) == 2 and turns[-1]["status"] == "completed"
+
+                await wait_for(recovered)
+                self.assertEqual(c.account.label, "two")
+                self.assertFalse(c.active_items)
+                self.assertEqual(rpc.proc.pid, initial_pid)
+                self.assertIsNone(rpc.proc.returncode)
+            finally:
+                if c.recovery:
+                    await asyncio.gather(c.recovery, return_exceptions=True)
+                await rpc.close()
+
+    def controller(self):
+        c = Controller(
+            [FakeAccount("one"), FakeAccount("two")],
+            FakeBackend(),
+            report=lambda _: None,
+        )
+        c.client = FakeClient()
+        c.last_turn["thread-1"] = {"threadId": "thread-1"}
+        c.preferences["watchdog_interval"] = 0.01
+        return c
+
+    async def started(self, c, ident="tool", thread="thread-1"):
+        await c.event(
+            {
+                "method": "item/started",
+                "params": {
+                    "threadId": thread,
+                    "item": {
+                        "id": ident,
+                        "type": "commandExecution",
+                        "status": "inProgress",
+                    },
+                },
+            }
+        )
+
+    def history(self, c, status="completed", view="full", ident="tool"):
+        original = c.backend.call
+
+        async def call(method, params=None, **kw):
+            if method == "thread/turns/list" and params.get("itemsView") == "full":
+                return {
+                    "data": [
+                        {
+                            "itemsView": view,
+                            "items": [
+                                {
+                                    "id": ident,
+                                    "type": "commandExecution",
+                                    "status": status,
+                                }
+                            ],
+                        }
+                    ]
+                }
+            return await original(method, params, **kw)
+
+        c.backend.call = call
+
+    async def test_quota_after_lost_completion_switches_and_continues_same_thread(self):
+        c = self.controller()
+        await self.started(c)
+        self.history(c)
+        await c.event(completed())
+        await asyncio.wait_for(c.recovery, 1)
+        self.assertFalse(c.active_items)
+        self.assertEqual(c.account.label, "two")
+        turns = [p for m, p in c.backend.calls if m == "turn/start"]
+        self.assertEqual(len(turns), 1)
+        self.assertEqual(turns[0]["threadId"], "thread-1")
+
+    async def test_running_missing_and_summary_items_remain_blocking(self):
+        for status, view, ident in (
+            ("inProgress", "full", "tool"),
+            ("completed", "summary", "tool"),
+            ("completed", "full", "different"),
+            (None, "full", "tool"),
+        ):
+            c = self.controller()
+            await self.started(c)
+            self.history(c, status, view, ident)
+            await c.reconcile_active_items()
+            self.assertEqual(c.active_items, {"tool"})
+
+    async def test_finished_tool_does_not_clear_pending_approval_or_child_thread(self):
+        c = self.controller()
+        await self.started(c)
+        c.server_requests.add(7)
+        c.active_threads.add("child")
+        self.history(c)
+        await c.reconcile_active_items()
+        self.assertFalse(c.active_items)
+        self.assertEqual(c.server_requests, {7})
+        self.assertEqual(c.active_threads, {"child"})
+        self.assertFalse(any(m == "account/login/start" for m, _ in c.backend.calls))
+
+    async def test_new_start_during_history_read_invalidates_the_read(self):
+        c = self.controller()
+        await self.started(c)
+
+        async def call(method, params=None, **kw):
+            await self.started(c, "new")
+            return {
+                "data": [
+                    {
+                        "itemsView": "full",
+                        "items": [
+                            {
+                                "id": "tool",
+                                "type": "commandExecution",
+                                "status": "completed",
+                            }
+                        ],
+                    }
+                ]
+            }
+
+        c.backend.call = call
+        await c.reconcile_active_items()
+        self.assertEqual(c.active_items, {"tool", "new"})
+
+    async def test_full_history_pages_until_matching_item_and_stops_on_repeated_cursor(
+        self,
+    ):
+        c = self.controller()
+        await self.started(c)
+        calls = []
+
+        async def call(method, params=None, **kw):
+            calls.append(params)
+            if not params.get("cursor"):
+                return {"data": [], "nextCursor": "older"}
+            return {
+                "data": [
+                    {
+                        "itemsView": "full",
+                        "items": [
+                            {
+                                "id": "tool",
+                                "type": "commandExecution",
+                                "status": "failed",
+                            }
+                        ],
+                    }
+                ]
+            }
+
+        c.backend.call = call
+        await c.reconcile_active_items()
+        self.assertFalse(c.active_items)
+        self.assertEqual(len(calls), 2)
+        await self.started(c)
+        calls.clear()
+
+        async def repeated(method, params=None, **kw):
+            calls.append(params)
+            return {"data": [], "nextCursor": "same"}
+
+        c.backend.call = repeated
+        await c.reconcile_active_items()
+        self.assertEqual(len(calls), 2)
+        self.assertEqual(c.active_items, {"tool"})
+
+    async def test_failed_read_and_unowned_item_never_clear_activity(self):
+        c = self.controller()
+        await self.started(c)
+        c.active_items.add("unknown-owner")
+
+        async def failed(*args, **kwargs):
+            raise RouterError("unavailable")
+
+        c.backend.call = failed
+        await c.reconcile_active_items()
+        self.assertEqual(c.active_items, {"tool", "unknown-owner"})
+
+    async def test_completion_and_terminal_start_do_not_leave_stale_ownership(self):
+        c = self.controller()
+        await self.started(c)
+        await c.event(
+            {
+                "method": "item/completed",
+                "params": {"threadId": "thread-1", "item": {"id": "tool"}},
+            }
+        )
+        self.assertFalse(c.active_item_threads)
+        await c.event(
+            {
+                "method": "item/started",
+                "params": {
+                    "threadId": "thread-1",
+                    "item": {
+                        "id": "already-done",
+                        "type": "commandExecution",
+                        "status": "completed",
+                    },
+                },
+            }
+        )
+        self.assertFalse(c.active_items)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_audit.py

@@ -246,6 +246,7 @@ class WorkerRegressions(unittest.IsolatedAsyncioTestCase):
             c.task = asyncio.create_task(service.serve(c.state, c.ident, c.binary))
             await wait_for(c.meta.exists)
         self.assertEqual(observed[0]["approvalsReviewer"], "auto_review")
+        self.assertTrue(observed[0]["excludeTurns"])
         self.assertIn("/private/tmp/audit-extra", observed[0]["runtimeWorkspaceRoots"])
         pool.close()