tmux-ide 2.1.5 → 2.6.0

package/src/lib/cast/recorder.ts

@@ -1,148 +0,0 @@
-/**
- * Records tmux pane output in asciicast v2 format.
- *
- * Uses `tmux capture-pane -p -t <paneId>` to snapshot pane content and
- * emits only the delta between snapshots as asciicast event lines.
- *
- * File format (one JSON object per line):
- *   Line 1 (header): {"version":2,"width":W,"height":H,"timestamp":T}
- *   Line 2+:         [elapsed_seconds, "o", "data"]
- *
- * @see https://docs.asciinema.org/manual/asciicast/v2/
- */
-
-import { execFileSync } from "node:child_process";
-import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-export interface RecorderOptions {
-  /** Project directory (recordings go in .tasks/recordings/). */
-  dir: string;
-  /** tmux session name. */
-  session: string;
-  /** tmux pane ID (e.g. %0). */
-  paneId: string;
-  /** Capture interval in ms (default 1000). */
-  intervalMs?: number;
-}
-
-export class AsciicastRecorder {
-  private filePath: string;
-  private timer: ReturnType<typeof setInterval> | null = null;
-  private startTime: number = 0;
-  private lastSnapshot: string = "";
-  private session: string;
-  private paneId: string;
-  private intervalMs: number;
-
-  constructor(opts: RecorderOptions) {
-    this.session = opts.session;
-    this.paneId = opts.paneId;
-    this.intervalMs = opts.intervalMs ?? 1000;
-
-    const recDir = join(opts.dir, ".tasks", "recordings");
-    if (!existsSync(recDir)) mkdirSync(recDir, { recursive: true });
-
-    const ts = new Date().toISOString().replace(/[:.]/g, "-");
-    const safePane = this.paneId.replace(/%/g, "");
-    this.filePath = join(recDir, `${this.session}_${safePane}_${ts}.cast`);
-  }
-
-  /** Start recording. Writes the header and begins periodic captures. */
-  start(): string {
-    const { width, height } = this.getPaneSize();
-    this.startTime = Date.now();
-
-    const header = {
-      version: 2,
-      width,
-      height,
-      timestamp: Math.floor(this.startTime / 1000),
-    };
-    writeFileSync(this.filePath, JSON.stringify(header) + "\n");
-    this.lastSnapshot = "";
-
-    this.timer = setInterval(() => this.capture(), this.intervalMs);
-    this.capture(); // immediate first capture
-
-    return this.filePath;
-  }
-
-  /** Stop recording and flush. */
-  stop(): void {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-    // Final capture
-    this.capture();
-  }
-
-  /** Path to the recording file. */
-  getFilePath(): string {
-    return this.filePath;
-  }
-
-  /** Single capture tick — computes delta and appends event. */
-  private capture(): void {
-    try {
-      const current = execFileSync("tmux", ["capture-pane", "-p", "-t", this.paneId], {
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "ignore"],
-      });
-
-      if (current === this.lastSnapshot) return; // no change
-
-      const elapsed = (Date.now() - this.startTime) / 1000;
-      const delta = this.computeDelta(this.lastSnapshot, current);
-      this.lastSnapshot = current;
-
-      if (delta.length === 0) return;
-
-      const event = JSON.stringify([elapsed, "o", delta]);
-      appendFileSync(this.filePath, event + "\n");
-    } catch {
-      // pane gone or tmux not available — stop silently
-    }
-  }
-
-  /** Compute the new/changed content between two snapshots. */
-  private computeDelta(prev: string, current: string): string {
-    if (prev === "") return current;
-
-    const prevLines = prev.split("\n");
-    const curLines = current.split("\n");
-
-    // Find first differing line
-    let firstDiff = 0;
-    while (
-      firstDiff < prevLines.length &&
-      firstDiff < curLines.length &&
-      prevLines[firstDiff] === curLines[firstDiff]
-    ) {
-      firstDiff++;
-    }
-
-    if (firstDiff >= curLines.length) return "";
-
-    // Return the changed portion with ANSI cursor positioning
-    const changedLines = curLines.slice(firstDiff);
-    const moveToLine = `\x1b[${firstDiff + 1};1H`;
-    return moveToLine + changedLines.join("\n");
-  }
-
-  /** Get pane dimensions from tmux. */
-  private getPaneSize(): { width: number; height: number } {
-    try {
-      const raw = execFileSync(
-        "tmux",
-        ["display-message", "-p", "-t", this.paneId, "#{pane_width}\t#{pane_height}"],
-        { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] },
-      ).trim();
-      const [w, h] = raw.split("\t");
-      return { width: parseInt(w!, 10) || 80, height: parseInt(h!, 10) || 24 };
-    } catch {
-      return { width: 80, height: 24 };
-    }
-  }
-}

