agent-relay-runner 0.117.0 → 0.118.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.117.0",
+  "version": "0.118.0",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -21,7 +21,7 @@
   },
   "dependencies": {
     "agent-relay-providers": "0.104.1",
-    "agent-relay-sdk": "0.2.99",
+    "agent-relay-sdk": "0.2.100",
     "callmux": "0.23.0"
   },
   "devDependencies": {

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.117.0",
+  "version": "0.118.0",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/adapters/claude.ts

@@ -1,11 +1,11 @@
 import { chmodSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { homedir, tmpdir } from "node:os";
-import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
 import { type Message } from "agent-relay-sdk";
+import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 import { shellEscape as shellQuote } from "agent-relay-sdk/shell-utils";
 import { tmuxCommand, tmuxHasSession } from "agent-relay-sdk/tmux-utils";
-import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 import { profileAllowsRelayFeature, type ManagedProcess, type ProviderAdapter, type ProviderConfig, type ProviderStatusUpdate, type RunnerSpawnConfig, type SemanticStatus, type SpawnArgs } from "../adapter";
 import { computeLivenessSignal, type LivenessInputs } from "../liveness";
 import type { LivenessSignal } from "agent-relay-sdk";
@@ -17,6 +17,7 @@ import { claudeProviderMessageText } from "./claude-delivery";
 import { claudeProbeActivity, readManagedClaudeStatus, resolveClaudePid, type ClaudeProbeActivity } from "./claude-session-probe";
 import { evaluateClaudePromptGatePane, initialClaudePromptGatePaneState, type ClaudePromptGatePaneState } from "../claude-prompt-gates";
 import { claudePaneLooksReady, claudePaneIsBusy, claudeRateLimitStatus, claudeConnectionRetryStatus, claudeModelUnavailableStatus } from "./claude-status-detectors";
+import { launcherScriptPathForSession } from "../session-scratch";
 
 export class ClaudeAdapter implements ProviderAdapter {
   readonly provider = "claude";
@@ -346,7 +347,7 @@ export class ClaudeAdapter implements ProviderAdapter {
   }
 
   private async spawnHeadless(config: RunnerSpawnConfig, spawnArgs: SpawnArgs): Promise<ManagedProcess> {
-    const { sessionName, socketName, args: tmuxArgs } = this.buildTmuxArgs(config, spawnArgs);
+    const { sessionName, socketName, args: tmuxArgs, launcherScript } = this.buildTmuxArgs(config, spawnArgs);
     this.modelUnavailableReported = false;
     this.connectionRetryActive = false;
     this.promptGatePaneState = initialClaudePromptGatePaneState();
@@ -385,6 +386,7 @@ export class ClaudeAdapter implements ProviderAdapter {
         monitorless: !profileAllowsRelayFeature(config, "plugins"),
         tmuxSession: sessionName,
         tmuxSocket: socketName,
+        launcherScript,
       },
     };
   }
@@ -604,13 +606,9 @@ async function submitTextToTmux(sessionName: string, text: string, socketName?:
   }
 }
 
-const LAUNCHER_DIR = join(tmpdir(), `agent-relay-launchers-${typeof process.getuid === "function" ? process.getuid() : "user"}`);
-
 function writeLauncherScript(sessionName: string, env: Record<string, string>, shellCmd: string): string {
-  mkdirSync(LAUNCHER_DIR, { recursive: true, mode: 0o700 });
-  chmodSync(LAUNCHER_DIR, 0o700);
-  const sanitized = sanitizeFsName(sessionName, { replacement: "-", collapse: false });
-  const scriptPath = join(LAUNCHER_DIR, `${sanitized}.sh`);
+  const scriptPath = launcherScriptPathForSession(sessionName);
+  const launcherDir = dirname(scriptPath); mkdirSync(launcherDir, { recursive: true, mode: 0o700 }); chmodSync(launcherDir, 0o700);
   const exports = Object.entries(env)
     .map(([key, value]) => `export ${shellEnvKey(key)}=${shellQuote(value)}`)
     .join("\n");

package/src/runner-core.ts

@@ -23,7 +23,7 @@ import { RELAY_MCP_TOKEN_ENV, relayMcpEndpoint, resolveSharedMcpUrl } from "./re
 import { RelayMcpProxy } from "./relay-mcp-proxy";
 import { runtimeMetadata } from "./version";
 import { logger, parseLogLevel } from "./logger";
-import { ensureSessionScratch, reapSessionScratch, sweepStaleSessions, type SessionScratchLayout } from "./session-scratch";
+import { ensureSessionScratch, reapSessionLauncher, reapSessionScratch, sweepStaleLaunchers, sweepStaleSessions, type SessionScratchLayout } from "./session-scratch";
 import { deliverBufferedMcpCall as deliverBufferedMcpOutboxCall, deliverRunnerOutboxEvent } from "./mcp-outbox";
 import { RunnerInsights } from "./runner-insights";
 import { BusyReconciler } from "./busy-reconciler";
@@ -466,11 +466,9 @@ export class AgentRunner {
   async stop(): Promise<void> {
     const alreadyStopped = this.stopped;
     this.stopped = true;
-    reapSessionScratch({
-      agentId: this.agentId,
-      cwd: this.options.cwd,
-      fallbackBaseDir: orchestratorBaseDirFromEnv(),
-    });
+    const launcherScript = typeof this.process?.meta?.launcherScript === "string" ? this.process.meta.launcherScript : undefined; const tmuxSession = typeof this.process?.meta?.tmuxSession === "string" ? this.process.meta.tmuxSession : undefined;
+    reapSessionScratch({ agentId: this.agentId, cwd: this.options.cwd, fallbackBaseDir: orchestratorBaseDirFromEnv() });
+    reapSessionLauncher({ launcherScript, tmuxSession });
     if (!alreadyStopped) await this.bus.statusAsync({ agentStatus: "offline", ready: false });
     if (this.process && !alreadyStopped) {
       await this.options.adapter.shutdown(this.process, {
@@ -2053,15 +2051,15 @@ export class AgentRunner {
   private async sweepStaleScratch(): Promise<void> {
     try {
       const agents = await this.http.listAgents().catch(() => [] as Awaited<ReturnType<RelayHttpClient["listAgents"]>>);
-      const keep = new Set(agents.map((a) => a.id));
-      keep.add(this.agentId);
+      const keep = new Set(agents.map((a) => a.id)); keep.add(this.agentId); const now = Date.now();
       const removed = sweepStaleSessions({
         cwd: this.options.cwd,
         fallbackBaseDir: orchestratorBaseDirFromEnv(),
         keepAgentIds: keep,
-        now: Date.now(),
+        now,
       });
       if (removed.length) this.logRunnerDiagnostic(`swept ${removed.length} stale session scratch dir(s)`);
+      const removedLaunchers = sweepStaleLaunchers({ keepAgentIds: keep, now }); if (removedLaunchers.length) this.logRunnerDiagnostic(`swept ${removedLaunchers.length} stale launcher script(s)`);
     } catch {}
   }
 

package/src/session-scratch.ts

@@ -1,11 +1,15 @@
 import { execFileSync } from "node:child_process";
 import { accessSync, appendFileSync, constants, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
+import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 
 const SCRATCH_DIR_NAME = ".agent-relay";
 // The local-ignore entry. Leading + trailing slash scopes it to the dir at the
 // base, matching git's gitignore semantics.
 const EXCLUDE_ENTRY = "/.agent-relay/";
+const LAUNCHER_DIR = join(tmpdir(), `agent-relay-launchers-${typeof process.getuid === "function" ? process.getuid() : "user"}`);
+const DEFAULT_LAUNCHER_SWEEP_MIN_AGE_MS = 24 * 60 * 60 * 1000;
 
 export interface SessionScratchLayout {
   baseDir: string; // dir that contains .agent-relay (cwd, or fallback base dir)
@@ -25,6 +29,12 @@ interface SessionScratchTarget {
   fallbackBaseDir?: string;
 }
 
+interface SessionLauncherTarget {
+  launcherScript?: string;
+  launcherDir?: string;
+  tmuxSession?: string;
+}
+
 function isWritableDir(dir: string): boolean {
   try {
     if (!statSync(dir).isDirectory()) return false;
@@ -110,6 +120,15 @@ export function ensureSessionScratch(target: SessionScratchTarget): SessionScrat
   return layout;
 }
 
+function resolveLauncherDir(launcherDir?: string): string {
+  return launcherDir ?? LAUNCHER_DIR;
+}
+
+export function launcherScriptPathForSession(sessionName: string, launcherDir?: string): string {
+  const sanitized = sanitizeFsName(sessionName, { replacement: "-", collapse: false });
+  return join(resolveLauncherDir(launcherDir), `${sanitized}.sh`);
+}
+
 function dedupeBases(bases: Array<string | undefined>): string[] {
   const seen = new Set<string>();
   const out: string[] = [];
@@ -121,6 +140,17 @@ function dedupeBases(bases: Array<string | undefined>): string[] {
   return out;
 }
 
+function dedupePaths(paths: Array<string | undefined>): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const path of paths) {
+    if (!path || seen.has(path)) continue;
+    seen.add(path);
+    out.push(path);
+  }
+  return out;
+}
+
 // SessionEnd: remove this session's dir from every candidate base.
 export function reapSessionScratch(target: SessionScratchTarget): void {
   for (const base of dedupeBases([target.cwd, target.fallbackBaseDir])) {
@@ -131,6 +161,24 @@ export function reapSessionScratch(target: SessionScratchTarget): void {
   }
 }
 
+// Claude headless sessions externalize their provider launch command into a
+// per-session script under /tmp. Remove it on runner shutdown alongside the
+// scratch dir reap to avoid leaking one file per spawn.
+export function reapSessionLauncher(target: SessionLauncherTarget): string[] {
+  const removed: string[] = [];
+  for (const path of dedupePaths([
+    target.launcherScript,
+    target.tmuxSession ? launcherScriptPathForSession(target.tmuxSession, target.launcherDir) : undefined,
+  ])) {
+    try {
+      const exists = statSync(path).isFile();
+      rmSync(path, { force: true });
+      if (exists) removed.push(path);
+    } catch {}
+  }
+  return removed;
+}
+
 interface SweepOptions {
   cwd: string;
   fallbackBaseDir?: string;
@@ -141,6 +189,33 @@ interface SweepOptions {
   minAgeMs?: number;
 }
 
+interface LauncherSweepOptions {
+  // Agent ids to keep (currently-known agents + self). Launcher scripts embed
+  // AGENT_RELAY_ID, so a stale sweep can safely remove only scripts whose agent
+  // is no longer live.
+  keepAgentIds: Set<string>;
+  launcherDir?: string;
+  now: number;
+  minAgeMs?: number;
+}
+
+function maybeShellUnquote(value: string): string {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("'") || !trimmed.endsWith("'")) return trimmed;
+  return trimmed.slice(1, -1).replace(/'\\''/g, "'");
+}
+
+function launcherAgentId(scriptPath: string): string | null {
+  try {
+    const match = readFileSync(scriptPath, "utf8").match(/^export AGENT_RELAY_ID=(.+)$/m);
+    if (!match) return null;
+    const agentId = maybeShellUnquote(match[1] ?? "");
+    return agentId || null;
+  } catch {
+    return null;
+  }
+}
+
 // Periodic sweep of leftover session dirs from agents no longer known to the
 // relay. The minAgeMs grace avoids racing a peer that just created its dir but
 // has not yet appeared in the agent list.
@@ -167,3 +242,30 @@ export function sweepStaleSessions(opts: SweepOptions): string[] {
   }
   return removed;
 }
+
+// Periodic sweep of leaked per-spawn launcher scripts. Old scripts whose agent
+// id is no longer live are safe to prune; old unparsable files are treated as
+// stale too so the next run clears historical buildup without manual cleanup.
+export function sweepStaleLaunchers(opts: LauncherSweepOptions): string[] {
+  const minAge = opts.minAgeMs ?? DEFAULT_LAUNCHER_SWEEP_MIN_AGE_MS;
+  const removed: string[] = [];
+  const launcherDir = resolveLauncherDir(opts.launcherDir);
+  let entries: string[];
+  try {
+    entries = readdirSync(launcherDir);
+  } catch {
+    return removed;
+  }
+  for (const entry of entries) {
+    const scriptPath = join(launcherDir, entry);
+    try {
+      if (!statSync(scriptPath).isFile()) continue;
+      if (opts.now - statSync(scriptPath).mtimeMs < minAge) continue;
+      const agentId = launcherAgentId(scriptPath);
+      if (agentId && opts.keepAgentIds.has(agentId)) continue;
+      rmSync(scriptPath, { force: true });
+      removed.push(scriptPath);
+    } catch {}
+  }
+  return removed;
+}