agent-relay-server 0.3.7 → 0.3.8

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> {
@@ -407,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 {
@@ -602,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-server",
-  "version": "0.3.7",
+  "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,107 +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.
-
-## Approvals and prompts
-
-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`.
-
-Example: no prompt loop, still workspace sandboxing:
-
-```bash
-codex-relay -- --ask-for-approval never --sandbox workspace-write
-```
-
-If you prefer prompts for everything else but want relay sends auto-approved,
-add a rule in `~/.codex/rules/default.rules` (adjust URL when using a remote relay):
-
-```python
-prefix_rule(
-    pattern = ["curl", "-sS", "-X", "POST", "http://127.0.0.1:4850/api/messages"],
-    decision = "allow",
-    justification = "Allow local Agent Relay message posts",
-)
-```
-
-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.