package/src/lib/daemon-watchdog.ts

@@ -1,102 +0,0 @@
-/**
- * Minimal crash-recovery watchdog for the tmux-ide daemon.
- * Respawns daemon.ts on unexpected exits with exponential backoff.
- * Gives up after 5 crashes within 60 seconds.
- *
- * Entry: bun src/lib/daemon-watchdog.ts <session> [port]
- *
- * ZERO imports from business logic — this file must never crash
- * due to broken application code.
- */
-
-import { spawn, type ChildProcess } from "node:child_process";
-import { resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { appendFileSync, mkdirSync, existsSync } from "node:fs";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sessionArg = process.argv[2];
-const port = process.argv[3] ?? "0";
-
-if (!sessionArg) {
-  console.error("Usage: daemon-watchdog.ts <session> [port]");
-  process.exit(1);
-}
-
-const session: string = sessionArg;
-
-const daemonScript = resolve(__dirname, "daemon.ts");
-
-let backoffMs = 1000;
-let crashCount = 0;
-let lastCrashTime = 0;
-let child: ChildProcess | null = null;
-
-function logError(msg: string): void {
-  try {
-    const tasksDir = resolve(process.cwd(), ".tasks");
-    if (!existsSync(tasksDir)) mkdirSync(tasksDir, { recursive: true });
-    const entry = JSON.stringify({
-      timestamp: new Date().toISOString(),
-      type: "error",
-      source: "daemon-watchdog",
-      message: msg,
-    });
-    appendFileSync(resolve(tasksDir, "events.log"), entry + "\n");
-  } catch {
-    // If even logging fails, silently continue
-  }
-}
-
-function spawnDaemon(): void {
-  child = spawn("bun", [daemonScript, session, port], {
-    cwd: process.cwd(),
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-
-  // Pipe child stdout/stderr to our own so logs are visible in the detached process
-  child.stdout?.pipe(process.stdout);
-  child.stderr?.pipe(process.stderr);
-
-  child.on("exit", (code) => {
-    child = null;
-
-    // Clean shutdown (code 0) — don't respawn
-    if (code === 0) {
-      process.exit(0);
-    }
-
-    const now = Date.now();
-
-    // Reset crash counter if the last crash was more than 60s ago
-    if (now - lastCrashTime > 60_000) {
-      crashCount = 0;
-      backoffMs = 1000;
-    }
-
-    crashCount++;
-    lastCrashTime = now;
-
-    if (crashCount > 5) {
-      logError(`Daemon crashed ${crashCount} times in 60s — giving up`);
-      process.exit(1);
-    }
-
-    logError(`Daemon exited with code ${code}, respawning in ${backoffMs}ms`);
-    setTimeout(spawnDaemon, backoffMs);
-    backoffMs = Math.min(backoffMs * 2, 30_000);
-  });
-}
-
-// Forward termination signals to the child daemon
-process.on("SIGTERM", () => {
-  if (child) child.kill("SIGTERM");
-  else process.exit(0);
-});
-
-process.on("SIGINT", () => {
-  if (child) child.kill("SIGTERM");
-  else process.exit(0);
-});
-
-spawnDaemon();

package/src/lib/daemon.ts

@@ -1,440 +0,0 @@
-/**
- * Unified tmux-ide daemon — background process that combines:
- * 1. Pane monitor loop (port detection, agent state, title drift)
- * 2. Orchestrator startup (task dispatch, stall detection)
- * 3. Command Center HTTP/WebSocket server
- *
- * Entry: bun src/lib/daemon.ts <session> [port]
- * Spawned as a detached child by launch.ts (via daemon-watchdog.ts).
- */
-
-import { execFileSync } from "node:child_process";
-import { existsSync, readdirSync, statSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
-import { createServer, type Server } from "node:http";
-import { createRequire } from "node:module";
-import { computePortPanes, computeAgentStates } from "./session-monitor.ts";
-
-// Anchor bare-specifier resolution to this file so dependencies like
-// @hono/node-server resolve from tmux-ide's own node_modules regardless
-// of the process's working directory.
-const _require = createRequire(import.meta.url);
-
-/** Remove dispatch files older than 24 hours */
-function cleanupDispatchFiles(dir: string): void {
-  const dispatchDir = join(dir, ".tasks", "dispatch");
-  if (!existsSync(dispatchDir)) return;
-  const cutoff = Date.now() - 24 * 60 * 60 * 1000;
-  try {
-    for (const file of readdirSync(dispatchDir)) {
-      const filePath = join(dispatchDir, file);
-      try {
-        const mtime = statSync(filePath).mtimeMs;
-        if (mtime < cutoff) unlinkSync(filePath);
-      } catch {
-        // skip files we can't stat/delete
-      }
-    }
-  } catch {
-    // dispatch dir unreadable — skip
-  }
-}
-
-const INTERVAL = 1000;
-
-// ---------------------------------------------------------------------------
-// Args
-// ---------------------------------------------------------------------------
-
-const sessionArg = process.argv[2];
-if (!sessionArg) {
-  console.error("Usage: daemon.ts <session> [port]");
-  process.exit(1);
-}
-const session: string = sessionArg;
-const requestedPort = parseInt(process.argv[3] ?? "6060", 10);
-
-// ---------------------------------------------------------------------------
-// tmux helpers (same as session-monitor.ts)
-// ---------------------------------------------------------------------------
-
-interface MonitorPane {
-  id: string;
-  pid: string;
-  cmd?: string;
-  title?: string;
-  role?: string;
-  type?: string;
-  name?: string;
-}
-
-function tmux(...args: string[]): string {
-  return execFileSync("tmux", args, { encoding: "utf-8" }).trim();
-}
-
-function tmuxSilent(...args: string[]): string {
-  try {
-    return tmux(...args);
-  } catch {
-    return "";
-  }
-}
-
-function sessionExists(): boolean {
-  try {
-    tmux("has-session", "-t", session);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function hasClients(): boolean {
-  return tmuxSilent("list-clients").length > 0;
-}
-
-function listPanes(): MonitorPane[] {
-  const raw = tmuxSilent(
-    "list-panes",
-    "-t",
-    session,
-    "-F",
-    "#{pane_id}\t#{pane_pid}\t#{pane_current_command}\t#{pane_title}\t#{@ide_role}\t#{@ide_type}\t#{@ide_name}",
-  );
-  if (!raw) return [];
-  return raw.split("\n").map((line) => {
-    const [id, pid, cmd, title, role, type, name] = line.split("\t");
-    return {
-      id: id!,
-      pid: pid!,
-      cmd,
-      title,
-      role: role || undefined,
-      type: type || undefined,
-      name: name || undefined,
-    };
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Forward declarations for shutdown — must be initialised before tick() runs
-// because tick() may call shutdown() synchronously on the first invocation.
-// ---------------------------------------------------------------------------
-
-let stopOrchestrator: (() => void) | null = null;
-let httpServer: Server | null = null;
-
-// ---------------------------------------------------------------------------
-// Monitor loop
-// ---------------------------------------------------------------------------
-
-let lastState = "";
-
-function tick(): void {
-  if (!sessionExists()) {
-    shutdown();
-    return;
-  }
-  if (!hasClients()) return; // skip when nobody is watching
-
-  const panes = listPanes();
-  if (panes.length === 0) return;
-
-  const portPanes = computePortPanes(panes);
-  const agentStates = computeAgentStates(panes);
-
-  // Build state fingerprint for change detection (includes title drift)
-  const stateKey = panes
-    .map((p) => {
-      const port = portPanes.has(p.id) ? "1" : "0";
-      const agent = agentStates.get(p.id) ?? "-";
-      const titleDrift = p.name && p.title !== p.name ? "d" : "ok";
-      return `${p.id}:${port}:${agent}:${titleDrift}`;
-    })
-    .join("|");
-
-  if (stateKey === lastState) return;
-
-  // Apply changes
-  for (const pane of panes) {
-    const hasPort = portPanes.has(pane.id) ? "1" : "0";
-    const agent = agentStates.get(pane.id);
-
-    tmuxSilent("set-option", "-pqt", pane.id, "@has_port", hasPort);
-    tmuxSilent("set-option", "-pqt", pane.id, "@agent_busy", agent === "busy" ? "1" : "0");
-    tmuxSilent("set-option", "-pqt", pane.id, "@agent_idle", agent === "idle" ? "1" : "0");
-
-    // Restore configured pane title if Claude Code changed it
-    if (pane.name && pane.title !== pane.name) {
-      tmuxSilent("select-pane", "-t", pane.id, "-T", pane.name);
-    }
-  }
-
-  // Agent idle notifications removed — the orchestrator's completion
-  // handler already notifies the lead pane with task context when a
-  // task finishes. Raw busy→idle transitions from the monitor loop
-  // fired on spinner gaps between tool calls, spamming the lead.
-
-  tmuxSilent("refresh-client", "-S");
-  lastState = stateKey;
-}
-
-// NOTE: monitor loop is started AFTER the command center and orchestrator
-// are kicked off (see bottom of file) so that a slow lsof/ps inside tick()
-// cannot block the HTTP server from binding its port.
-
-// ---------------------------------------------------------------------------
-// Orchestrator (if enabled in ide.yml)
-// ---------------------------------------------------------------------------
-
-async function startOrchestrator(): Promise<void> {
-  try {
-    const { readConfig } = await import("./yaml-io.ts");
-    const { config } = readConfig(process.cwd());
-
-    if (!config.orchestrator?.enabled) return;
-
-    try {
-      const { createOrchestrator } = await import("./orchestrator.ts");
-
-      // Configure webhooks for event delivery
-      if (config.orchestrator.webhooks?.length) {
-        const { setWebhookConfig } = await import("./event-log.ts");
-        setWebhookConfig(config.orchestrator.webhooks);
-      }
-
-      const orch = config.orchestrator;
-
-      // Build pane specialty map from ide.yml config
-      const paneSpecialties = new Map<string, string[]>();
-      for (const row of config.rows) {
-        for (const pane of row.panes) {
-          if (pane.specialty && pane.title) {
-            paneSpecialties.set(
-              pane.title,
-              pane.specialty.split(",").map((s: string) => s.trim().toLowerCase()),
-            );
-          }
-        }
-      }
-
-      // Clean up stale dispatch files on startup
-      cleanupDispatchFiles(process.cwd());
-
-      stopOrchestrator = createOrchestrator({
-        session,
-        dir: process.cwd(),
-        autoDispatch: orch.auto_dispatch ?? true,
-        stallTimeout: orch.stall_timeout ?? 300000,
-        pollInterval: orch.poll_interval ?? 5000,
-        masterPane: orch.master_pane ?? null,
-        beforeRun: orch.before_run ?? null,
-        afterRun: orch.after_run ?? null,
-        maxConcurrentAgents: orch.max_concurrent_agents ?? 10,
-        dispatchMode: orch.dispatch_mode ?? "tasks",
-        paneSpecialties,
-        services:
-          (orch.services as Record<
-            string,
-            { command: string; port?: number; healthcheck?: string }
-          >) ?? {},
-        research: orch.research,
-      });
-    } catch {
-      // Orchestrator module not available yet
-    }
-  } catch {
-    // Config not readable — skip orchestrator
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Command Center HTTP + WebSocket server
-// ---------------------------------------------------------------------------
-
-async function startCommandCenter(): Promise<void> {
-  try {
-    const { createApp } = await import("../command-center/server.ts");
-    const { getRequestListener } = await import(_require.resolve("@hono/node-server"));
-    const { AuthService } = await import("./auth/auth-service.ts");
-    const { AuthConfigSchema } = await import("./auth/types.ts");
-    const { TunnelManager } = await import("./tunnels/manager.ts");
-    const { RemoteRegistry } = await import("./hq/registry.ts");
-    const { HQConfigSchema } = await import("./hq/types.ts");
-
-    // Load auth + tunnel + hq config from ide.yml
-    let authConfig = AuthConfigSchema.parse({});
-    let authService: InstanceType<typeof AuthService> | undefined;
-    let tunnelConfig: Record<string, unknown> | undefined;
-    let hqConfig: ReturnType<typeof HQConfigSchema.parse> | undefined;
-    try {
-      const { readConfig } = await import("./yaml-io.ts");
-      const { config } = readConfig(process.cwd());
-      if (config.auth) {
-        authConfig = AuthConfigSchema.parse(config.auth);
-      }
-      if (config.tunnel) {
-        tunnelConfig = config.tunnel as Record<string, unknown>;
-      }
-      if (config.hq) {
-        hqConfig = HQConfigSchema.parse(config.hq);
-      }
-    } catch {
-      // Config not readable — use defaults
-    }
-    authService = new AuthService(authConfig.secret);
-    const tunnelManager = new TunnelManager({ session, dir: process.cwd() });
-
-    // Start HQ registry if role is "hq"
-    let remoteRegistry: InstanceType<typeof RemoteRegistry> | undefined;
-    if (hqConfig?.enabled && hqConfig.role === "hq") {
-      let _isShuttingDown = false;
-      remoteRegistry = new RemoteRegistry({
-        healthInterval: hqConfig.heartbeat_interval,
-        isShuttingDown: () => _isShuttingDown,
-      });
-      // Wire shutdown flag
-      const origShutdown = shutdown;
-      const shutdownWithRegistry = () => {
-        _isShuttingDown = true;
-        remoteRegistry?.destroy();
-        origShutdown();
-      };
-      process.removeListener("SIGTERM", shutdown);
-      process.removeListener("SIGINT", shutdown);
-      process.on("SIGTERM", shutdownWithRegistry);
-      process.on("SIGINT", shutdownWithRegistry);
-      console.log("[daemon] HQ registry started");
-    }
-
-    const app = createApp({ authService, authConfig, tunnelManager, remoteRegistry });
-
-    // Health endpoint for watchdog and external probes
-    app.get("/health", (c: { json: (body: unknown, status?: number) => Response }) => {
-      return c.json({ ok: true, session, uptime: process.uptime() });
-    });
-
-    const listener = getRequestListener(app.fetch);
-    const server = createServer(listener);
-
-    const bindRequestedPort = (port: number): Promise<boolean> =>
-      new Promise<boolean>((res, rej) => {
-        server.once("error", (err: NodeJS.ErrnoException) => {
-          if (err.code === "EADDRINUSE") {
-            server.removeAllListeners("error");
-            res(false);
-          } else {
-            rej(err);
-          }
-        });
-        server.listen(port, "0.0.0.0", () => {
-          tmuxSilent("set-option", "-t", session, "@command_center_port", String(port));
-          console.log(`[daemon] Command Center on http://0.0.0.0:${port} (session: ${session})`);
-          res(true);
-        });
-      });
-
-    const commandCenterStarted = await bindRequestedPort(requestedPort);
-    if (commandCenterStarted) {
-      httpServer = server;
-    } else {
-      // Port is in use — check if it's another tmux-ide command center we can share
-      try {
-        const res = await fetch(`http://localhost:${requestedPort}/health`, {
-          signal: AbortSignal.timeout(2000),
-        });
-        if (res.ok) {
-          // Another tmux-ide command center is running — store its port so
-          // status/health checks work for this session too
-          tmuxSilent("set-option", "-t", session, "@command_center_port", String(requestedPort));
-          console.log(
-            `[daemon] Sharing Command Center on port ${requestedPort} from another session`,
-          );
-        } else {
-          console.error(
-            `[daemon] Port ${requestedPort} is in use by a non-tmux-ide service; no dashboard for this session`,
-          );
-        }
-      } catch {
-        console.error(
-          `[daemon] Port ${requestedPort} is in use but not responding; no dashboard for this session`,
-        );
-      }
-    }
-
-    // Auto-start tunnel if configured
-    if (commandCenterStarted && tunnelConfig && tunnelConfig.auto_start) {
-      try {
-        const { tunnelConfigSchema } = await import("./tunnels/types.ts");
-        const parsed = tunnelConfigSchema.parse({
-          ...tunnelConfig,
-          port: tunnelConfig.port ?? requestedPort,
-        });
-        await tunnelManager.start(parsed);
-        console.log("[daemon] Tunnel auto-started");
-      } catch (err) {
-        console.error("[daemon] Tunnel auto-start failed:", err);
-      }
-    }
-
-    // Auto-start HQ client if role is "remote"
-    if (
-      commandCenterStarted &&
-      hqConfig?.enabled &&
-      hqConfig.role === "remote" &&
-      hqConfig.hq_url
-    ) {
-      try {
-        const { HQClient } = await import("./hq/client.ts");
-        const os = await import("node:os");
-        const hqClient = new HQClient({
-          hqUrl: hqConfig.hq_url,
-          secret: hqConfig.secret ?? "",
-          machineName: hqConfig.machine_name ?? os.hostname(),
-          remoteUrl: `http://localhost:${requestedPort}`,
-          heartbeatInterval: hqConfig.heartbeat_interval,
-        });
-        await hqClient.register();
-        console.log(`[daemon] Registered with HQ as ${hqClient.getName()}`);
-
-        // Deregister on shutdown
-        const origShutdownFn = shutdown;
-        process.removeListener("SIGTERM", shutdown);
-        process.removeListener("SIGINT", shutdown);
-        const shutdownWithHQ = async () => {
-          await hqClient.destroy();
-          origShutdownFn();
-        };
-        process.on("SIGTERM", () => void shutdownWithHQ());
-        process.on("SIGINT", () => void shutdownWithHQ());
-      } catch (err) {
-        console.error("[daemon] HQ client registration failed:", err);
-      }
-    }
-  } catch (err) {
-    // Command center failed but daemon continues (monitor + orchestrator still work)
-    console.error("[daemon] Command Center failed to start:", err);
-  }
-}
-
-void startCommandCenter();
-void startOrchestrator();
-
-// Start the monitor loop last — tick() uses execFileSync (lsof, ps) which
-// can block the event loop for seconds if the system is under load.
-const monitorInterval = setInterval(tick, INTERVAL);
-tick();
-
-// ---------------------------------------------------------------------------
-// Unified shutdown
-// ---------------------------------------------------------------------------
-
-function shutdown(): void {
-  clearInterval(monitorInterval);
-  if (stopOrchestrator) stopOrchestrator();
-  if (httpServer) httpServer.close();
-  process.exit(0);
-}
-
-process.on("SIGTERM", shutdown);
-process.on("SIGINT", shutdown);