relay-codex 0.0.0-stage → 0.4.1

package/python/settings.py

@@ -0,0 +1,109 @@
+"""Validated local preferences; no automatic model fallback or extra billing."""
+
+from pathlib import Path
+import copy
+import json
+import os
+import tomllib
+
+DEFAULTS = {
+    "retry_interval": 300,
+    "retry_attempts": 3,
+    "unknown_reset_interval": 300,
+    "watchdog_interval": 30,
+    "idle_warning_after": 120,
+    "routing": "balanced",
+    "notifications": False,
+    "fallback_models": [],
+    "preferred_accounts": [],
+    "max_sessions_per_account": 0,
+    "reservation_seconds": 120,
+    "history_days": 30,
+    "event_limit": 2000,
+    "offline_retry": 30,
+    "background_on_disconnect": False,
+    "broker_idle_seconds": 600,
+}
+
+
+def validate(values):
+    unknown = set(values) - set(DEFAULTS)
+    if unknown:
+        raise ValueError("Unknown settings: " + ", ".join(sorted(unknown)))
+    for key, value in values.items():
+        expected = DEFAULTS[key]
+        if isinstance(expected, bool):
+            if not isinstance(value, bool):
+                raise ValueError(f"{key} must be true or false")
+        elif isinstance(expected, int):
+            if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+                raise ValueError(f"{key} must be a nonnegative integer")
+            if key not in {"max_sessions_per_account", "retry_attempts"} and value < 1:
+                raise ValueError(f"{key} must be positive")
+        elif isinstance(expected, list):
+            if not isinstance(value, list) or not all(
+                isinstance(v, str) for v in value
+            ):
+                raise ValueError(f"{key} must be a list of strings")
+    if values.get("routing", "balanced") not in {
+        "balanced",
+        "quota",
+        "priority",
+        "round-robin",
+    }:
+        raise ValueError("routing must be balanced, quota, priority, or round-robin")
+    if values.get("reservation_seconds", 120) < 30:
+        raise ValueError(
+            "reservation_seconds must be at least 30 to allow heartbeat renewal"
+        )
+    return values
+
+
+def load(state, project=None, profile=None):
+    result = copy.deepcopy(DEFAULTS)
+    for path in [
+        state / "settings.json",
+        Path(project) / ".codex-accounts.toml" if project else None,
+        Path(project) / ".relay.toml" if project else None,
+    ]:
+        if not path or not path.exists():
+            continue
+        data = (
+            json.loads(path.read_text())
+            if path.suffix == ".json"
+            else tomllib.loads(path.read_text())
+        )
+        result.update(validate(data.get("settings", {})))
+        if profile:
+            result.update(validate(data.get("profiles", {}).get(profile, {})))
+    return result
+
+
+def edit(state, key, raw, profile=None):
+    try:
+        value = json.loads(raw)
+    except ValueError:
+        value = raw
+    validate({key: value})
+    path = state / "settings.json"
+    data = json.loads(path.read_text()) if path.exists() else {}
+    target = (
+        data.setdefault("profiles", {}).setdefault(profile, {})
+        if profile
+        else data.setdefault("settings", {})
+    )
+    target[key] = value
+    atomic_json(path, data)
+
+
+def atomic_json(path, data):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    temporary = path.with_name(path.name + f".{os.getpid()}.tmp")
+    fd = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w") as stream:
+        json.dump(data, stream, indent=2)
+        stream.write("\n")
+        stream.flush()
+        os.fsync(stream.fileno())
+    temporary.replace(path)

package/tests/fake_native.py

