agent-relay-runner 0.29.0 → 0.30.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.29.0",
+  "version": "0.30.1",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "directory": "runner"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.18"
+    "agent-relay-sdk": "0.2.19"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/plugins/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-relay-runner",
   "description": "Thin Agent Relay runner bridge for Claude Code",
-  "version": "0.29.0",
+  "version": "0.30.1",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/adapter.ts

@@ -174,7 +174,7 @@ export function profileAllowsRelayFeature(config: RunnerSpawnConfig, feature: ke
 
 export const RELAY_CONTEXT = `[agent-relay] You are connected to Agent Relay, a real-time message bus between agents and users. When you receive a relay message: read it, do what it asks, and reply through the relay when a text response is needed. Use agent-relay /react <messageId> <emoji> for lightweight acknowledgement or approval. If Relay MCP tools are available, prefer relay_reply, relay_get_message, relay_get_thread, relay_send_message, relay_upload_artifact, relay_attach_artifact, relay_agent_status, relay_find_agents, relay_spawn_agent, and relay_shutdown_agent. You never need to know or pass your own agent id — relay fills it from your token; use relay_whoami only if you need to reason about yourself. relay_spawn_agent / relay_shutdown_agent only appear if your profile grants spawning (a live-children quota); when present you can stand up long-living child agents and shut down your own — find them later with relay_find_agents spawnedBy:me. CLI fallback: agent-relay /reply <messageId> --stdin < response.md; if a delivered message says it was truncated, fetch the full body with: agent-relay get-message <messageId>. For command details, run: agent-relay /guide`;
 
-const PROVIDER_MESSAGE_BODY_PREVIEW_CHARS = 4000;
+export const PROVIDER_MESSAGE_BODY_PREVIEW_CHARS = 4000;
 
 function attachmentRefs(message: Message): Record<string, unknown>[] {
   const payloadRefs = message.payload?.attachments;

package/src/adapters/claude-delivery.ts

@@ -1,8 +1,7 @@
 import type { Message } from "agent-relay-sdk";
 import { isRecord } from "agent-relay-sdk";
-import { isNotificationMessage, NOTIFICATION_NUDGE, providerAttachmentText } from "../adapter";
+import { isNotificationMessage, NOTIFICATION_NUDGE, PROVIDER_MESSAGE_BODY_PREVIEW_CHARS, providerAttachmentText } from "../adapter";
 
-const PROVIDER_MESSAGE_BODY_PREVIEW_CHARS = 4000;
 const REMINDER_EVERY_DELIVERIES = 5;
 
 interface ClaudeDeliveryTextOptions {

package/src/adapters/claude.ts

@@ -48,7 +48,7 @@ export class ClaudeAdapter implements ProviderAdapter {
       await this.shutdownTmux(tmuxSession, opts, tmuxSocket);
       return;
     }
-    await terminateProcess(process, opts);
+    await terminateSingleProcess(process, opts);
   }
 
   async compact(process: ManagedProcess): Promise<Record<string, unknown>> {
@@ -586,7 +586,7 @@ export function findClaudeRigRC(cwd: string): string | null {
   }
 }
 
-async function terminateProcess(process: ManagedProcess, opts: { graceful: boolean; timeoutMs: number }): Promise<void> {
+async function terminateSingleProcess(process: ManagedProcess, opts: { graceful: boolean; timeoutMs: number }): Promise<void> {
   const proc = process.process;
   if (!proc) return;
   try {

package/src/adapters/codex.ts

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { basename, join, resolve } from "node:path";
 import type { ContextState, Message } from "agent-relay-sdk";
 import { isRecord, stringValue } from "agent-relay-sdk";
-import { isPidAlive, killPid, waitForPidsExit } from "agent-relay-sdk/process-utils";
+import { isPidAlive, killPid, processTreePids, processTreePidsFromTable, waitForPidsExit } from "agent-relay-sdk/process-utils";
 import { profileAllowsRelayFeature, providerMessageText, RELAY_CONTEXT, type ManagedProcess, type ProviderAdapter, type ProviderConfig, type ProviderPermissionDecisionInput, type ProviderSessionEvent, type ProviderStatusUpdate, type RunnerSpawnConfig, type SpawnArgs, type TerminalAttachSpec } from "../adapter";
 import { workspaceDepsNoteFromEnv } from "../relay-instructions";
 import { relayMcpCodexConfigArgs, tomlString } from "../relay-mcp";
@@ -18,6 +18,7 @@ function codexRelayContextBlock(): string {
 import { prepareCodexProfileHome, profileUsesHostProviderGlobals } from "../profile-home";
 import { CodexAppClient, type ClientEvent } from "./codex-client";
 
+export { processTreePidsFromTable };
 export const DEFAULT_CODEX_TOOL_OUTPUT_TOKEN_LIMIT = 12_000;
 
 type PendingCodexApproval = {
@@ -28,12 +29,22 @@ type PendingCodexApproval = {
   view: Record<string, unknown>;
 };
 
+type PendingCodexCompact = {
+  threadId: string;
+  timeout: ReturnType<typeof setTimeout>;
+  resolve: () => void;
+  reject: (error: Error) => void;
+};
+
+const CODEX_COMPACT_TIMEOUT_MS = 10 * 60 * 1000;
+
 export class CodexAdapter implements ProviderAdapter {
   readonly provider = "codex";
   private statusCb: (status: ProviderStatusUpdate) => void = () => {};
   private sessionEventCb: (event: ProviderSessionEvent) => void = () => {};
   private readonly subagentThreads = new Map<string, { label?: string; role?: string; parentId?: string }>();
   private readonly pendingApprovals = new Map<string, PendingCodexApproval>();
+  private pendingCompact?: PendingCodexCompact;
   // Active turn id for the main thread, captured from turn/started so an interrupt
   // can target the in-flight turn. Cleared on turn/completed.
   private activeTurnId?: string;
@@ -65,6 +76,7 @@ export class CodexAdapter implements ProviderAdapter {
   }
 
   private resetThreadState(): void {
+    this.cancelPendingCompact(new Error("Codex compact canceled by thread reset"));
     this.subagentThreads.clear();
     this.pendingApprovals.clear();
     this.activeTurnId = undefined;
@@ -179,7 +191,7 @@ export class CodexAdapter implements ProviderAdapter {
   async shutdown(process: ManagedProcess, opts: { graceful: boolean; timeoutMs: number }): Promise<void> {
     const client = process.meta?.client as CodexAppClient | undefined;
     client?.close();
-    await terminateProcess(process, opts);
+    await terminateProcessTree(process, opts);
   }
 
   async compact(process: ManagedProcess): Promise<Record<string, unknown>> {
@@ -195,9 +207,12 @@ export class CodexAdapter implements ProviderAdapter {
         context: { ...currentContext, lifecycleState: "compacting", lastUpdatedAt: Date.now() },
       };
     }
+    const completion = this.waitForPendingCompact(threadId);
     try {
       await client.threadCompactStart(threadId);
+      await completion;
     } catch (error) {
+      this.clearPendingCompact(threadId);
       this.statusCb({ status: "idle", reason: "provider-turn" });
       throw error;
     }
@@ -377,6 +392,12 @@ export class CodexAdapter implements ProviderAdapter {
             updatedAt: Date.now(),
           },
         });
+      } else {
+        const client = process.meta?.client as CodexAppClient | undefined;
+        logger.warn("codex", `rejecting unknown Codex server-request method: ${event.message.method}`);
+        client?.rejectServerRequest(event.message.id, -32601, `Method not found: ${event.message.method}`, {
+          method: event.message.method,
+        });
       }
       return;
     }
@@ -426,8 +447,13 @@ export class CodexAdapter implements ProviderAdapter {
         this.finishMainTurn();
       }
     }
+    if ((method.includes("thread/compacted") || method.includes("thread.compacted")) && threadId) {
+      this.completePendingCompact(threadId);
+    }
     if ((method.includes("item/completed") || method.includes("item.completed")) && !isSubagent) {
-      this.handleCodexItem(isRecord(params?.item) ? params.item : undefined);
+      const item = isRecord(params?.item) ? params.item : undefined;
+      this.handleCodexItem(item);
+      if (codexItemIsCompactionComplete(item) && threadId) this.completePendingCompact(threadId);
     }
     if (!isSubagent) this.handleCodexItemDelta(method, params);
     if (method.includes("thread/status") || method.includes("thread.status")) {
@@ -553,6 +579,47 @@ export class CodexAdapter implements ProviderAdapter {
     this.statusCb({ status: "idle", reason: "provider-turn", id: turnId });
   }
 
+  private waitForPendingCompact(threadId: string): Promise<void> {
+    if (this.pendingCompact) throw new Error("Codex compact is already in progress");
+    return new Promise<void>((resolve, reject) => {
+      const pending: PendingCodexCompact = {
+        threadId,
+        resolve,
+        reject,
+        timeout: setTimeout(() => {
+          if (this.pendingCompact !== pending) return;
+          this.pendingCompact = undefined;
+          reject(new Error(`Codex compact timed out after ${Math.round(CODEX_COMPACT_TIMEOUT_MS / 1000)}s`));
+        }, CODEX_COMPACT_TIMEOUT_MS),
+      };
+      this.pendingCompact = pending;
+    });
+  }
+
+  private completePendingCompact(threadId: string): boolean {
+    const pending = this.pendingCompact;
+    if (!pending || pending.threadId !== threadId) return false;
+    clearTimeout(pending.timeout);
+    this.pendingCompact = undefined;
+    pending.resolve();
+    return true;
+  }
+
+  private clearPendingCompact(threadId?: string): void {
+    const pending = this.pendingCompact;
+    if (!pending || (threadId && pending.threadId !== threadId)) return;
+    clearTimeout(pending.timeout);
+    this.pendingCompact = undefined;
+  }
+
+  private cancelPendingCompact(error: Error): void {
+    const pending = this.pendingCompact;
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    this.pendingCompact = undefined;
+    pending.reject(error);
+  }
+
   private providerStateFromThreadStatus(status: unknown, params?: Record<string, unknown>): Record<string, unknown> | undefined {
     const state = codexProviderStateFromThreadStatus(status, params);
     if (state?.state !== "blocked" || state.reason !== "waitingOnApproval" || state.pendingApproval) return state;
@@ -565,6 +632,11 @@ function codexItemId(item: Record<string, unknown> | undefined): string | undefi
   return stringValue(item?.itemId) ?? stringValue(item?.id);
 }
 
+function codexItemIsCompactionComplete(item: Record<string, unknown> | undefined): boolean {
+  const type = stringValue(item?.type);
+  return type === "context_compaction" || type === "contextCompaction" || type === "compaction";
+}
+
 function codexDeltaText(params: Record<string, unknown> | undefined): string {
   const delta = params?.delta;
   if (typeof delta === "string") return delta;
@@ -1101,7 +1173,7 @@ async function connectWithRetry(client: CodexAppClient, attempts = 40): Promise<
   throw lastError instanceof Error ? lastError : new Error(String(lastError));
 }
 
-async function terminateProcess(process: ManagedProcess, opts: { graceful: boolean; timeoutMs: number }): Promise<void> {
+async function terminateProcessTree(process: ManagedProcess, opts: { graceful: boolean; timeoutMs: number }): Promise<void> {
   const processes = [
     process.meta?.tui as Bun.Subprocess | undefined,
     process.meta?.appServer as Bun.Subprocess | undefined,
@@ -1130,37 +1202,6 @@ async function terminateProcess(process: ManagedProcess, opts: { graceful: boole
   }
 }
 
-export function processTreePidsFromTable(table: string, rootPids: number[]): number[] {
-  const childrenByParent = new Map<number, number[]>();
-  for (const line of table.split("\n")) {
-    const match = line.trim().match(/^(\d+)\s+(\d+)$/);
-    if (!match) continue;
-    const pid = Number(match[1]);
-    const ppid = Number(match[2]);
-    if (!Number.isFinite(pid) || !Number.isFinite(ppid)) continue;
-    const children = childrenByParent.get(ppid) ?? [];
-    children.push(pid);
-    childrenByParent.set(ppid, children);
-  }
-
-  const seen = new Set<number>();
-  const visit = (pid: number) => {
-    if (seen.has(pid)) return;
-    seen.add(pid);
-    for (const child of childrenByParent.get(pid) ?? []) visit(child);
-  };
-  for (const pid of rootPids) visit(pid);
-  return [...seen].sort((a, b) => b - a);
-}
-
-async function processTreePids(rootPids: number[]): Promise<number[]> {
-  if (rootPids.length === 0) return [];
-  const proc = Bun.spawn(["ps", "-e", "-o", "pid=,ppid="], { stdout: "pipe", stderr: "ignore" });
-  const table = await new Response(proc.stdout).text();
-  await proc.exited;
-  return processTreePidsFromTable(table, rootPids);
-}
-
 function codexRelayContextEnabled(process: ManagedProcess): boolean {
   const config = process.meta?.config as RunnerSpawnConfig | undefined;
   return config ? profileAllowsRelayFeature(config, "context") : true;

package/src/config.ts

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
 import { join, resolve } from "node:path";
-import { stringValue } from "agent-relay-sdk";
+import { DEFAULT_RELAY_URL, stringValue } from "agent-relay-sdk";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 import type { ProviderConfig } from "./adapter";
 
@@ -15,8 +15,6 @@ interface LoadedProviderConfig extends ProviderConfig {
   path: string;
 }
 
-const DEFAULT_RELAY_URL = "http://127.0.0.1:4850";
-
 function agentRelayHome(): string {
   return process.env.AGENT_RELAY_HOME || join(homedir(), ".agent-relay");
 }