agent-relay-server 0.3.6 → 0.3.8

package/README.md

@@ -77,6 +77,31 @@ codex-relay
 incoming messages as live turns, and cleans up sidecar processes when Codex
 exits.
 
+### Codex approval prompts
+
+Replying to relay messages is usually done with a shell command (`curl` to
+`/api/messages`), so Codex may prompt for approval in stricter modes.
+
+`codex-relay` now forwards your Codex runtime mode to the sidecar, including
+`--ask-for-approval`, `--sandbox`, `--full-auto`, and `--yolo`.
+
+Useful setups:
+
+```bash
+# no approval prompts, still sandboxed to workspace boundaries
+codex-relay -- --ask-for-approval never --sandbox workspace-write
+```
+
+```python
+# ~/.codex/rules/default.rules
+# allow only relay message sends without repeated prompts
+prefix_rule(
+    pattern = ["curl", "-sS", "-X", "POST", "http://127.0.0.1:4850/api/messages"],
+    decision = "allow",
+    justification = "Allow local Agent Relay message posts",
+)
+```
+
 Use a remote relay server by setting:
 
 ```bash

package/bin/agent-relay-codex.ts

@@ -76,6 +76,47 @@ function readJsonFile<T>(path: string, fallback: T): T {
   return JSON.parse(readFileSync(path, "utf8")) as T;
 }
 
+function isAgentRelaySessionStartCommand(command: string): boolean {
+  return /agent-relay.*codex\/hooks\/session-start\.ts/.test(command);
+}
+
+function removeAgentRelaySessionStartToml(input: string): string {
+  const lines = input.split(/\r?\n/);
+  const blocks: Array<{ header: string | null; text: string }> = [];
+
+  for (let index = 0; index < lines.length; ) {
+    const line = lines[index] ?? "";
+    const header = /^\[\[?/.test(line) ? line : null;
+    const block: string[] = [];
+    do {
+      block.push(lines[index] ?? "");
+      index += 1;
+    } while (index < lines.length && !/^\[\[?/.test(lines[index] ?? ""));
+    blocks.push({ header, text: block.join("\n") });
+  }
+
+  let output = "";
+  for (let index = 0; index < blocks.length; ) {
+    const block = blocks[index];
+    if (block?.header?.startsWith("[[hooks.SessionStart")) {
+      const group: typeof blocks = [];
+      while (index < blocks.length && blocks[index]?.header?.startsWith("[[hooks.SessionStart")) {
+        group.push(blocks[index]!);
+        index += 1;
+      }
+
+      const groupText = group.map((block) => block.text).join("\n");
+      if (!isAgentRelaySessionStartCommand(groupText)) output += `${groupText}\n`;
+      continue;
+    }
+
+    output += `${block?.text ?? ""}\n`;
+    index += 1;
+  }
+
+  return output.replace(/\s+$/, "\n");
+}
+
 function compareVersions(left: string, right: string): number {
   const leftParts = left.split(/[.-]/).map((part) => Number.parseInt(part, 10) || 0);
   const rightParts = right.split(/[.-]/).map((part) => Number.parseInt(part, 10) || 0);
@@ -215,35 +256,43 @@ function installMarketplace(quiet = false): void {
 
 function installHook(): void {
   mkdirSync(join(home, ".codex"), { recursive: true });
+  const command = `bun ${shellQuote(installedHookScript)}`;
+
+  const configPath = join(home, ".codex", "config.toml");
+  const existingConfig = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
+  let output = removeAgentRelaySessionStartToml(existingConfig);
+  if (!output.endsWith("\n\n")) output += output.endsWith("\n") ? "\n" : "\n\n";
+  output += `[[hooks.SessionStart]]
+matcher = "startup|resume"
+
+[[hooks.SessionStart.hooks]]
+type = "command"
+command = "${command.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"
+statusMessage = "Starting Agent Relay"
+timeout = 10
+`;
+
+  writeFileSync(configPath, output);
+
   const hooksPath = join(home, ".codex", "hooks.json");
+  if (!existsSync(hooksPath)) return;
+
   const hooksJson = readJsonFile<HooksJson>(hooksPath, { hooks: {} });
   hooksJson.hooks ??= {};
-  hooksJson.hooks.SessionStart ??= [];
-
-  const command = `bun ${shellQuote(installedHookScript)}`;
-  hooksJson.hooks.SessionStart = hooksJson.hooks.SessionStart
+  hooksJson.hooks.SessionStart = (hooksJson.hooks.SessionStart ?? [])
     .map((group) => ({
       ...group,
       hooks: (group.hooks ?? []).filter((hook) => {
         if (hook.type !== "command" || typeof hook.command !== "string") return true;
-        return !/agent-relay.*codex\/hooks\/session-start\.ts/.test(hook.command);
+        return !isAgentRelaySessionStartCommand(hook.command);
       }),
     }))
     .filter((group) => (group.hooks ?? []).length > 0);
 
-  hooksJson.hooks.SessionStart.push({
-    matcher: "startup|resume",
-    hooks: [
-      {
-        type: "command",
-        command,
-        statusMessage: "Starting Agent Relay",
-        timeout: 10,
-      },
-    ],
-  });
+  if (hooksJson.hooks.SessionStart.length === 0) delete hooksJson.hooks.SessionStart;
 
-  writeFileSync(hooksPath, `${JSON.stringify(hooksJson, null, 2)}\n`);
+  if (Object.keys(hooksJson.hooks).length === 0) rmSync(hooksPath, { force: true });
+  else writeFileSync(hooksPath, `${JSON.stringify(hooksJson, null, 2)}\n`);
 }
 
 async function pickLoopbackUrl(): Promise<string> {
@@ -329,6 +378,56 @@ function spawnFallbackSidecar(runDir: string, env: Record<string, string | undef
   return sidecar.pid;
 }
 
+type SessionPermissions = {
+  approvalPolicy?: string;
+  sandbox?: string;
+};
+
+function resolveSessionPermissions(codexArgs: string[]): SessionPermissions {
+  let approvalPolicy: string | undefined;
+  let sandbox: string | undefined;
+
+  for (let index = 0; index < codexArgs.length; index += 1) {
+    const arg = codexArgs[index]!;
+    if (arg === "--yolo" || arg === "--dangerously-bypass-approvals-and-sandbox") {
+      approvalPolicy = "never";
+      sandbox = "danger-full-access";
+      continue;
+    }
+    if (arg === "--full-auto") {
+      approvalPolicy = "on-request";
+      sandbox = "workspace-write";
+      continue;
+    }
+    if (arg === "--ask-for-approval" || arg === "-a") {
+      const next = codexArgs[index + 1];
+      if (next && !next.startsWith("-")) {
+        approvalPolicy = next;
+        index += 1;
+      }
+      continue;
+    }
+    if (arg.startsWith("--ask-for-approval=")) {
+      approvalPolicy = arg.slice("--ask-for-approval=".length);
+      continue;
+    }
+    if (arg === "--sandbox" || arg === "-s") {
+      const next = codexArgs[index + 1];
+      if (next && !next.startsWith("-")) {
+        sandbox = next;
+        index += 1;
+      }
+      continue;
+    }
+    if (arg.startsWith("--sandbox=")) {
+      sandbox = arg.slice("--sandbox=".length);
+      continue;
+    }
+  }
+
+  return { approvalPolicy, sandbox };
+}
+
 function cleanupRun(runDir: string, appServer: ReturnType<typeof Bun.spawn> | null): void {
   if (existsSync(runDir)) {
     const pidsPath = join(runDir, "sidecar-pids.txt");
@@ -357,8 +456,9 @@ function cleanupRun(runDir: string, appServer: ReturnType<typeof Bun.spawn> | nu
 function installCodexSupport(quiet = false): void {
   if (!commandExists("bun")) throw new Error("Bun is required: https://bun.sh");
   findCodexBinary();
-  installMarketplace(quiet);
+  syncInstalledPackage();
   installHook();
+  installMarketplace(quiet);
 }
 
 function writeLauncherShim(name: string): void {
@@ -489,6 +589,7 @@ async function start(args: string[]): Promise<void> {
   }
 
   if (!listenUrl) listenUrl = await pickLoopbackUrl();
+  const permissions = resolveSessionPermissions(codexArgs);
 
   mkdirSync(runtimeRoot, { recursive: true });
   const runId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
@@ -502,6 +603,8 @@ async function start(args: string[]): Promise<void> {
     AGENT_RELAY_CODEX_RUN_ID: runId,
     AGENT_RELAY_CODEX_RUNTIME_DIR: runDir,
     CODEX_APP_SERVER_URL: listenUrl,
+    CODEX_LIVE_APPROVAL_POLICY: permissions.approvalPolicy,
+    CODEX_LIVE_SANDBOX: permissions.sandbox,
   };
 
   const appLog = Bun.file(join(runDir, "app-server.log"));
@@ -549,7 +652,9 @@ async function doctor(): Promise<void> {
   const checks: Array<[string, boolean, string]> = [];
   checks.push(["bun", commandExists("bun"), "Bun is required to run the sidecar"]);
   checks.push(["codex", findOnPath("codex", [aliasBinDir]) !== null, "Codex CLI is required"]);
-  checks.push(["hook", existsSync(join(home, ".codex", "hooks.json")), "~/.codex/hooks.json exists"]);
+  const configPath = join(home, ".codex", "config.toml");
+  const config = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
+  checks.push(["hook", isAgentRelaySessionStartCommand(config), "~/.codex/config.toml has Agent Relay SessionStart hook"]);
   checks.push(["marketplace", existsSync(marketplaceFile), "Agent Relay marketplace is installed"]);
   checks.push(["launcher", existsSync(join(aliasBinDir, process.platform === "win32" ? "codex-relay.cmd" : "codex-relay")), "codex-relay launcher shim"]);
 

package/codex/live-sidecar.ts

@@ -20,6 +20,8 @@ interface Config {
   threadMode: "auto" | "resume" | "start";
   threadId?: string;
   model?: string;
+  approvalPolicy?: string;
+  sandbox?: string;
 }
 
 interface RuntimeState {
@@ -196,8 +198,7 @@ class CodexLiveSidecar {
       const resumed = await this.app.threadResume({
         threadId,
         cwd: this.config.cwd,
-        approvalPolicy: "on-request",
-        sandbox: "workspace-write",
+        ...this.threadPermissions(),
         persistExtendedHistory: false,
       });
       return normalizeThread(resumed.thread);
@@ -213,8 +214,7 @@ class CodexLiveSidecar {
       const resumed = await this.app.threadResume({
         threadId: this.config.threadId,
         cwd: this.config.cwd,
-        approvalPolicy: "on-request",
-        sandbox: "workspace-write",
+        ...this.threadPermissions(),
         persistExtendedHistory: false,
       });
       return normalizeThread(resumed.thread);
@@ -238,8 +238,7 @@ class CodexLiveSidecar {
         const resumed = await this.app.threadResume({
           threadId: latest.id,
           cwd: this.config.cwd,
-          approvalPolicy: "on-request",
-          sandbox: "workspace-write",
+          ...this.threadPermissions(),
           persistExtendedHistory: false,
         });
         return normalizeThread(resumed.thread);
@@ -248,8 +247,7 @@ class CodexLiveSidecar {
 
     const started = await this.app.threadStart({
       cwd: this.config.cwd,
-      approvalPolicy: "on-request",
-      sandbox: "workspace-write",
+      ...this.threadPermissions(),
       ephemeral: false,
       sessionStartSource: "startup",
       model: this.config.model ?? null,
@@ -257,6 +255,13 @@ class CodexLiveSidecar {
     return normalizeThread(started.thread);
   }
 
+  private threadPermissions(): Record<string, string> {
+    const payload: Record<string, string> = {};
+    if (this.config.approvalPolicy) payload.approvalPolicy = this.config.approvalPolicy;
+    if (this.config.sandbox) payload.sandbox = this.config.sandbox;
+    return payload;
+  }
+
   private async readThreadWithFallback(threadId: string): Promise<Thread> {
     try {
       const read = await this.app.threadRead(threadId, true);
@@ -595,6 +600,8 @@ function loadConfig(): Config {
     threadMode: (process.env.CODEX_THREAD_MODE as Config["threadMode"]) || "auto",
     threadId: process.env.CODEX_THREAD_ID || undefined,
     model: process.env.CODEX_MODEL || undefined,
+    approvalPolicy: process.env.CODEX_LIVE_APPROVAL_POLICY || undefined,
+    sandbox: process.env.CODEX_LIVE_SANDBOX || undefined,
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-server",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "Lightweight HTTP message relay for inter-agent communication across machines",
   "module": "src/index.ts",
   "type": "module",

package/codex/README.md

@@ -1,82 +0,0 @@
-# Codex Live Sidecar
-
-Codex integration for Agent Relay.
-
-## Purpose
-
-This sidecar connects to a Codex app-server session and to Agent Relay, then delivers incoming relay messages into the active Codex thread using:
-
-- `turn/start`
-- `turn/steer`
-- `turn/interrupt`
-
-## Current behavior
-
-- attaches to a loaded thread for the current `cwd` when one exists
-- otherwise resumes the newest thread for the current `cwd`
-- otherwise creates a new thread
-- registers a relay agent with `client: codex-live`
-- marks the relay agent `ready=true` once app-server + thread are attached
-- polls relay inbox and delivers messages into the live thread
-- coalesces ordinary relay bursts into one delivery turn
-- reconnects to the app-server with exponential backoff after disconnects
-- writes runtime state to `codex/runtime/live-state.json`
-
-## Delivery behavior
-
-- idle thread: `turn/start`
-- active thread: `turn/steer`
-- urgent or `meta.delivery = "interrupt"`: `turn/interrupt` then `turn/start`
-
-## Run
-
-```bash
-codex/start-live.sh
-```
-
-## Installable workflow
-
-The packaged Codex path is:
-
-```bash
-bunx agent-relay-server@latest
-curl -fsSL https://unpkg.com/agent-relay-server@latest/codex/install-codex.sh | bash
-# after restarting your shell
-codex-relay
-```
-
-The installer always adds a `codex-relay` launcher and asks whether plain
-`codex` should also route through Agent Relay. `codex-relay` idempotently
-installs or refreshes the Codex hook/plugin, then launches `codex app-server`,
-starts Codex with
-`--remote`, lets the SessionStart hook attach a sidecar to the actual thread,
-and kills sidecars plus the app-server when Codex exits.
-
-For local development from this repo:
-
-```bash
-bun run bin/agent-relay-codex.ts
-bun run codex:smoke:fallback
-```
-
-Useful environment variables:
-
-- `AGENT_RELAY_URL`
-- `AGENT_RELAY_CAPS`
-- `CODEX_APP_SERVER_URL`
-- `CODEX_THREAD_ID`
-- `CODEX_THREAD_MODE=auto|resume|start`
-- `CODEX_LIVE_STATE_PATH`
-- `CODEX_LIVE_COALESCE_WINDOW_MS`
-- `CODEX_LIVE_RECONNECT_INITIAL_MS`
-- `CODEX_LIVE_RECONNECT_MAX_MS`
-- `CODEX_LIVE_RIG`
-- `CODEX_MODEL`
-
-## Notes
-
-Current sidecar behavior is stable for live delivery. Remaining gaps are advanced policies such as batching by sender, message prioritization queues, and more nuanced retry/backoff behavior.
-
-- `CODEX_THREAD_MODE=auto` will attach to an already loaded thread for the same `cwd`. That is what you want for real live control, but it also means the sidecar can attach to your current interactive Codex session if one is already open.
-- For isolated testing, set `CODEX_THREAD_MODE=start` so the sidecar always creates its own thread.
-- A brand-new thread is not materialized for `includeTurns` reads until the first turn starts. That is an app-server behavior, not a relay bug.