agent-relay-orchestrator 0.10.19 → 0.10.21

package/src/tmux.ts

@@ -1,298 +0,0 @@
-import { existsSync } from "node:fs";
-import { homedir } from "node:os";
-import { isAbsolute, join, relative, resolve } from "node:path";
-import type { OrchestratorConfig } from "./config";
-import type { ManagedAgentReport } from "./relay";
-
-export interface SpawnOptions {
-  provider: "claude" | "codex";
-  cwd: string;
-  label?: string;
-  agentId?: string;
-  approvalMode: string;
-  prompt?: string;
-  env?: Record<string, string>;
-  tags?: string[];
-  capabilities?: string[];
-  providerArgs?: string[];
-  policyName?: string;
-  spawnRequestId?: string;
-  tmuxSession?: string;
-}
-
-export interface TmuxSession {
-  name: string;
-  pid: number;
-  attached: boolean;
-}
-
-export function isWithinBaseDir(path: string, baseDir: string): boolean {
-  const base = resolve(baseDir);
-  const target = resolve(path);
-  const rel = relative(base, target);
-  return rel === "" || (!!rel && !rel.startsWith("..") && !isAbsolute(rel));
-}
-
-export function sessionName(config: OrchestratorConfig, provider: string, label: string): string {
-  const clean = label.replace(/[^a-zA-Z0-9._-]+/g, "-").toLowerCase();
-  return `${config.tmuxPrefix}-${provider}-${clean}`;
-}
-
-export async function listTmuxSessions(prefix: string): Promise<TmuxSession[]> {
-  try {
-    const proc = Bun.spawn(["tmux", "list-sessions", "-F", "#{session_name}\t#{pid}\t#{session_attached}"], {
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    const out = await new Response(proc.stdout).text();
-    const code = await proc.exited;
-    if (code !== 0) return [];
-
-    return out.trim().split("\n").filter(Boolean).map((line) => {
-      const [name, pid, attached] = line.split("\t");
-      return { name: name!, pid: parseInt(pid!, 10), attached: attached === "1" };
-    }).filter((s) => s.name.startsWith(`${prefix}-`));
-  } catch {
-    return [];
-  }
-}
-
-export async function hasSession(name: string): Promise<boolean> {
-  const proc = Bun.spawn(["tmux", "has-session", "-t", name], {
-    stdout: "ignore",
-    stderr: "ignore",
-  });
-  return (await proc.exited) === 0;
-}
-
-export function buildRunnerCommand(opts: SpawnOptions, config: OrchestratorConfig): string[] {
-  const repoLauncher = resolve(import.meta.dir, "../../runner/src/index.ts");
-  const launcher = existsSync(repoLauncher)
-    ? ["bun", "run", repoLauncher, opts.provider]
-    : [`${opts.provider}-relay`, opts.provider];
-  const args = [
-    ...launcher,
-    "--headless",
-    "--cwd", opts.cwd,
-    "--relay-url", config.relayUrl,
-    "--approval", opts.approvalMode || "guarded",
-  ];
-  if (opts.label) args.push("--label", opts.label);
-  if (opts.agentId) args.push("--agent-id", opts.agentId);
-  if (opts.prompt) args.push("--prompt", opts.prompt);
-  if (opts.tags?.length) args.push("--tags", opts.tags.join(","));
-  if (opts.capabilities?.length) args.push("--caps", opts.capabilities.join(","));
-  if (opts.providerArgs?.length) args.push("--", ...opts.providerArgs);
-  return [
-    ...args,
-  ];
-}
-
-function buildEnv(opts: SpawnOptions, config: OrchestratorConfig): Record<string, string> {
-  const currentPath = process.env.PATH || "";
-  const extraPaths = [
-    join(homedir(), ".local", "bin"),
-    join(homedir(), ".bun", "bin"),
-    join(homedir(), ".npm-global", "bin"),
-  ];
-  const fullPath = [...extraPaths, ...currentPath.split(":").filter(Boolean)]
-    .filter((v, i, a) => a.indexOf(v) === i)
-    .join(":");
-
-  return {
-    ...process.env as Record<string, string>,
-    ...config.env,
-    ...(opts.env || {}),
-    PATH: fullPath,
-    AGENT_RELAY_URL: config.relayUrl,
-    AGENT_RELAY_APPROVAL: opts.approvalMode || "guarded",
-    AGENT_RELAY_TAGS: [...new Set(["headless", "dashboard-spawned", config.hostname, ...(opts.tags ?? [])])].join(","),
-    AGENT_RELAY_CAPS: [...new Set(opts.capabilities ?? [])].join(","),
-    AGENT_RELAY_CAPABILITIES: [...new Set(opts.capabilities ?? [])].join(","),
-    AGENT_RELAY_HEADLESS: "1",
-    ...(opts.label ? { AGENT_RELAY_LABEL: opts.label } : {}),
-    ...(opts.policyName ? { AGENT_RELAY_POLICY: opts.policyName } : {}),
-    ...(opts.spawnRequestId ? { AGENT_RELAY_SPAWN_REQUEST_ID: opts.spawnRequestId } : {}),
-    ...(opts.tmuxSession ? { AGENT_RELAY_TMUX_SESSION: opts.tmuxSession } : {}),
-    ...(config.token ? { AGENT_RELAY_TOKEN: config.token } : {}),
-  };
-}
-
-export async function spawnAgent(
-  opts: SpawnOptions,
-  config: OrchestratorConfig,
-): Promise<ManagedAgentReport> {
-  const label = opts.label || `${opts.provider}-${Date.now()}`;
-  const agentId = opts.agentId || managedAgentId(config, opts.provider, label);
-  const name = sessionName(config, opts.provider, label);
-  const spawnOpts: SpawnOptions = { ...opts, label, agentId, tmuxSession: name };
-
-  if (!existsSync(opts.cwd)) {
-    throw new Error(`cwd does not exist: ${opts.cwd}`);
-  }
-  if (!isWithinBaseDir(opts.cwd, config.baseDir)) {
-    throw new Error(`cwd must be within base directory: ${config.baseDir}`);
-  }
-
-  const command = buildRunnerCommand(spawnOpts, config);
-
-  const env = buildEnv(spawnOpts, config);
-
-  // Build the env export string for tmux
-  const envExports = Object.entries(env)
-    .filter(([k]) => k === "PATH" || k.startsWith("AGENT_RELAY_") || k.startsWith("CLAUDE_") || k.startsWith("ANTHROPIC_") || k === "GITHUB_TOKEN" || k === "NPM_TOKEN" || k === "HOME" || k === "USER" || k === "SHELL")
-    .map(([k, v]) => `${k}=${shellEscape(v)}`)
-    .join(" ");
-
-  const fullCommand = envExports
-    ? `env ${envExports} ${command.map(shellEscape).join(" ")}`
-    : command.map(shellEscape).join(" ");
-
-  const tmuxArgs = [
-    "tmux", "new-session", "-d",
-    "-s", name,
-    "-c", opts.cwd,
-    fullCommand,
-  ];
-
-  console.error(`[orchestrator] Spawning ${opts.provider} agent: ${name}`);
-  console.error(`[orchestrator]   cwd: ${opts.cwd}`);
-  console.error(`[orchestrator]   command: ${fullCommand}`);
-
-  const proc = Bun.spawn(tmuxArgs, {
-    stdout: "pipe",
-    stderr: "pipe",
-    env,
-  });
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    const stderr = await new Response(proc.stderr).text();
-    throw new Error(`tmux spawn failed (exit ${exitCode}): ${stderr.trim()}`);
-  }
-
-  // Get the PID from tmux
-  const pid = await getSessionPid(name);
-
-  return {
-    agentId,
-    provider: spawnOpts.provider,
-    tmuxSession: name,
-    cwd: spawnOpts.cwd,
-    label,
-    approvalMode: spawnOpts.approvalMode || "guarded",
-    policyName: spawnOpts.policyName,
-    spawnRequestId: spawnOpts.spawnRequestId,
-    pid: pid ?? undefined,
-    startedAt: Date.now(),
-  };
-}
-
-export async function stopSession(name: string, config: OrchestratorConfig, reason: string, graceful = true): Promise<{ stopped: boolean; wasRunning: boolean }> {
-  if (!name.startsWith(`${config.tmuxPrefix}-`)) throw new Error("session is not managed by this orchestrator");
-  const wasRunning = await hasSession(name);
-  if (!wasRunning) return { stopped: false, wasRunning: false };
-  if (graceful) {
-    await Bun.spawn(["tmux", "send-keys", "-t", name, "C-c"], { stdout: "ignore", stderr: "ignore" }).exited;
-    await new Promise((resolve) => setTimeout(resolve, 500));
-  }
-  if (await hasSession(name)) {
-    await Bun.spawn(["tmux", "kill-session", "-t", name], {
-      stdout: "ignore",
-      stderr: "ignore",
-      env: { ...process.env, AGENT_RELAY_STOP_REASON: reason },
-    }).exited;
-  }
-  return { stopped: true, wasRunning };
-}
-
-export async function captureSession(name: string, config: OrchestratorConfig, lines = 100): Promise<{ session: string; lines: string[]; running: boolean }> {
-  if (!name.startsWith(`${config.tmuxPrefix}-`)) throw new Error("session is not managed by this orchestrator");
-  const running = await hasSession(name);
-  if (!running) return { session: name, lines: [], running };
-  const safeLines = Math.min(Math.max(lines, 1), 1000);
-  const proc = Bun.spawn(["tmux", "capture-pane", "-p", "-t", name, "-S", `-${safeLines}`], {
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  const out = await new Response(proc.stdout).text();
-  const code = await proc.exited;
-  if (code !== 0) {
-    const err = await new Response(proc.stderr).text();
-    throw new Error(err.trim() || "tmux capture failed");
-  }
-  return { session: name, lines: out.split("\n").filter(Boolean), running };
-}
-
-function managedAgentId(config: OrchestratorConfig, provider: string, label: string): string {
-  const cleanHost = config.hostname.replace(/[^a-zA-Z0-9._-]+/g, "-").toLowerCase();
-  const cleanLabel = label.replace(/[^a-zA-Z0-9._-]+/g, "-").toLowerCase();
-  return `${cleanHost}-${provider}-${cleanLabel}-${crypto.randomUUID().slice(0, 8)}`;
-}
-
-async function getSessionPid(name: string): Promise<number | null> {
-  try {
-    const proc = Bun.spawn(["tmux", "display-message", "-p", "-t", name, "#{pane_pid}"], {
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    const out = await new Response(proc.stdout).text();
-    const code = await proc.exited;
-    if (code !== 0) return null;
-    const pid = parseInt(out.trim(), 10);
-    return isNaN(pid) ? null : pid;
-  } catch {
-    return null;
-  }
-}
-
-export async function recoverExistingSessions(
-  config: OrchestratorConfig,
-): Promise<ManagedAgentReport[]> {
-  const sessions = await listTmuxSessions(config.tmuxPrefix);
-  const managed: ManagedAgentReport[] = [];
-
-  for (const session of sessions) {
-    // Parse provider and label from session name: "ar-claude-backend" → provider=claude, label=backend
-    const parts = session.name.slice(config.tmuxPrefix.length + 1).split("-");
-    const provider = parts[0] as "claude" | "codex";
-    if (provider !== "claude" && provider !== "codex") continue;
-    const label = parts.slice(1).join("-") || undefined;
-
-    // Get cwd from tmux
-    const cwd = await getSessionCwd(session.name);
-
-    managed.push({
-      agentId: managedAgentId(config, provider, label || session.name),
-      provider,
-      tmuxSession: session.name,
-      cwd: cwd || config.baseDir,
-      label,
-      approvalMode: "guarded",
-      pid: session.pid || undefined,
-      startedAt: Date.now(),
-    });
-
-    console.error(`[orchestrator] Recovered existing session: ${session.name} (${provider}, pid ${session.pid})`);
-  }
-
-  return managed;
-}
-
-async function getSessionCwd(name: string): Promise<string | null> {
-  try {
-    const proc = Bun.spawn(["tmux", "display-message", "-p", "-t", name, "#{pane_current_path}"], {
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    const out = await new Response(proc.stdout).text();
-    const code = await proc.exited;
-    return code === 0 ? out.trim() || null : null;
-  } catch {
-    return null;
-  }
-}
-
-function shellEscape(s: string): string {
-  if (/^[a-zA-Z0-9._\-/:=@]+$/.test(s)) return s;
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}