agent-relay-orchestrator 0.65.2 → 0.67.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.65.2",
+  "version": "0.67.0",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.42"
+    "agent-relay-sdk": "0.2.43"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/config.ts

@@ -62,6 +62,14 @@ export function workspaceDepsMode(): string {
   return (process.env.AGENT_RELAY_WORKSPACE_DEPS || "symlink").toLowerCase();
 }
 
+export function tmuxSocketSweepEnabled(): boolean {
+  return process.env.AGENT_RELAY_TMUX_SOCKET_SWEEP !== "0";
+}
+
+export function tmuxSocketSweepIntervalMs(): number {
+  return envNonNegativeMax("AGENT_RELAY_TMUX_SOCKET_SWEEP_INTERVAL_MS", 10 * 60 * 1000, 60_000);
+}
+
 export const TERMINAL_FLUSH_MS = envNonNegativeMax("AGENT_RELAY_TERMINAL_FLUSH_MS", 6, 0);
 export const TERMINAL_FLUSH_MAX_BYTES = envNonNegativeMax("AGENT_RELAY_TERMINAL_FLUSH_MAX_BYTES", 65536, 4096);
 export const TERMINAL_BACKPRESSURE_MAX_BYTES = envNonNegativeMax("AGENT_RELAY_TERMINAL_BACKPRESSURE_MAX_BYTES", 8 << 20, 1 << 20);

package/src/index.ts

@@ -8,6 +8,7 @@ import { startApiServer } from "./api";
 import { recoverManagedAgents } from "./recovery";
 import { ProviderProbeCache } from "./provider-probe";
 import { sweepEmptyWorkspaceContainers, workspacesRoot } from "./workspace-probe";
+import { startOrchestratorMaintenanceScheduler } from "./maintenance";
 
 const args = process.argv.slice(2);
 
@@ -78,6 +79,9 @@ async function startup(): Promise<void> {
   // Recover existing tmux sessions
   await recoverManagedAgents(config, control, relay);
 
+  // Host-local maintenance must run where the agent processes and tmux sockets live.
+  startOrchestratorMaintenanceScheduler();
+
   // Sweep empty workspace container dirs left behind by prior cleanups (#280).
   const swept = sweepEmptyWorkspaceContainers(workspacesRoot(config.baseDir));
   if (swept.length > 0) console.error(`[orchestrator] Swept ${swept.length} empty workspace container(s)`);

package/src/maintenance.ts

@@ -0,0 +1,51 @@
+import { tmuxSocketSweepEnabled, tmuxSocketSweepIntervalMs } from "./config";
+import { sweepStaleTmuxSockets } from "./tmux-socket-sweeper";
+
+interface OrchestratorMaintenanceJobDefinition {
+  id: string;
+  title: string;
+  intervalMs: number;
+  runOnStart: boolean;
+  handler(): unknown;
+}
+
+let started = false;
+const timers: Timer[] = [];
+
+export const definitions: OrchestratorMaintenanceJobDefinition[] = [
+  {
+    id: "tmux-socket-sweep",
+    title: "Tmux socket sweep",
+    intervalMs: tmuxSocketSweepIntervalMs(),
+    runOnStart: true,
+    handler() {
+      const result = sweepStaleTmuxSockets();
+      if (result.scanned > 0 || result.failed.length > 0) {
+        console.error(
+          `[orchestrator] Tmux socket sweep: removed=${result.removed} kept=${result.kept} scanned=${result.scanned} dir=${result.dir}`,
+        );
+      }
+      for (const failure of result.failed) {
+        console.error(`[orchestrator] Tmux socket sweep failed for ${failure.socket}: ${failure.error}`);
+      }
+      return result;
+    },
+  },
+];
+
+export function startOrchestratorMaintenanceScheduler(): void {
+  if (started || !tmuxSocketSweepEnabled()) return;
+  started = true;
+  for (const definition of definitions) {
+    if (definition.runOnStart) void runJob(definition);
+    timers.push(setInterval(() => void runJob(definition), definition.intervalMs));
+  }
+}
+
+async function runJob(definition: OrchestratorMaintenanceJobDefinition): Promise<void> {
+  try {
+    await Promise.resolve(definition.handler());
+  } catch (error) {
+    console.error(`[orchestrator] Maintenance job ${definition.id} failed: ${error}`);
+  }
+}

package/src/tmux-socket-sweeper.ts

@@ -0,0 +1,65 @@
+import { existsSync, lstatSync, readdirSync, rmSync } from "node:fs";
+import { basename, join } from "node:path";
+import { tmuxCommand } from "agent-relay-sdk/tmux-utils";
+
+const SOCKET_PREFIX = "agent-relay-";
+
+interface TmuxSocketSweepResult {
+  dir: string;
+  scanned: number;
+  removed: number;
+  kept: number;
+  failed: Array<{ socket: string; error: string }>;
+}
+
+export function tmuxSocketDir(env: NodeJS.ProcessEnv = process.env): string {
+  const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+  const tmuxTmp = env.TMUX_TMPDIR?.trim();
+  if (!tmuxTmp) return `/tmp/tmux-${uid}`;
+  return basename(tmuxTmp) === `tmux-${uid}` ? tmuxTmp : join(tmuxTmp, `tmux-${uid}`);
+}
+
+export function sweepStaleTmuxSockets(input: { dir?: string; env?: NodeJS.ProcessEnv } = {}): TmuxSocketSweepResult {
+  const dir = input.dir ?? tmuxSocketDir(input.env);
+  const result: TmuxSocketSweepResult = { dir, scanned: 0, removed: 0, kept: 0, failed: [] };
+  if (!existsSync(dir)) return result;
+
+  for (const entry of readdirSync(dir)) {
+    if (!entry.startsWith(SOCKET_PREFIX)) continue;
+    const path = join(dir, entry);
+    let removable = false;
+    try {
+      const stat = lstatSync(path);
+      removable = stat.isSocket() || stat.isFile();
+    } catch (error) {
+      result.failed.push({ socket: entry, error: String(error) });
+      continue;
+    }
+    if (!removable) continue;
+
+    result.scanned += 1;
+    if (tmuxSocketHasLiveServer(entry, input.env)) {
+      result.kept += 1;
+      continue;
+    }
+
+    try {
+      rmSync(path, { force: true });
+      result.removed += 1;
+    } catch (error) {
+      result.failed.push({ socket: entry, error: String(error) });
+    }
+  }
+
+  return result;
+}
+
+function tmuxSocketHasLiveServer(socketName: string, env?: NodeJS.ProcessEnv): boolean {
+  const result = Bun.spawnSync(tmuxCommand(socketName, "list-sessions"), {
+    stdin: "ignore",
+    stdout: "ignore",
+    stderr: "ignore",
+    ...(env ? { env } : {}),
+  });
+  return result.exitCode === 0;
+}