relay-codex 0.4.1 → 0.5.0

package/python/tools.py

@@ -0,0 +1,233 @@
+"""Local launch explanations, redacted diagnostics, saved workspaces, and cleanup."""
+
+import json
+import os
+from pathlib import Path
+import shutil
+import sys
+import time
+
+from settings import atomic_json
+from pool import Pool
+
+
+def explain(arguments, cwd, binary=None):
+    from launch import (
+        translate,
+        working_directory,
+        native_mode,
+        additional_roots,
+        tokens,
+        arguments_only,
+    )
+    from router import VERSION
+
+    if binary is None:
+        from router import codex_path
+
+        try:
+            binary = codex_path()
+        except Exception:
+            binary = None
+    native = native_mode(arguments, binary)
+    _, overrides = translate(arguments)
+    model = next(
+        (
+            value
+            for name, value, _ in tokens(arguments_only(arguments))
+            if name == "--model"
+        ),
+        None,
+    )
+    return {
+        "relay_version": VERSION,
+        "mode": "native" if native else "managed",
+        "account_recovery": not native,
+        "cwd": working_directory(arguments, cwd),
+        "model": model or "Native Codex default",
+        "permissions": overrides or "Saved thread or native Codex defaults",
+        "additional_directories": additional_roots(
+            arguments, working_directory(arguments, cwd)
+        ),
+        "codex": binary,
+        "note": "Native utilities and external/local-provider endpoints retain native behavior."
+        if native
+        else "Relay manages account resets, temporary failures, and the saved conversation.",
+    }
+
+
+def diagnostics(state, output):
+    """Allowlisted operational facts only; never read credentials or raw job arguments."""
+    from router import VERSION
+    import platform
+
+    pool = Pool(state)
+    try:
+        details = pool.detail()
+        with pool.db() as db:
+            health = db.execute("PRAGMA quick_check").fetchone()[0]
+            events = [
+                r[0]
+                for r in db.execute(
+                    "SELECT kind FROM events ORDER BY id DESC LIMIT 100"
+                )
+            ]
+        value = {
+            "relay_version": VERSION,
+            "python": platform.python_version(),
+            "platform": sys.platform,
+            "database": "ok" if health == "ok" else "failed",
+            "active_sessions": len(details),
+            "session_states": [r.get("state", "unknown") for r in details],
+            "recent_event_types": events,
+        }
+        destination = Path(output).expanduser()
+        with destination.open("x", encoding="utf-8") as stream:
+            os.chmod(destination, 0o600)
+            json.dump(value, stream, indent=2)
+            stream.write("\n")
+        return str(destination)
+    finally:
+        pool.close()
+
+
+def workspace(state, action, name=None, sessions=None, binary=None):
+    import service
+
+    path = state / "workspaces.json"
+    data = json.loads(path.read_text()) if path.exists() else {}
+    pool = Pool(state)
+    try:
+        if action == "list":
+            return {key: len(value) for key, value in data.items()}
+        if action == "remove":
+            data.pop(name, None)
+            atomic_json(path, data)
+            return {"removed": name}
+        if action == "save":
+            live = pool.detail()
+            chosen = [
+                r
+                for r in live
+                if not sessions or any(r["id"].startswith(s) for s in sessions)
+            ]
+            if not chosen or sessions and len(chosen) != len(sessions):
+                raise ValueError(
+                    "Choose live session IDs from relay status, or omit IDs to save every live session"
+                )
+            jobs = []
+            for row in chosen:
+                job_path = service.folder(state) / (row["id"] + ".job.json")
+                if not job_path.exists():
+                    continue
+                jobs.append(row["id"])
+            if not jobs:
+                raise ValueError("No supervised sessions were available to save")
+            data[name] = jobs
+            atomic_json(path, data)
+            return {"saved": name, "sessions": len(jobs)}
+        if name not in data:
+            raise ValueError("Unknown workspace")
+        alive = {r["id"] for r in pool.detail()}
+        result = []
+        for ident in data[name]:
+            if ident not in alive:
+                service.restart(state, ident)
+            result.append({"session": ident, "attach": "relay attach " + ident})
+        return result
+    finally:
+        pool.close()
+
+
+def cleanup(state, *, apply=False, days=30, jobs=False):
+    """Default to a dry run. Preserve runtimes used by live or restartable jobs."""
+    import runtime
+
+    pool = Pool(state)
+    try:
+        live = {r["id"] for r in pool.detail()}
+    finally:
+        pool.close()
+    threshold = time.time() - days * 86400
+    protected = {str(Path(__file__).parent.resolve())}
+    workspaces_file = state / "workspaces.json"
+    saved_workspaces = (
+        json.loads(workspaces_file.read_text()) if workspaces_file.exists() else {}
+    )
+    workspace_jobs = {ident for group in saved_workspaces.values() for ident in group}
+    value = runtime.index(state)
+    native_protected = {
+        row["sha256"][:20] for row in value["runtimes"][-1:] if row.get("sha256")
+    }
+    if value.get("selected"):
+        native_protected.add(value["selected"][:20])
+    candidates = []
+    protect_all_python = False
+    for path in (state / "services").glob("*.job.json"):
+        try:
+            job = json.loads(path.read_text())
+        except (OSError, ValueError):
+            protect_all_python = True
+            continue
+        ident = path.name.removesuffix(".job.json")
+        old_stopped = (
+            ident not in live
+            and job.get("state") in {"stopped", "removed"}
+            and path.stat().st_mtime < threshold
+        )
+        if old_stopped and jobs and ident not in workspace_jobs:
+            candidates.extend(
+                p
+                for p in path.parent.glob(ident + ".*")
+                if p.is_file() and not p.is_symlink()
+            )
+            continue
+        if job.get("binary"):
+            protected.add(str(Path(job["binary"]).resolve()))
+        if job.get("relay_runtime"):
+            protected.add(str(Path(job["relay_runtime"]).resolve()))
+        elif ident in live:
+            protect_all_python = True
+    for folder in ["relay-runtimes", "native-runtimes"]:
+        root = state / folder
+        if not root.exists() or folder == "relay-runtimes" and protect_all_python:
+            continue
+        for path in root.iterdir():
+            resolved = str(path.resolve())
+            if (
+                path.is_symlink()
+                or not path.is_dir()
+                or path.stat().st_mtime >= threshold
+            ):
+                continue
+            if folder == "native-runtimes" and path.name in native_protected:
+                continue
+            if any(p == resolved or p.startswith(resolved + os.sep) for p in protected):
+                continue
+            candidates.append(path)
+    # Recheck live references immediately before mutations. Never delete from another user's state.
+    if apply:
+        guard = Pool(state)
+        try:
+            if {r["id"] for r in guard.detail()} != live:
+                raise ValueError("Sessions changed during cleanup; rerun the dry run")
+        finally:
+            guard.close()
+        for path in candidates:
+            if path.is_symlink():
+                raise ValueError(
+                    "Cleanup encountered a changed symlink; nothing further was removed"
+                )
+            if path.is_dir():
+                shutil.rmtree(path)
+            else:
+                path.unlink(missing_ok=True)
+        value["runtimes"] = [
+            r for r in value["runtimes"] if Path(r["binary"]).is_file()
+        ]
+        atomic_json(state / "runtimes.json", value)
+    return {
+        "dry_run": not apply,
+        "paths": [str(p) for p in candidates],
+        "count": len(candidates),
+    }

