agent-relay-runner 0.10.19 → 0.10.21

package/src/adapters/claude.ts

@@ -1,13 +1,16 @@
-import { resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
 import type { Message } from "agent-relay-sdk";
-import type { ManagedProcess, ProviderAdapter, ProviderConfig, RunnerSpawnConfig, SemanticStatus, SpawnArgs } from "../adapter";
+import { profileAllowsRelayFeature, type ManagedProcess, type ProviderAdapter, type ProviderConfig, type ProviderStatusUpdate, type RunnerSpawnConfig, type SemanticStatus, type SpawnArgs } from "../adapter";
+import { prepareClaudeProfileHome, profileUsesHostProviderGlobals } from "../profile-home";
 
 export class ClaudeAdapter implements ProviderAdapter {
   readonly provider = "claude";
-  private statusCb: (status: SemanticStatus) => void = () => {};
+  private statusCb: (status: ProviderStatusUpdate) => void = () => {};
   private tmuxWatcher?: Timer;
 
-  onStatusChange(cb: (status: SemanticStatus) => void): void {
+  onStatusChange(cb: (status: ProviderStatusUpdate) => void): void {
     this.statusCb = cb;
   }
 
@@ -31,44 +34,83 @@ export class ClaudeAdapter implements ProviderAdapter {
 
   async shutdown(process: ManagedProcess, opts: { graceful: boolean; timeoutMs: number }): Promise<void> {
     const tmuxSession = process.meta?.tmuxSession as string | undefined;
+    const tmuxSocket = process.meta?.tmuxSocket as string | undefined;
     if (tmuxSession) {
-      await this.shutdownTmux(tmuxSession, opts);
+      await this.shutdownTmux(tmuxSession, opts, tmuxSocket);
       return;
     }
     await terminateProcess(process, opts);
   }
 
+  async compact(process: ManagedProcess): Promise<Record<string, unknown>> {
+    const session = process.meta?.tmuxSession as string | undefined;
+    const socket = process.meta?.tmuxSocket as string | undefined;
+    if (!session || !tmuxHasSession(session, socket)) throw new Error("no active tmux session for compact");
+    await submitTextToTmux(session, "/compact", socket);
+    return { method: "tmux-inject", command: "/compact" };
+  }
+
+  async clearContext(process: ManagedProcess): Promise<Record<string, unknown>> {
+    const session = process.meta?.tmuxSession as string | undefined;
+    const socket = process.meta?.tmuxSocket as string | undefined;
+    if (!session || !tmuxHasSession(session, socket)) throw new Error("no active tmux session for clear");
+    await submitTextToTmux(session, "/clear", socket);
+    return { method: "tmux-inject", command: "/clear" };
+  }
+
   async deliver(_process: ManagedProcess, messages: Message[]): Promise<void> {
     const monitor = _process.meta?.monitor as { deliver?(messages: Message[]): Promise<number[]> } | undefined;
     if (!monitor?.deliver) throw new Error("Claude monitor delivery is unavailable");
     await monitor.deliver(messages);
   }
 
+  async deliverInitialPrompt(process: ManagedProcess, prompt: string): Promise<void> {
+    const session = process.meta?.tmuxSession as string | undefined;
+    const socket = process.meta?.tmuxSocket as string | undefined;
+    if (!session || !tmuxHasSession(session, socket)) throw new Error("no active tmux session for initial prompt");
+    await waitForClaudeInputReady(session, CLAUDE_TMUX_READY_TIMEOUT_MS, socket);
+    await submitTextToTmux(session, prompt, socket);
+  }
+
   buildSpawnArgs(config: RunnerSpawnConfig, providerConfig: ProviderConfig): SpawnArgs {
+    const profileHome = prepareClaudeProfileHome(config);
     const pluginRoot = resolve(import.meta.dir, "../../plugins/claude");
-    const pluginDirs = [...new Set([pluginRoot, ...providerConfig.pluginDirs])];
+    const defaultArgs = profileUsesHostProviderGlobals(config) ? providerConfig.defaultArgs : [];
+    const pluginDirs = profileAllowsRelayFeature(config, "plugins") ? [...new Set([pluginRoot, ...providerConfig.pluginDirs])] : [];
     const isClaudeRig = /claude-rig/.test(providerConfig.command);
-    const rigPrefix = isClaudeRig && config.rig ? ["launch", config.rig] : [];
+    const bypassRigDefaults = config.headless && isClaudeRig && config.approvalMode !== "open";
+    const rigPrefix = isClaudeRig && !bypassRigDefaults && config.rig ? ["launch", config.rig] : [];
+    const command = bypassRigDefaults || (isClaudeRig && !config.rig && !findClaudeRigRC(config.cwd))
+      ? "claude"
+      : providerConfig.command;
+    const providerArgs = config.headless
+      ? claudeLaunchArgs(defaultArgs, config.providerArgs, config.approvalMode)
+      : [...defaultArgs, ...config.providerArgs];
     const args = [
       ...rigPrefix,
       ...pluginDirs.flatMap((dir) => ["--plugin-dir", dir]),
-      ...providerConfig.defaultArgs,
-      ...config.providerArgs,
+      ...(profileAllowsRelayFeature(config, "statusLine") ? sessionStatusLineSettingsArgs(defaultArgs, config.providerArgs) : []),
+      ...(config.systemPromptAppend ? ["--append-system-prompt", config.systemPromptAppend] : []),
+      ...providerArgs,
     ];
-    if (config.prompt) args.push(String(config.prompt));
+    if (config.model) args.push("--model", config.model);
+    if (config.prompt && !config.headless) args.push(String(config.prompt));
     return {
-      command: providerConfig.command,
+      command,
       args,
       cwd: config.cwd,
       env: {
         ...config.env,
+        ...(profileHome ? { CLAUDE_CONFIG_DIR: profileHome.path } : {}),
         AGENT_RELAY_PROVIDER: "claude",
+        ...(config.effort ? { CLAUDE_CODE_EFFORT_LEVEL: config.effort } : {}),
       },
     };
   }
 
-  buildTmuxArgs(config: RunnerSpawnConfig, spawnArgs: SpawnArgs): { sessionName: string; args: string[] } {
-    const sessionName = tmuxSessionName(config.providerConfig.headless.tmuxPrefix, config.instanceId, config.label);
+  buildTmuxArgs(config: RunnerSpawnConfig, spawnArgs: SpawnArgs): { sessionName: string; socketName: string; args: string[] } {
+    const sessionName = config.tmuxSession || tmuxSessionName(config.providerConfig.headless.tmuxPrefix, config.instanceId, config.label);
+    const socketName = tmuxSocketName(sessionName);
     const shellCmd = [spawnArgs.command, ...spawnArgs.args].map(shellQuote).join(" ");
     const tmuxArgs = ["new-session", "-d", "-s", sessionName, "-x", "200", "-y", "50"];
 
@@ -80,17 +122,17 @@ export class ClaudeAdapter implements ProviderAdapter {
     }
 
     tmuxArgs.push("-c", spawnArgs.cwd, shellCmd);
-    return { sessionName, args: tmuxArgs };
+    return { sessionName, socketName, args: tmuxArgs };
   }
 
   private async spawnHeadless(config: RunnerSpawnConfig, spawnArgs: SpawnArgs): Promise<ManagedProcess> {
-    const { sessionName, args: tmuxArgs } = this.buildTmuxArgs(config, spawnArgs);
+    const { sessionName, socketName, args: tmuxArgs } = this.buildTmuxArgs(config, spawnArgs);
 
-    Bun.spawnSync(["tmux", "kill-session", "-t", sessionName], {
+    Bun.spawnSync(tmuxCommand(socketName, "kill-session", "-t", sessionName), {
       stdin: "ignore", stdout: "ignore", stderr: "ignore",
     });
 
-    const result = Bun.spawnSync(["tmux", ...tmuxArgs], {
+    const result = Bun.spawnSync(tmuxCommand(socketName, ...tmuxArgs), {
       stdin: "ignore",
       stdout: "pipe",
       stderr: "pipe",
@@ -101,7 +143,15 @@ export class ClaudeAdapter implements ProviderAdapter {
       throw new Error(`tmux session creation failed: ${stderr || `exit code ${result.exitCode}`}`);
     }
 
-    this.watchTmuxSession(sessionName);
+    this.watchTmuxSession(sessionName, socketName);
+    const logFile = spawnArgs.env.AGENT_RELAY_LOG_FILE;
+    if (logFile) {
+      Bun.spawnSync(tmuxCommand(socketName, "pipe-pane", "-o", "-t", sessionName, `cat >> ${shellQuote(logFile)}`), {
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "ignore",
+      });
+    }
 
     return {
       pid: undefined,
@@ -109,14 +159,15 @@ export class ClaudeAdapter implements ProviderAdapter {
       meta: {
         monitor: config.monitor,
         tmuxSession: sessionName,
+        tmuxSocket: socketName,
       },
     };
   }
 
-  private watchTmuxSession(sessionName: string): void {
+  private watchTmuxSession(sessionName: string, socketName?: string): void {
     if (this.tmuxWatcher) clearInterval(this.tmuxWatcher);
     this.tmuxWatcher = setInterval(() => {
-      if (!tmuxHasSession(sessionName)) {
+      if (!tmuxHasSession(sessionName, socketName)) {
         clearInterval(this.tmuxWatcher!);
         this.tmuxWatcher = undefined;
         this.statusCb("offline");
@@ -124,42 +175,180 @@ export class ClaudeAdapter implements ProviderAdapter {
     }, 2000);
   }
 
-  private async shutdownTmux(sessionName: string, opts: { graceful: boolean; timeoutMs: number }): Promise<void> {
+  private async shutdownTmux(sessionName: string, opts: { graceful: boolean; timeoutMs: number }, socketName?: string): Promise<void> {
     if (this.tmuxWatcher) {
       clearInterval(this.tmuxWatcher);
       this.tmuxWatcher = undefined;
     }
 
-    if (opts.graceful && tmuxHasSession(sessionName)) {
-      Bun.spawnSync(["tmux", "send-keys", "-t", sessionName, "C-c"], {
-        stdin: "ignore", stdout: "ignore", stderr: "ignore",
-      });
+    if (opts.graceful && tmuxHasSession(sessionName, socketName)) {
+      await submitTextToTmux(sessionName, CLAUDE_EXIT_COMMAND, socketName);
 
-      const deadline = Date.now() + opts.timeoutMs;
+      const deadline = Date.now() + claudeShutdownGraceMs(opts.timeoutMs);
       while (Date.now() < deadline) {
-        if (!tmuxHasSession(sessionName)) return;
-        await Bun.sleep(500);
+        if (!tmuxHasSession(sessionName, socketName)) return;
+        await Bun.sleep(200);
       }
     }
 
-    Bun.spawnSync(["tmux", "kill-session", "-t", sessionName], {
+    Bun.spawnSync(tmuxCommand(socketName, "kill-session", "-t", sessionName), {
       stdin: "ignore", stdout: "ignore", stderr: "ignore",
     });
   }
 }
 
+export const CLAUDE_EXIT_COMMAND = "/exit";
+export const CLAUDE_TMUX_SUBMIT_DELAY_MS = 250;
+export const CLAUDE_TMUX_SUBMIT_KEY = "C-m";
+export const CLAUDE_TMUX_READY_TIMEOUT_MS = 10_000;
+
+export function claudeShutdownGraceMs(timeoutMs: number): number {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return 10_000;
+  return Math.min(timeoutMs, 10_000);
+}
+
+export function sessionStatusLineSettingsArgs(...argLists: string[][]): string[] {
+  if (argLists.some(hasSettingsArg)) return [];
+  return ["--settings", JSON.stringify({
+    statusLine: {
+      type: "command",
+      command: "agent-relay context-probe --wrap",
+      refreshInterval: 30,
+    },
+  })];
+}
+
+export function claudeLaunchArgs(defaultArgs: string[], providerArgs: string[], approvalMode?: string): string[] {
+  return [
+    ...stripClaudePermissionArgs(defaultArgs),
+    ...stripClaudePermissionArgs(providerArgs),
+    ...claudePermissionModeArgs(approvalMode),
+  ];
+}
+
+export function claudePermissionModeArgs(approvalMode?: string): string[] {
+  if (approvalMode === "open") return ["--dangerously-skip-permissions"];
+  if (approvalMode === "read-only") return [
+    "--permission-mode",
+    "dontAsk",
+    "--allowedTools",
+    "Read,Grep,Glob,LS,Bash(agent-relay *)",
+  ];
+  return ["--permission-mode", "default"];
+}
+
+function stripClaudePermissionArgs(args: string[]): string[] {
+  const result: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) continue;
+    if (
+      arg === "--dangerously-skip-permissions" ||
+      arg === "--allow-dangerously-skip-permissions" ||
+      arg?.startsWith("--permission-mode=")
+    ) {
+      continue;
+    }
+    if (arg === "--permission-mode") {
+      i++;
+      continue;
+    }
+    result.push(arg);
+  }
+  return result;
+}
+
+function hasSettingsArg(args: string[]): boolean {
+  return args.some((arg) => arg === "--settings" || arg.startsWith("--settings="));
+}
+
 export function tmuxSessionName(prefix: string, instanceId: string, label?: string): string {
   if (label) return `${prefix}-${label.replace(/[^a-zA-Z0-9._-]/g, "-").toLowerCase()}`;
   return `${prefix}-${instanceId.slice(0, 8)}`;
 }
 
-export function tmuxHasSession(sessionName: string): boolean {
-  const result = Bun.spawnSync(["tmux", "has-session", "-t", sessionName], {
+export function tmuxSocketName(sessionName: string): string {
+  return `agent-relay-${sessionName}`.replace(/[^a-zA-Z0-9._-]/g, "-").toLowerCase();
+}
+
+function tmuxCommand(socketName: string | undefined, ...args: string[]): string[] {
+  return socketName ? ["tmux", "-L", socketName, ...args] : ["tmux", ...args];
+}
+
+export function tmuxHasSession(sessionName: string, socketName?: string): boolean {
+  const result = Bun.spawnSync(tmuxCommand(socketName, "has-session", "-t", sessionName), {
     stdin: "ignore", stdout: "ignore", stderr: "ignore",
   });
   return result.exitCode === 0;
 }
 
+function captureTmuxPane(sessionName: string, socketName?: string): string {
+  const result = Bun.spawnSync(tmuxCommand(socketName, "capture-pane", "-p", "-t", sessionName, "-S", "-80"), {
+    stdin: "ignore", stdout: "pipe", stderr: "pipe",
+  });
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.toString().trim();
+    throw new Error(`tmux capture-pane failed: ${stderr || `exit code ${result.exitCode}`}`);
+  }
+  return result.stdout.toString();
+}
+
+export function claudePaneLooksReady(text: string): boolean {
+  return text.includes("Claude Code")
+    && (
+      text.includes("bypass permissions")
+      || text.includes("/effort")
+      || text.includes("What's new")
+      || text.includes("Welcome back")
+    );
+}
+
+async function waitForClaudeInputReady(sessionName: string, timeoutMs = CLAUDE_TMUX_READY_TIMEOUT_MS, socketName?: string): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!tmuxHasSession(sessionName, socketName)) throw new Error("tmux session exited before Claude became ready");
+    if (claudePaneLooksReady(captureTmuxPane(sessionName, socketName))) return;
+    await Bun.sleep(200);
+  }
+  throw new Error(`Claude input was not ready within ${timeoutMs}ms`);
+}
+
+function pasteTextIntoTmux(sessionName: string, text: string, socketName?: string): void {
+  const bufferName = `agent-relay-${crypto.randomUUID()}`;
+  const setResult = Bun.spawnSync(tmuxCommand(socketName, "set-buffer", "-b", bufferName, text), {
+    stdin: "ignore", stdout: "ignore", stderr: "pipe",
+  });
+  if (setResult.exitCode !== 0) {
+    const stderr = setResult.stderr.toString().trim();
+    throw new Error(`tmux set-buffer failed: ${stderr || `exit code ${setResult.exitCode}`}`);
+  }
+  try {
+    const pasteResult = Bun.spawnSync(tmuxCommand(socketName, "paste-buffer", "-b", bufferName, "-t", sessionName), {
+      stdin: "ignore", stdout: "ignore", stderr: "pipe",
+    });
+    if (pasteResult.exitCode !== 0) {
+      const stderr = pasteResult.stderr.toString().trim();
+      throw new Error(`tmux paste-buffer failed: ${stderr || `exit code ${pasteResult.exitCode}`}`);
+    }
+  } finally {
+    Bun.spawnSync(tmuxCommand(socketName, "delete-buffer", "-b", bufferName), {
+      stdin: "ignore", stdout: "ignore", stderr: "ignore",
+    });
+  }
+}
+
+async function submitTextToTmux(sessionName: string, text: string, socketName?: string): Promise<void> {
+  pasteTextIntoTmux(sessionName, text, socketName);
+  await Bun.sleep(CLAUDE_TMUX_SUBMIT_DELAY_MS);
+  const result = Bun.spawnSync(tmuxCommand(socketName, "send-keys", "-t", sessionName, CLAUDE_TMUX_SUBMIT_KEY), {
+    stdin: "ignore", stdout: "ignore", stderr: "pipe",
+  });
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.toString().trim();
+    throw new Error(`tmux submit failed: ${stderr || `exit code ${result.exitCode}`}`);
+  }
+}
+
 export function tmuxEnvKeys(env: Record<string, string>, providerEnv: Record<string, string>): string[] {
   const keys = new Set<string>();
   for (const key of Object.keys(env)) {
@@ -179,6 +368,18 @@ export function shellQuote(arg: string): string {
   return `'${arg.replace(/'/g, "'\\''")}'`;
 }
 
+export function findClaudeRigRC(cwd: string): string | null {
+  const home = homedir();
+  let dir = resolve(cwd);
+  while (true) {
+    const rc = join(dir, ".claude-rig");
+    if (existsSync(rc)) return rc;
+    const parent = resolve(dir, "..");
+    if (parent === dir || dir === home) return null;
+    dir = parent;
+  }
+}
+
 async function terminateProcess(process: ManagedProcess, opts: { graceful: boolean; timeoutMs: number }): Promise<void> {
   const proc = process.process;
   if (!proc) return;

package/src/adapters/codex-client.ts

@@ -168,6 +168,10 @@ export class CodexAppClient {
     return this.request<ThreadLoadedListResponse>("thread/loaded/list", { limit });
   }
 
+  async threadCompactStart(threadId: string): Promise<Record<string, never>> {
+    return this.request<Record<string, never>>("thread/compact/start", { threadId });
+  }
+
   async turnStart(threadId: string, text: string): Promise<TurnStartResponse> {
     return this.request<TurnStartResponse>("turn/start", {
       threadId,
@@ -187,6 +191,20 @@ export class CodexAppClient {
     return this.request<Record<string, never>>("turn/interrupt", { threadId, turnId });
   }
 
+  respondToServerRequest(id: JsonRpcId, result: unknown): void {
+    if (!this.connected) {
+      throw new Error("websocket not connected");
+    }
+    this.ws.send(JSON.stringify({ id, result }));
+  }
+
+  rejectServerRequest(id: JsonRpcId, code: number, message: string, data?: unknown): void {
+    if (!this.connected) {
+      throw new Error("websocket not connected");
+    }
+    this.ws.send(JSON.stringify({ id, error: { code, message, ...(data !== undefined ? { data } : {}) } }));
+  }
+
   private async request<T = unknown>(method: string, params?: unknown): Promise<T> {
     if (!this.connected) {
       throw new Error("websocket not connected");
@@ -201,7 +219,15 @@ export class CodexAppClient {
   }
 
   private handleMessage(raw: string): void {
-    const parsed = JSON.parse(raw) as JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;
+    // The frame comes from an external process over a WebSocket; a partial or
+    // malformed frame must not throw out of onmessage and drop the connection.
+    let parsed: JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;
+    try {
+      parsed = JSON.parse(raw) as JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;
+    } catch {
+      this.log(`dropped malformed frame (${raw.length} bytes)`);
+      return;
+    }
 
     if ("id" in parsed && ("result" in parsed || "error" in parsed)) {
       const pending = this.pending.get(parsed.id);