agent-relay-runner 0.10.11 → 0.10.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.10.11",
+  "version": "0.10.13",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {

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

@@ -1,5 +1,5 @@
 {
   "name": "agent-relay-runner",
   "description": "Thin Agent Relay runner bridge for Claude Code",
-  "version": "0.10.11"
+  "version": "0.10.13"
 }

package/src/adapters/codex.ts

@@ -162,17 +162,79 @@ async function terminateProcess(process: ManagedProcess, opts: { graceful: boole
     process.process,
   ].filter(Boolean) as Bun.Subprocess[];
   if (processes.length === 0) return;
+  const rootPids = processes.map((proc) => proc.pid).filter((pid): pid is number => typeof pid === "number" && pid > 0);
+  const pids = await processTreePids(rootPids).catch(() => rootPids);
+  const signal = opts.graceful ? "SIGTERM" : "SIGKILL";
   try {
-    for (const proc of processes) proc.kill(opts.graceful ? "SIGTERM" : "SIGKILL");
+    for (const pid of pids) killPid(pid, signal);
   } catch {
     return;
   }
-  const timeout = new Promise<"timeout">((resolve) => setTimeout(() => resolve("timeout"), opts.timeoutMs));
-  const result = await Promise.race([Promise.all(processes.map((proc) => proc.exited)), timeout]);
-  if (result === "timeout") {
+  const exited = await waitForPidsExit(pids, opts.timeoutMs);
+  const alive = pids.filter(isPidAlive);
+  if (!exited || alive.length > 0) {
     try {
-      for (const proc of processes) proc.kill("SIGKILL");
+      for (const pid of alive) killPid(pid, "SIGKILL");
     } catch {}
-    await Promise.all(processes.map((proc) => proc.exited.catch(() => {})));
+    await waitForPidsExit(alive, 1_000);
+    await Promise.race([
+      Promise.all(processes.map((proc) => proc.exited.catch(() => {}))),
+      Bun.sleep(1_000),
+    ]);
   }
 }
+
+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 killPid(pid: number, signal: "SIGTERM" | "SIGKILL"): void {
+  try {
+    process.kill(pid, signal);
+  } catch {}
+}
+
+function isPidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function waitForPidsExit(pids: number[], timeoutMs: number): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!pids.some(isPidAlive)) return true;
+    await Bun.sleep(100);
+  }
+  return !pids.some(isPidAlive);
+}