@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+"""Offline test double for native JSONL transport. Never contacts OpenAI."""
+
+import json
+import os
+from pathlib import Path
+import sys
+import threading
+import time
+import uuid
+import fcntl
+
+home = Path(os.environ.get("CODEX_HOME", "."))
+home.mkdir(parents=True, exist_ok=True)
+state_file = home / "fake-history.json"
+guard = threading.RLock()
+out = threading.Lock()
+
+
+def send(value):
+    with out:
+        print(json.dumps(value), flush=True)
+
+
+def change(operation):
+    with guard:
+        with (home / "fake-history.lock").open("a") as lock:
+            fcntl.flock(lock, fcntl.LOCK_EX)
+            data = (
+                json.loads(state_file.read_text())
+                if state_file.exists()
+                else {"threads": {}, "calls": []}
+            )
+            result = operation(data)
+            temporary = state_file.with_suffix(".tmp")
+            temporary.write_text(json.dumps(data))
+            temporary.replace(state_file)
+            return result
+
+
+def finish(thread, turn, text, mode):
+    status = "failed" if mode in {"quota", "capacity"} else "completed"
+    error = (
+        {"message": "synthetic limit", "codexErrorInfo": "usageLimitExceeded"}
+        if mode == "quota"
+        else None
+    )
+    if mode == "capacity":
+        error = {
+            "message": "Selected model is at capacity. Please try a different model.",
+            "codexErrorInfo": "policyCapacityUnavailable",
+        }
+
+    def apply(data):
+        value = data["threads"][thread]
+        value["status"] = {"type": "idle"}
+        value["turns"][-1].update(status=status, error=error)
+        return value["turns"][-1].copy()
+
+    value = change(apply)
+    if status == "completed":
+        send(
+            {
+                "method": "item/completed",
+                "params": {
+                    "threadId": thread,
+                    "item": {
+                        "id": "reply-" + turn,
+                        "type": "agentMessage",
+                        "text": "FAKE_OK",
+                    },
+                },
+            }
+        )
+    if mode == "capacity":
+        send(
+            {
+                "method": "error",
+                "params": {
+                    "threadId": thread,
+                    "turnId": turn,
+                    "error": error,
+                    "willRetry": False,
+                },
+            }
+        )
+    send({"method": "turn/completed", "params": {"threadId": thread, "turn": value}})
+    send(
+        {
+            "method": "thread/status/changed",
+            "params": {"threadId": thread, "status": {"type": "idle"}},
+        }
+    )
+
+
+if "--version" in sys.argv:
+    print("codex-cli 0.166.0")
+    raise SystemExit()
+if "--help" in sys.argv:
+    print("--remote --remote-auth-token-env")
+    raise SystemExit()
+
+for raw in sys.stdin:
+    try:
+        request = json.loads(raw)
+        method = request.get("method")
+        params = request.get("params") or {}
+        ident = request.get("id")
+        if ident is None:
+            continue
+        change(
+            lambda d: d["calls"].append(
+                {"method": method, "thread": params.get("threadId")}
+            )
+        )
+        result = {}
+        if method == "initialize":
+            result = {
+                "userAgent": "fake/1",
+                "codexHome": str(home),
+                "platformFamily": "unix",
+                "platformOs": "macos",
+            }
+        elif method == "account/read":
+            result = {"account": {"type": "chatgpt", "planType": "plus"}}
+        elif method == "account/login/start":
+            result = {"type": params["type"]}
+        elif method == "account/rateLimits/read":
+            result = {
+                "ordinaryUsageAllowed": True,
+                "rateLimits": {
+                    "primary": {"usedPercent": 20, "resetsAt": int(time.time()) + 3600}
+                },
+            }
+        elif method in ("thread/start", "thread/fork"):
+            thread = str(uuid.uuid4())
+            value = {
+                "id": thread,
+                "cwd": params.get("cwd", str(home)),
+                "model": params.get("model", "fake-model"),
+                "canAcceptDirectInput": True,
+                "status": {"type": "idle"},
+                "turns": [],
+            }
+            change(lambda d: d["threads"].update({thread: value}))
+            result = {
+                "thread": value,
+                "model": value["model"],
+                "cwd": value["cwd"],
+                "approvalPolicy": params.get("approvalPolicy", "never"),
+                "sandbox": params.get("sandbox", "read-only"),
+            }
+            send({"method": "thread/started", "params": {"thread": value}})
+        elif method == "thread/resume":
+            value = change(lambda d: d["threads"].get(params["threadId"]))
+            if not value:
+                raise ValueError("no thread")
+            if (
+                value.get("runtime") != os.getpid()
+                and value.get("status", {}).get("type") == "active"
+            ):
+                value["status"] = {"type": "idle"}
+                if value["turns"]:
+                    value["turns"][-1].update(status="interrupted", error=None)
+            value.update({k: v for k, v in params.items() if k in {"model", "cwd"}})
+            change(lambda d: d["threads"].update({value["id"]: value}))
+            result = {"thread": value, "model": value["model"], "cwd": value["cwd"]}
+        elif method == "thread/read":
+            result = {"thread": change(lambda d: d["threads"][params["threadId"]])}
+        elif method == "thread/turns/list":
+            result = {
+                "data": change(
+                    lambda d: list(reversed(d["threads"][params["threadId"]]["turns"]))[
+                        : params.get("limit", 1)
+                    ]
+                )
+            }
+        elif method == "thread/loaded/list":
+            result = {"data": change(lambda d: list(d["threads"]))}
+        elif method == "turn/start":
+            thread = params["threadId"]
+            turn = str(uuid.uuid4())
+            value = {"id": turn, "status": "inProgress", "items": [], "error": None}
+
+            def begin(data):
+                data["threads"][thread]["turns"].append(value)
+                data["threads"][thread]["status"] = {
+                    "type": "active",
+                    "activeFlags": [],
+                }
+                data["threads"][thread]["runtime"] = os.getpid()
+                return sum(c["method"] == "turn/start" for c in data["calls"])
+
+            count = change(begin)
+            fault = (
+                json.loads((home / "fault.json").read_text())
+                if (home / "fault.json").exists()
+                else {}
+            )
+            mode = "quota" if count <= fault.get("quota_turns", 0) else "ok"
+            if count <= fault.get("capacity_turns", 0):
+                mode = "capacity"
+            if not fault.get("drop_ack"):
+                send({"id": ident, "result": {"turn": value}})
+            send(
+                {
+                    "method": "turn/started",
+                    "params": {"threadId": thread, "turn": value},
+                }
+            )
+            if fault.get("external"):
+                send(
+                    {
+                        "method": "item/started",
+                        "params": {
+                            "threadId": thread,
+                            "item": {"id": "external1", "type": "commandExecution"},
+                        },
+                    }
+                )
+            if fault.get("die_once") and count == 1:
+                os._exit(11)
+            timer = threading.Timer(
+                float(fault.get("delay", 0.02)), finish, args=(thread, turn, "", mode)
+            )
+            timer.daemon = True
+            timer.start()
+            continue
+        elif method == "turn/interrupt":
+            result = {}
+        send({"id": ident, "result": result})
+    except Exception:
+        send(
+            {
+                "id": request.get("id"),
+                "error": {"code": -32600, "message": "Synthetic request rejected"},
+            }
+        )

