agent-relay-server 0.3.7 → 0.3.9

package/README.md

@@ -77,16 +77,24 @@ codex-relay
 incoming messages as live turns, and cleans up sidecar processes when Codex
 exits.
 
-### Codex approval prompts
+### Codex approval mode
 
 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`.
+By default, `codex-relay` starts Codex with
+`--dangerously-bypass-approvals-and-sandbox` so relay turns do not get stuck on
+approval prompts. If you pass an explicit Codex runtime mode, `codex-relay`
+leaves it alone and forwards it to the sidecar, including `--ask-for-approval`,
+`--sandbox`, `--full-auto`, and `--yolo`.
 
 Useful setups:
 
+```bash
+# default: no approval prompts, no Codex sandbox
+codex-relay
+```
+
 ```bash
 # no approval prompts, still sandboxed to workspace boundaries
 codex-relay -- --ask-for-approval never --sandbox workspace-write

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> {
@@ -334,6 +383,25 @@ type SessionPermissions = {
   sandbox?: string;
 };
 
+function hasCodexPermissionMode(codexArgs: string[]): boolean {
+  for (const arg of codexArgs) {
+    if (
+      arg === "--yolo" ||
+      arg === "--dangerously-bypass-approvals-and-sandbox" ||
+      arg === "--full-auto" ||
+      arg === "--ask-for-approval" ||
+      arg === "-a" ||
+      arg.startsWith("--ask-for-approval=") ||
+      arg === "--sandbox" ||
+      arg === "-s" ||
+      arg.startsWith("--sandbox=")
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
 function resolveSessionPermissions(codexArgs: string[]): SessionPermissions {
   let approvalPolicy: string | undefined;
   let sandbox: string | undefined;
@@ -407,8 +475,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 {
@@ -438,7 +507,6 @@ function installLauncherShims(includeCodexAlias: boolean): void {
   mkdirSync(aliasBinDir, { recursive: true });
   writeLauncherShim("codex-relay");
   if (includeCodexAlias) writeLauncherShim("codex");
-  else removeLauncherShim("codex");
 }
 
 function isAliasBinOnPath(): boolean {
@@ -539,6 +607,7 @@ async function start(args: string[]): Promise<void> {
   }
 
   if (!listenUrl) listenUrl = await pickLoopbackUrl();
+  if (!hasCodexPermissionMode(codexArgs)) codexArgs.unshift("--dangerously-bypass-approvals-and-sandbox");
   const permissions = resolveSessionPermissions(codexArgs);
 
   mkdirSync(runtimeRoot, { recursive: true });
@@ -577,8 +646,8 @@ async function start(args: string[]): Promise<void> {
   process.once("exit", shutdown);
 
   await waitForPort(listenUrl, appServer);
-  console.error(`Agent Relay Codex session: ${listenUrl}`);
-  console.error(`Runtime: ${runDir}`);
+  console.log(`Agent Relay Codex session: ${listenUrl}`);
+  console.log(`Runtime: ${runDir}`);
 
   const codex = Bun.spawn([codexBinary, "--remote", listenUrl, ...codexArgs], {
     env,
@@ -602,7 +671,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/README.md

@@ -52,13 +52,22 @@ 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.
 
-## Approvals and prompts
+## Approval mode
 
 Relay replies are usually sent with a shell command (`curl` to
 `/api/messages`), so Codex can prompt for approval in stricter modes.
 
-`codex-relay` forwards your launch mode to the sidecar, including
-`--ask-for-approval`, `--sandbox`, `--full-auto`, and `--yolo`.
+By default, `codex-relay` starts Codex with
+`--dangerously-bypass-approvals-and-sandbox` so relay turns do not get stuck on
+approval prompts. If you pass an explicit Codex runtime mode, `codex-relay`
+leaves it alone and forwards it to the sidecar, including `--ask-for-approval`,
+`--sandbox`, `--full-auto`, and `--yolo`.
+
+Default:
+
+```bash
+codex-relay
+```
 
 Example: no prompt loop, still workspace sandboxing:
 

package/codex/smoke/fallback.ts

@@ -48,8 +48,8 @@ exit 64
   chmodSync(path, 0o755);
 }
 
-function parseRuntimeDir(stderr: string): string | null {
-  const match = stderr.match(/^Runtime:\s+(.+)$/m);
+function parseRuntimeDir(output: string): string | null {
+  const match = output.match(/^Runtime:\s+(.+)$/m);
   return match?.[1]?.trim() || null;
 }
 
@@ -85,9 +85,9 @@ async function main(): Promise<void> {
     throw new Error(`launcher exited ${exitCode}\nstdout:\n${stdout}\nstderr:\n${stderr}`);
   }
 
-  const runtimeDir = parseRuntimeDir(stderr);
+  const runtimeDir = parseRuntimeDir(`${stdout}\n${stderr}`);
   if (!runtimeDir) {
-    throw new Error(`missing runtime directory in launcher output\nstderr:\n${stderr}`);
+    throw new Error(`missing runtime directory in launcher output\nstdout:\n${stdout}\nstderr:\n${stderr}`);
   }
 
   if (!stderr.includes("SessionStart hook did not start sidecar; started fallback sidecar pid")) {
@@ -122,4 +122,3 @@ main().catch((error) => {
   log(error instanceof Error ? error.stack || error.message : String(error));
   process.exitCode = 1;
 });
-

package/package.json

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