package/python/watch.py

@@ -0,0 +1,74 @@
+"""Wait for local filesystem changes; never fetch allowance or run inference."""
+
+import asyncio
+import json
+import os
+from pathlib import Path
+import select
+
+
+def fingerprint(value):
+    """Heartbeats and sample time do not represent a dashboard change."""
+    value = {**value, "at": None}
+    value["sessions"] = [
+        {k: v for k, v in item.items() if k != "seen"}
+        for item in value.get("sessions", [])
+    ]
+    return json.dumps(value, sort_keys=True)
+
+
+class LocalChanges:
+    def __init__(self, state):
+        self.state = Path(state)
+        self.queue = select.kqueue() if hasattr(select, "kqueue") else None
+        self.files = []
+        self.signature = None
+
+    def close(self):
+        if self.queue:
+            self.queue.close()
+        for fd in self.files:
+            os.close(fd)
+        self.files.clear()
+
+    def wait(self, timeout=30):
+        paths = [
+            self.state,
+            self.state / "services",
+            self.state / "accounts",
+            self.state / "pool.sqlite",
+            self.state / "pool.sqlite-wal",
+            self.state / "settings.json",
+        ]
+        if not self.queue:
+            import time
+
+            time.sleep(timeout)
+            return
+        for fd in self.files:
+            os.close(fd)
+        self.files = []
+        registrations = []
+        for path in paths:
+            try:
+                fd = os.open(path, os.O_RDONLY)
+            except FileNotFoundError:
+                continue
+            self.files.append(fd)
+            registrations.append(
+                select.kevent(
+                    fd,
+                    filter=select.KQ_FILTER_VNODE,
+                    flags=select.KQ_EV_ADD | select.KQ_EV_CLEAR,
+                    fflags=select.KQ_NOTE_WRITE
+                    | select.KQ_NOTE_RENAME
+                    | select.KQ_NOTE_DELETE
+                    | select.KQ_NOTE_ATTRIB,
+                )
+            )
+        self.queue.control(registrations, max(1, len(registrations)), timeout)
+
+    async def changed(self, timeout=30):
+        await asyncio.to_thread(self.wait, timeout)
+        # Coalesce a burst of updates into one consistent snapshot.
+        await asyncio.sleep(0.15)