package/tests/test_capacity.py

@@ -0,0 +1,217 @@
+"""Capacity recovery and audit regressions, without real accounts or requests."""
+
+import asyncio
+import contextlib
+import io
+from pathlib import Path
+import tempfile
+import time
+from types import SimpleNamespace
+import unittest
+from unittest.mock import patch
+
+from pool import CAPACITY_MESSAGE, Pool, failure_kind
+from router import Controller
+from test_router import FakeAccount, FakeBackend, FakeClient, completed
+from test_pool import Clock
+from test_services import wait_for
+
+
+class CapacityClassifierTests(unittest.TestCase):
+    def test_structured_and_exact_legacy_capacity_errors(self):
+        self.assertEqual(failure_kind("policyCapacityUnavailable"), "capacity")
+        for code in (
+            None,
+            "other",
+            "policyCapacityUnavailable",
+            "serverOverloaded",
+            "flexUnavailable",
+        ):
+            for message in (CAPACITY_MESSAGE, "■ " + CAPACITY_MESSAGE):
+                self.assertEqual(failure_kind(code, message), "capacity")
+
+    def test_policy_denials_are_not_reclassified_by_message(self):
+        for code in (
+            "cyberPolicy",
+            "misalignmentPolicyViolation",
+            "badRequest",
+            "sandboxError",
+        ):
+            self.assertIsNone(failure_kind(code, CAPACITY_MESSAGE))
+        self.assertIsNone(failure_kind("other", "This request mentions capacity"))
+
+
+class CapacityRecoveryTests(unittest.IsolatedAsyncioTestCase):
+    async def capacity(self, turn):
+        message = completed(code="policyCapacityUnavailable", turn=turn)
+        message["params"]["turn"]["error"]["message"] = CAPACITY_MESSAGE
+        await self.c.event(message)
+
+    async def asyncSetUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.clock = Clock()
+        self.pool = Pool(Path(self.tmp.name), clock=self.clock)
+        self.backend = FakeBackend()
+        self.c = Controller(
+            [FakeAccount("one"), FakeAccount("two")],
+            self.backend,
+            pool=self.pool,
+            clock=self.clock,
+            sleep=self.clock.sleep,
+            report=lambda _: None,
+        )
+        self.c.client = FakeClient()
+        self.c.last_turn["thread-1"] = {"threadId": "thread-1", "model": "chosen-model"}
+
+    async def asyncTearDown(self):
+        if self.c.recovery:
+            self.c.recovery.cancel()
+            await asyncio.gather(self.c.recovery, return_exceptions=True)
+        self.pool.close()
+        self.tmp.cleanup()
+
+    async def test_capacity_retries_every_five_minutes_without_cycling_accounts_or_models(
+        self,
+    ):
+        for i in range(4):
+            await self.capacity(str(i))
+            await self.c.recovery
+        self.assertEqual(self.clock.waits, [300, 300, 300, 300])
+        self.assertEqual(self.c.index, 0)
+        self.assertEqual(self.c.model_for("thread-1"), "chosen-model")
+        starts = [p for m, p in self.backend.calls if m == "turn/start"]
+        self.assertEqual(len(starts), 4)
+        self.assertTrue(all(p["threadId"] == "thread-1" for p in starts))
+        self.assertFalse(
+            any(
+                m in {"thread/resume", "account/login/start"}
+                for m, _ in self.backend.calls
+            )
+        )
+        with self.pool.db() as db:
+            reasons = [r[0] for r in db.execute("SELECT reason FROM blocks")]
+        self.assertFalse(reasons)
+
+    async def test_legacy_message_continues_saved_thread(self):
+        message = completed(code="other")
+        message["params"]["turn"]["error"]["message"] = CAPACITY_MESSAGE
+        await self.c.event(message)
+        await self.c.recovery
+        self.assertEqual(self.clock.waits, [300])
+        self.assertTrue(any(m == "turn/start" for m, _ in self.backend.calls))
+
+    async def test_final_policy_failure_cancels_an_earlier_capacity_retry(self):
+        await self.c.event(
+            {
+                "method": "error",
+                "params": {
+                    "threadId": "thread-1",
+                    "turnId": "turn-1",
+                    "willRetry": False,
+                    "error": {
+                        "codexErrorInfo": "policyCapacityUnavailable",
+                        "message": CAPACITY_MESSAGE,
+                    },
+                },
+            }
+        )
+        await self.c.event(completed(code="cyberPolicy"))
+        await asyncio.gather(self.c.recovery, return_exceptions=True)
+        self.assertFalse(any(m == "turn/start" for m, _ in self.backend.calls))
+
+    async def test_native_error_and_final_turn_do_not_schedule_two_retries(self):
+        params = {
+            "threadId": "thread-1",
+            "turnId": "turn-1",
+            "error": {
+                "codexErrorInfo": "policyCapacityUnavailable",
+                "message": CAPACITY_MESSAGE,
+            },
+        }
+        await self.c.event({"method": "error", "params": {**params, "willRetry": True}})
+        self.assertIsNone(self.c.recovery)
+        await self.c.event(
+            {"method": "error", "params": {**params, "willRetry": False}}
+        )
+        await self.capacity("turn-1")
+        await self.c.recovery
+        self.assertEqual(self.clock.waits, [300])
+        self.assertEqual(sum(m == "turn/start" for m, _ in self.backend.calls), 1)
+
+    async def test_capacity_fallback_only_uses_explicitly_configured_model(self):
+        self.c.preferences["fallback_models"] = ["chosen-fallback"]
+        for i in range(4):
+            await self.capacity(str(i))
+            await self.c.recovery
+        self.assertEqual(self.c.model_for("thread-1"), "chosen-fallback")
+
+    async def test_restored_capacity_retry_retains_its_deadline(self):
+        await self.c.restore_recovery(
+            "thread-1",
+            {
+                "accepted": True,
+                "kind": "capacity",
+                "next_wake": 1500,
+                "account_label": "one",
+                "episode": {"account": 0, "start": 1000, "attempt": 1},
+            },
+        )
+        self.assertEqual(self.clock.waits, [500])
+        self.assertEqual(sum(m == "turn/start" for m, _ in self.backend.calls), 1)
+
+    async def test_missing_continuation_baseline_cannot_accept_old_completed_turn_as_new(
+        self,
+    ):
+        async def lost(method, params=None, **kwargs):
+            if method == "turn/start":
+                raise asyncio.TimeoutError()
+            if method == "thread/turns/list":
+                return {"data": [{"id": "old", "status": "completed"}]}
+            if method == "thread/read":
+                return {"thread": {"status": {"type": "idle"}}}
+            return {}
+
+        self.backend.call = lost
+        await self.c.continue_thread("thread-1", 0)
+        self.assertIn("thread-1", self.c.paused_uncertain)
+        self.assertFalse(self.c.pending_intents["thread-1"]["accepted"])
+
+    async def test_unrelated_wake_does_not_shorten_service_retry(self):
+        self.c.clock = time.time
+        self.c.sleep = asyncio.sleep
+        self.c.recovery = asyncio.create_task(self.c.recover("thread-1", 0, "capacity"))
+        await wait_for(lambda: self.c.episodes.get("thread-1", {}).get("attempt") == 1)
+        self.c.wake.set()
+        await asyncio.sleep(0.03)
+        self.assertFalse(self.c.recovery.done())
+        self.assertFalse(any(m == "turn/start" for m, _ in self.backend.calls))
+        # Explicit Retry is allowed to override the saved timer.
+        await self.c.control("retry", {})
+        await asyncio.wait_for(self.c.recovery, 1)
+        self.assertTrue(any(m == "turn/start" for m, _ in self.backend.calls))
+
+
+class DoctorRegressionTests(unittest.IsolatedAsyncioTestCase):
+    async def test_incompatible_native_runtime_is_failure_exit(self):
+        import commands
+
+        with tempfile.TemporaryDirectory() as folder:
+            state = Path(folder)
+            Pool(state).close()
+
+            async def absent(*args, **kw):
+                raise OSError()
+
+            with (
+                patch("compatibility.check", side_effect=ValueError()),
+                patch("broker.exchange", absent),
+                contextlib.redirect_stdout(io.StringIO()),
+            ):
+                code = await commands.doctor(
+                    SimpleNamespace(
+                        restore_backup=False, self_test=False, backup=False
+                    ),
+                    state,
+                    "fake",
+                )
+            self.assertEqual(code, 1)