relay-codex 0.0.0-stage → 0.4.1

package/python/compatibility.py

@@ -0,0 +1,225 @@
+"""Check protocol capabilities, not an exact Codex version allowlist."""
+
+import hashlib
+import json
+from pathlib import Path
+import subprocess
+import tempfile
+import sys
+
+ADAPTER = 4
+
+
+def executable(path):
+    """Resolve the native executable behind the official npm launcher when present."""
+    real = Path(path).resolve()
+    if real.suffix == ".js":
+        root = real.parent.parent
+        candidates = list(
+            (root / "node_modules" / "@openai").glob("codex-*/vendor/*/bin/codex")
+        )
+        candidates += list((root / "vendor").glob("*/bin/codex"))
+        import platform
+
+        architecture = "aarch64" if platform.machine() == "arm64" else "x86_64"
+        candidates = [
+            p for p in candidates if architecture in str(p) and "darwin" in str(p)
+        ]
+        if len(candidates) == 1:
+            return candidates[0].resolve()
+    return real
+
+
+def digest(path):
+    value = hashlib.sha256()
+    with Path(path).open("rb") as stream:
+        for data in iter(lambda: stream.read(1024 * 1024), b""):
+            value.update(data)
+    return value.hexdigest()
+
+
+def validate_schema(root):
+    request = json.loads((root / "ClientRequest.json").read_text())
+    methods = {
+        m
+        for x in request["oneOf"]
+        for m in x.get("properties", {}).get("method", {}).get("enum", [])
+    }
+    required = {
+        "initialize",
+        "account/read",
+        "account/login/start",
+        "account/rateLimits/read",
+        "thread/start",
+        "thread/resume",
+        "turn/start",
+        "turn/interrupt",
+    }
+    if required - methods:
+        raise ValueError("Required account/thread methods changed.")
+    login = json.loads((root / "v2/LoginAccountParams.json").read_text())
+    variants = [
+        x
+        for x in login["oneOf"]
+        if x.get("properties", {}).get("type", {}).get("enum") == ["chatgptAuthTokens"]
+    ]
+    if not variants or not {"accessToken", "chatgptAccountId"} <= set(
+        variants[0]["properties"]
+    ):
+        raise ValueError("Live token login interface changed.")
+    if set(variants[0].get("required", [])) - {
+        "type",
+        "accessToken",
+        "chatgptAccountId",
+        "chatgptPlanType",
+    }:
+        raise ValueError("Token login requires new fields.")
+    for name, fields in {
+        "v2/TurnStartParams.json": {"threadId", "input"},
+        "v2/TurnCompletedNotification.json": {"threadId", "turn"},
+        "v2/GetAccountRateLimitsResponse.json": {"rateLimits"},
+        "ChatgptAuthTokensRefreshParams.json": {"reason", "previousAccountId"},
+    }.items():
+        value = json.loads((root / name).read_text())
+        if not fields <= set(value["properties"]):
+            raise ValueError("Required response fields changed.")
+        if name == "v2/TurnStartParams.json" and set(value.get("required", [])) - {
+            "threadId",
+            "input",
+        }:
+            raise ValueError("Turn continuation requires new fields.")
+    # Validate complete request examples against the generated combined schema,
+    # including types and newly required fields, not just matching field names.
+    try:
+        import jsonschema
+    except ImportError:
+        raise ValueError(
+            "Install requirements.txt; JSON schema validation is required."
+        ) from None
+    if request.get("definitions"):
+        validator = jsonschema.Draft7Validator(request)
+        ident = "00000000-0000-4000-8000-000000000000"
+        examples = [
+            {
+                "id": "probe",
+                "method": "initialize",
+                "params": {
+                    "clientInfo": {"name": "local_codex_accounts", "version": "0.3.0"},
+                    "capabilities": {"experimentalApi": True},
+                },
+            },
+            {
+                "id": "probe",
+                "method": "account/login/start",
+                "params": {
+                    "type": "chatgptAuthTokens",
+                    "accessToken": "probe",
+                    "chatgptAccountId": "probe",
+                },
+            },
+            {
+                "id": "probe",
+                "method": "account/read",
+                "params": {"refreshToken": False},
+            },
+            {"id": "probe", "method": "account/rateLimits/read"},
+            {
+                "id": "probe",
+                "method": "thread/resume",
+                "params": {
+                    "threadId": ident,
+                    "sandbox": "danger-full-access",
+                    "approvalPolicy": "never",
+                },
+            },
+            {
+                "id": "probe",
+                "method": "turn/start",
+                "params": {
+                    "threadId": ident,
+                    "input": [{"type": "text", "text": "probe", "text_elements": []}],
+                    "clientUserMessageId": ident,
+                },
+            },
+            {
+                "id": "probe",
+                "method": "thread/turns/list",
+                "params": {
+                    "threadId": ident,
+                    "limit": 1,
+                    "sortDirection": "desc",
+                    "itemsView": "summary",
+                },
+            },
+        ]
+        for sample in examples:
+            if not validator.is_valid(sample):
+                raise ValueError(
+                    "Native RPC request contract changed: " + sample["method"]
+                )
+
+
+def check(binary, state):
+    """Cache by launcher bytes/version; serialize callers with caller's file lock."""
+    version = subprocess.run(
+        [binary, "--version"], capture_output=True, text=True, check=True, timeout=15
+    ).stdout.strip()
+    native = executable(binary)
+    fingerprint = hashlib.sha256(
+        (digest(binary) + digest(native) + version + str(ADAPTER)).encode()
+    ).hexdigest()
+    cache = state / "compatibility.json"
+    if cache.exists():
+        try:
+            value = json.loads(cache.read_text())
+            if value.get("fingerprint") == fingerprint:
+                return value
+        except (ValueError, OSError):
+            pass
+    with tempfile.TemporaryDirectory(prefix="codex-account-schema-") as folder:
+        root = Path(folder)
+        subprocess.run(
+            [
+                binary,
+                "app-server",
+                "generate-json-schema",
+                "--experimental",
+                "--out",
+                folder,
+            ],
+            capture_output=True,
+            check=True,
+            timeout=45,
+        )
+        validate_schema(root)
+    help_text = subprocess.run(
+        [binary, "--help"], capture_output=True, text=True, check=True, timeout=15
+    ).stdout
+    if not all(flag in help_text for flag in ["--remote", "--remote-auth-token-env"]):
+        raise ValueError("Terminal remote connection flags changed.")
+    # New releases must also accept the live login operation twice in the same
+    # native process. Fake identities only; an OS sandbox denies all networking.
+    subprocess.run(
+        [
+            sys.executable,
+            str(Path(__file__).with_name("probe_native.py")),
+            "--binary",
+            binary,
+        ],
+        capture_output=True,
+        check=True,
+        timeout=40,
+    )
+    value = {
+        "version": version,
+        "fingerprint": fingerprint,
+        "adapter": ADAPTER,
+        "native_executable": str(native),
+        "native_sha256": digest(native),
+        "validation": "schema, CLI flags, network-denied native login-switch probe; real handshake on launch",
+    }
+    temporary = cache.with_suffix(".tmp")
+    temporary.write_text(json.dumps(value, indent=2) + "\n")
+    temporary.chmod(0o600)
+    temporary.replace(cache)
+    return value