package/tests/fake_native.py

@@ -177,7 +177,7 @@ for raw in sys.stdin:
             }
         elif method == "thread/loaded/list":
             result = {"data": change(lambda d: list(d["threads"]))}
-        elif method == "turn/start":
+        elif method in {"turn/start", "review/start"}:
             thread = params["threadId"]
             turn = str(uuid.uuid4())
             value = {"id": turn, "status": "inProgress", "items": [], "error": None}
@@ -189,7 +189,9 @@ for raw in sys.stdin:
                     "activeFlags": [],
                 }
                 data["threads"][thread]["runtime"] = os.getpid()
-                return sum(c["method"] == "turn/start" for c in data["calls"])
+                return sum(
+                    c["method"] in {"turn/start", "review/start"} for c in data["calls"]
+                )
 
             count = change(begin)
             fault = (

package/tests/test_audit.py

@@ -0,0 +1,320 @@
+"""Regression cases reproduced by the audit. No real accounts or model calls."""
+
+import asyncio
+import contextlib
+import io
+import json
+import os
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+
+from router import Controller, RemoteError, parse_arguments, resolve_resume_target
+from test_router import FakeAccount, FakeBackend, FakeClient, completed
+from test_pool import Clock
+from pool import Pool, process_birth
+from settings import atomic_json
+import commands
+import service
+
+
+class RecoveryRegressions(unittest.IsolatedAsyncioTestCase):
+    async def test_late_failure_cannot_bypass_review_hold(self):
+        with tempfile.TemporaryDirectory() as folder:
+            clock = Clock()
+            pool = Pool(Path(folder), clock=clock)
+            backend = FakeBackend()
+            c = Controller(
+                [FakeAccount("one")],
+                backend,
+                pool=pool,
+                clock=clock,
+                sleep=clock.sleep,
+                report=lambda _: None,
+            )
+            c.client = FakeClient()
+            c.last_turn["thread-1"] = {"threadId": "thread-1"}
+            c.hold_for_review("thread-1")
+            await c.event(completed(code="policyCapacityUnavailable"))
+            await c.recovery
+            self.assertFalse(any(method == "turn/start" for method, _ in backend.calls))
+            self.assertTrue(pool.intent("thread-1")["review_required"])
+            await c.control("retry", {"thread": "thread-1"})
+            await c.recovery
+            self.assertTrue(any(method == "turn/start" for method, _ in backend.calls))
+            pool.close()
+
+    async def test_picker_permission_control_applies_before_thread_selection(self):
+        c = Controller([FakeAccount("one")], FakeBackend(), report=lambda _: None)
+        c.launch_overrides = {
+            "sandbox": "danger-full-access",
+            "approvalPolicy": "never",
+        }
+        await c.control(
+            "permissions", {"sandbox": "read-only", "approvalPolicy": "on-request"}
+        )
+        self.assertEqual(
+            c.launch_overrides, {"sandbox": "read-only", "approvalPolicy": "on-request"}
+        )
+        c.client = FakeClient()
+        await c.forward({"id": 1, "method": "thread/start", "params": {}}, {})
+        self.assertEqual(c.backend.calls[-1][1]["sandbox"], "read-only")
+
+    async def test_more_than_one_thousand_overloads_do_not_grow_call_stack(self):
+        clock = Clock()
+        backend = FakeBackend()
+        rejections = 1100
+        original = backend.call
+
+        async def overloaded(method, params=None, **kw):
+            nonlocal rejections
+            if method == "turn/start" and rejections:
+                rejections -= 1
+                raise RemoteError({"code": -32001})
+            return await original(method, params, **kw)
+
+        backend.call = overloaded
+        c = Controller(
+            [FakeAccount("one"), FakeAccount("two")],
+            backend,
+            clock=clock,
+            sleep=clock.sleep,
+            report=lambda _: None,
+        )
+        c.client = FakeClient()
+        c.last_turn["thread-1"] = {"threadId": "thread-1"}
+        await c.recover("thread-1", 0, "transient")
+        self.assertEqual(rejections, 0)
+        self.assertTrue(any(method == "turn/start" for method, _ in backend.calls))
+        self.assertFalse(c.paused_uncertain)
+
+    async def test_resume_lookup_uses_native_filtering_and_names(self):
+        class Backend:
+            def __init__(self):
+                self.calls = []
+
+            async def call(self, method, params):
+                self.calls.append((method, dict(params)))
+                return {
+                    "data": [{"id": "interactive", "name": "named", "cwd": "/project"}]
+                }
+
+        backend = Backend()
+        selected = await resolve_resume_target(
+            ["resume", "--last"], Path("/home"), "/project", backend=backend
+        )
+        self.assertEqual(selected, "interactive")
+        self.assertNotIn("sourceKinds", backend.calls[-1][1])
+        self.assertEqual(backend.calls[-1][1]["cwd"], "/project")
+        selected = await resolve_resume_target(
+            ["resume", "named", "--all", "--include-non-interactive"],
+            Path("/home"),
+            "/project",
+            backend=backend,
+        )
+        self.assertEqual(selected, "interactive")
+        self.assertIn("exec", backend.calls[-1][1]["sourceKinds"])
+        self.assertNotIn("cwd", backend.calls[-1][1])
+
+    async def test_watch_ignores_heartbeats_and_redraws_only_meaningful_changes(self):
+        args = type(
+            "Args", (), {"watch": True, "json": True, "all": False, "interval": 30}
+        )()
+        count = 0
+        values = [
+            {"at": 1, "sessions": [{"id": "a", "seen": 1, "state": "idle"}]},
+            {"at": 2, "sessions": [{"id": "a", "seen": 2, "state": "idle"}]},
+            {"at": 3, "sessions": [{"id": "a", "seen": 3, "state": "working"}]},
+        ]
+
+        class Watch:
+            def __init__(self, state):
+                pass
+
+            async def changed(self, timeout):
+                nonlocal count
+                count += 1
+                if count == 3:
+                    raise asyncio.CancelledError()
+
+            def close(self):
+                pass
+
+        output = io.StringIO()
+        with (
+            patch("watch.LocalChanges", Watch),
+            patch("commands.snapshot", side_effect=values),
+            contextlib.redirect_stdout(output),
+        ):
+            with self.assertRaises(asyncio.CancelledError):
+                await commands.status(args, Path("/unused"))
+        self.assertEqual(len(output.getvalue().splitlines()), 2)
+
+    async def test_control_wait_reports_rejection(self):
+        with tempfile.TemporaryDirectory() as folder:
+            state = Path(folder)
+            pool = Pool(state)
+            pool.session = "worker"
+            pool.assign("one")
+            args = parse_arguments(["pause", "worker", "--wait"])
+
+            async def reject(pool, ident, timeout):
+                raise ValueError("rejected")
+
+            with patch("service.wait_control", reject):
+                with self.assertRaisesRegex(ValueError, "rejected"):
+                    await commands.control(args, state)
+            pool.close()
+
+
+class WorkerRegressions(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        from test_services import ServiceTests
+
+        self.case = ServiceTests("test_background_work_completes_without_frontend")
+        await self.case.asyncSetUp()
+
+    async def asyncTearDown(self):
+        await self.case.asyncTearDown()
+
+    async def test_worker_restores_reviewer_and_workspace_roots(self):
+        from test_services import wait_for
+        from router import RPC
+
+        c = self.case
+        await wait_for(lambda: json.loads(c.job.read_text()).get("resume"))
+        await wait_for(
+            lambda: any(
+                t["turns"] and t["turns"][-1]["status"] == "completed"
+                for t in json.loads((c.home / "fake-history.json").read_text())[
+                    "threads"
+                ].values()
+            )
+        )
+        thread = json.loads(c.job.read_text())["resume"]
+        c.task.cancel()
+        await asyncio.gather(c.task, return_exceptions=True)
+        pool = Pool(c.state)
+        pool.session = c.ident
+        pool.intent(
+            thread,
+            {
+                "role": "foreground",
+                "accepted": True,
+                "state": "completed",
+                "settings": {
+                    "approvalsReviewer": "auto_review",
+                    "runtimeWorkspaceRoots": [str(c.home), "/private/tmp/audit-extra"],
+                },
+            },
+        )
+        observed = []
+        original = RPC.call
+
+        async def capture(rpc, method, params=None, **kw):
+            if method == "thread/resume":
+                observed.append(params)
+            return await original(rpc, method, params, **kw)
+
+        with patch.object(RPC, "call", capture):
+            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.assertIn("/private/tmp/audit-extra", observed[0]["runtimeWorkspaceRoots"])
+        pool.close()
+
+    async def test_project_selection_updates_restart_and_attach_metadata(self):
+        from websockets.asyncio.client import connect
+
+        c = self.case
+        other = c.home / "other"
+        other.mkdir()
+        value = json.loads(c.meta.read_text())
+        async with connect(
+            value["url"],
+            additional_headers={"Authorization": "Bearer " + value["token"]},
+            proxy=None,
+        ) as ws:
+            await ws.send(
+                json.dumps(
+                    {
+                        "id": "select",
+                        "method": "thread/start",
+                        "params": {"cwd": str(other)},
+                    }
+                )
+            )
+            while json.loads(await ws.recv()).get("id") != "select":
+                pass
+        self.assertEqual(json.loads(c.meta.read_text())["cwd"], str(other))
+        self.assertEqual(json.loads(c.job.read_text())["cwd"], str(other))
+
+
+class AttachmentRegressions(unittest.IsolatedAsyncioTestCase):
+    async def test_new_worker_reconnects_without_replaying_original_prompt(self):
+        with tempfile.TemporaryDirectory() as folder:
+            state = Path(folder)
+            root = service.folder(state)
+            job = root / "task.job.json"
+            meta = root / "task.connection.json"
+            atomic_json(job, {"binary": "/codex", "state": "running"})
+            old = {
+                "pid": os.getpid(),
+                "birth": process_birth(os.getpid()),
+                "url": "ws://127.0.0.1:1",
+                "token": "FAKE",
+                "home": folder,
+                "cwd": folder,
+                "thread": "saved",
+            }
+            atomic_json(meta, old)
+
+            class Process:
+                def __init__(self, done=False):
+                    self.returncode = 0 if done else None
+                    self.finished = asyncio.Event()
+
+                async def wait(self):
+                    if self.returncode is None:
+                        await self.finished.wait()
+                    return self.returncode
+
+                def terminate(self):
+                    self.returncode = 0
+                    self.finished.set()
+
+                def kill(self):
+                    self.terminate()
+
+            spawned = []
+
+            async def spawn(*argv, **kwargs):
+                spawned.append(argv)
+                if len(spawned) == 1:
+                    atomic_json(
+                        meta,
+                        {
+                            **old,
+                            "pid": os.getppid(),
+                            "birth": process_birth(os.getppid()),
+                            "url": "ws://127.0.0.1:2",
+                            "token": "NEW_FAKE",
+                        },
+                    )
+                return Process(done=len(spawned) > 1)
+
+            with patch("asyncio.create_subprocess_exec", spawn):
+                self.assertEqual(
+                    await service.attach(state, "task", "/codex", ["original prompt"]),
+                    0,
+                )
+            self.assertEqual(len(spawned), 2)
+            self.assertIn("saved", spawned[1])
+            self.assertNotIn("original prompt", spawned[1])
+
+    def test_takeover_can_follow_session_but_not_native_separator(self):
+        self.assertTrue(parse_arguments(["attach", "task", "--takeover"]).takeover)
+        self.assertFalse(
+            parse_arguments(["attach", "task", "--", "--takeover"]).takeover
+        )

package/tests/test_controller.py

@@ -33,12 +33,10 @@ class LaunchTests(unittest.TestCase):
         self.assertEqual(args, ["resume", "--", "--yolo"])
         self.assertEqual(value, {})
 
-    def test_config_profile_forwarded_to_backend(self):
+    def test_config_forwarded_without_native_only_profile_flag(self):
         self.assertEqual(
-            backend_arguments(
-                ["resume", "-p", "work", "-c", 'model_reasoning_effort="high"']
-            ),
-            ["-p", "work", "-c", 'model_reasoning_effort="high"'],
+            backend_arguments(["resume", "-c", 'model_reasoning_effort="high"']),
+            ["-c", 'model_reasoning_effort="high"'],
         )
 
     def test_setup_supports_one_or_arbitrary_count(self):