relay-codex 0.0.0-stage → 0.5.0

package/python/settings.py

@@ -0,0 +1,110 @@
+"""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,
+    "keep_awake": False,
+}
+
+
+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/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

@@ -0,0 +1,240 @@
+#!/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 in {"turn/start", "review/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"] in {"turn/start", "review/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"},
+            }
+        )