package/python/desktop.py

@@ -0,0 +1,52 @@
+"""Optional macOS menu app."""
+
+from pathlib import Path
+import plistlib
+import shutil
+import subprocess
+from processes import spawn
+
+
+def menubar(state, launcher=None, build_only=False):
+    from router import VERSION
+
+    launcher = launcher or shutil.which("relay")
+    if not launcher:
+        raise ValueError("The relay command is not on PATH")
+    source = Path(__file__).with_name("Menu.swift")
+    app = state / "Relay Menu.app"
+    contents = app / "Contents"
+    binary = contents / "MacOS" / "RelayMenu"
+    binary.parent.mkdir(parents=True, exist_ok=True)
+    if not binary.exists() or source.stat().st_mtime > binary.stat().st_mtime:
+        compiler = shutil.which("swiftc")
+        if not compiler:
+            raise ValueError(
+                "Swift compiler is unavailable; install Apple command-line tools to build the optional menu app"
+            )
+        subprocess.run([compiler, str(source), "-o", str(binary)], check=True)
+        with (contents / "Info.plist").open("wb") as stream:
+            plistlib.dump(
+                {
+                    "CFBundleIdentifier": "local.relay.menu",
+                    "CFBundleName": "Relay",
+                    "CFBundleExecutable": "RelayMenu",
+                    "CFBundleVersion": VERSION,
+                    "RelayCommand": launcher,
+                    "LSUIElement": True,
+                },
+                stream,
+            )
+        subprocess.run(
+            ["/usr/bin/codesign", "--force", "--sign", "-", str(app)],
+            check=True,
+            capture_output=True,
+        )
+    if not build_only:
+        spawn(
+            ["/usr/bin/open", "-n", str(app), "--args", str(launcher)],
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+    return app

package/python/launch.py

@@ -0,0 +1,117 @@
+"""Translate local launch preferences into explicit app-server thread settings."""
+
+
+def translate(arguments):
+    arguments = list(arguments)
+    if arguments and arguments[0] == "--":
+        arguments.pop(0)
+    frontend, overrides = [], {}
+    i = 0
+    while i < len(arguments):
+        arg = arguments[i]
+        if arg == "--":
+            frontend.extend(arguments[i:])
+            break
+        if arg in ("--yolo", "--dangerously-bypass-approvals-and-sandbox"):
+            overrides.update(approvalPolicy="never", sandbox="danger-full-access")
+        elif arg in (
+            "-s",
+            "--sandbox",
+            "-a",
+            "--ask-for-approval",
+            "-P",
+            "--permission-profile",
+        ):
+            if i + 1 == len(arguments):
+                raise ValueError(f"{arg} requires a value")
+            i += 1
+            key = {
+                "-s": "sandbox",
+                "--sandbox": "sandbox",
+                "-a": "approvalPolicy",
+                "--ask-for-approval": "approvalPolicy",
+                "-P": "permissions",
+                "--permission-profile": "permissions",
+            }[arg]
+            overrides[key] = arguments[i]
+        elif any(
+            arg.startswith(flag + "=")
+            for flag in ("--sandbox", "--ask-for-approval", "--permission-profile")
+        ):
+            name, value = arg.split("=", 1)
+            overrides[
+                {
+                    "--sandbox": "sandbox",
+                    "--ask-for-approval": "approvalPolicy",
+                    "--permission-profile": "permissions",
+                }[name]
+            ] = value
+        else:
+            frontend.append(arg)
+        i += 1
+    if "sandbox" in overrides and "permissions" in overrides:
+        raise ValueError(
+            "Choose either --sandbox/--yolo or a named permission profile."
+        )
+    if overrides.get("sandbox") not in (
+        None,
+        "read-only",
+        "workspace-write",
+        "danger-full-access",
+    ):
+        raise ValueError("Unsupported sandbox mode.")
+    if overrides.get("approvalPolicy") not in (
+        None,
+        "never",
+        "on-request",
+        "untrusted",
+        "on-failure",
+    ):
+        raise ValueError("Unsupported approval policy.")
+    return frontend, overrides
+
+
+def backend_arguments(arguments):
+    """Copy config/profile selection to the backend without consuming native UI args."""
+    result = []
+    i = 0
+    while i < len(arguments):
+        arg = arguments[i]
+        if arg in {
+            "-c",
+            "--config",
+            "-p",
+            "--profile",
+            "--enable",
+            "--disable",
+            "-m",
+            "--model",
+        } and i + 1 < len(arguments):
+            result.extend([arg, arguments[i + 1]])
+            i += 2
+            continue
+        if arg.startswith(
+            ("--config=", "--profile=", "--enable=", "--disable=", "--model=")
+        ):
+            result.append(arg)
+        elif arg == "--search":
+            result.extend(["-c", 'web_search="live"'])
+        i += 1
+    # app-server has no --model flag; a model config override has the same default.
+    converted = []
+    i = 0
+    while i < len(result):
+        if result[i] in {"-m", "--model"}:
+            import json
+
+            converted.extend(["-c", "model=" + json.dumps(result[i + 1])])
+            i += 2
+        elif result[i].startswith("--model="):
+            import json
+
+            converted.extend(["-c", "model=" + json.dumps(result[i].split("=", 1)[1])])
+            i += 1
+        else:
+            converted.append(result[i])
+            i += 1
+    return converted

package/python/metadata.py

@@ -0,0 +1,82 @@
+"""Recover local routing metadata without touching credentials or conversations."""
+
+import contextlib
+import json
+from pathlib import Path
+import sqlite3
+import time
+import uuid
+
+from pool import Pool, process_birth
+
+
+def restore_backup(state):
+    backup = state / "pool.backup.sqlite"
+    if not backup.is_file():
+        raise ValueError("No metadata backup exists; use doctor --backup first")
+    # Supervised workers are identified independently of the potentially damaged DB.
+    for path in (state / "services").glob("*.supervisor.json"):
+        try:
+            value = json.loads(path.read_text())
+        except (ValueError, OSError):
+            raise ValueError(
+                "Unreadable supervisor metadata; inspect it before restoring"
+            ) from None
+        if Pool.alive(value["pid"]) and process_birth(value["pid"]) == value.get(
+            "birth"
+        ):
+            raise ValueError(
+                "Stop wrapper sessions before restoring metadata; account logins are retained"
+            )
+    database = state / "pool.sqlite"
+    if database.exists():
+        with contextlib.suppress(sqlite3.Error):
+            db = sqlite3.connect(database)
+            try:
+                if any(
+                    Pool.alive(row[0]) for row in db.execute("SELECT pid FROM sessions")
+                ):
+                    raise ValueError("Stop wrapper sessions before restoring metadata")
+            finally:
+                db.close()
+    temporary = state / ("restore-" + uuid.uuid4().hex + ".sqlite")
+    source = sqlite3.connect("file:" + str(backup) + "?mode=ro", uri=True)
+    try:
+        if source.execute("PRAGMA quick_check").fetchone()[0] != "ok":
+            raise ValueError("Metadata backup is corrupt")
+        dest = sqlite3.connect(temporary)
+        try:
+            source.backup(dest)
+            tables = {
+                r[0]
+                for r in dest.execute(
+                    "SELECT name FROM sqlite_master WHERE type='table'"
+                )
+            }
+            if not {"usage", "blocks", "sessions", "threads"} <= tables:
+                raise ValueError("Not a Relay metadata backup")
+            # Old process/command records must never become live after restore.
+            for table in (
+                "sessions",
+                "threads",
+                "reservations",
+                "session_details",
+                "commands",
+            ):
+                if table in tables:
+                    dest.execute("DELETE FROM " + table)
+            dest.commit()
+        finally:
+            dest.close()
+        temporary.chmod(0o600)
+        quarantine = state / ("metadata-before-restore-" + str(time.time_ns()))
+        quarantine.mkdir(mode=0o700)
+        for suffix in ("", "-wal", "-shm", "-journal"):
+            path = Path(str(database) + suffix)
+            if path.exists():
+                path.replace(quarantine / path.name)
+        temporary.replace(database)
+        return str(quarantine)
+    finally:
+        source.close()
+        temporary.unlink(missing_ok=True)

package/python/notifications.py

@@ -0,0 +1,36 @@
+"""Opt-in local macOS notifications with a bounded, metadata-only message."""
+
+import subprocess
+import time
+from processes import spawn
+
+_last = {}
+EVENTS = {
+    "switched": "Account switched",
+    "waiting_for_reset": "Waiting for account reset",
+    "needs_attention": "Codex needs attention",
+    "completed": "Codex task finished",
+    "backend_restored": "Codex session recovered",
+    "model_fallback": "Configured model fallback selected",
+}
+
+
+def notify(kind, label=""):
+    if kind not in EVENTS or time.monotonic() - _last.get(kind, 0) < 30:
+        return
+    _last[kind] = time.monotonic()
+    # argv is passed to AppleScript as data, never interpolated as script code.
+    script = (
+        'on run argv\ndisplay notification (item 1 of argv) with title "Relay"\nend run'
+    )
+    spawn(
+        [
+            "/usr/bin/osascript",
+            "-e",
+            script,
+            EVENTS[kind] + (" — " + label if label else ""),
+        ],
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )