tmux-ide 1.3.1 → 2.1.0

package/src/lib/daemon.ts

@@ -0,0 +1,439 @@
+/**
+ * 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 { computePortPanes, computeAgentStates } from "./session-monitor.ts";
+
+/** 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,
+    };
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Monitor loop
+// ---------------------------------------------------------------------------
+
+let lastState = "";
+let prevAgentStates = new Map<string, "busy" | "idle" | null>();
+let monitorInitialized = false;
+
+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);
+    }
+  }
+
+  // Notify master pane when an agent transitions from busy → idle
+  if (monitorInitialized) {
+    const masterPane = panes.find((p) => p.role === "lead");
+    if (masterPane) {
+      for (const pane of panes) {
+        const prev = prevAgentStates.get(pane.id);
+        const curr = agentStates.get(pane.id);
+        if (prev === "busy" && curr === "idle" && pane.id !== masterPane.id) {
+          const label = pane.name ?? pane.title ?? pane.id;
+          tmuxSilent("send-keys", "-t", masterPane.id, `Agent "${label}" is now idle`, "Enter");
+        }
+      }
+    }
+  }
+  monitorInitialized = true;
+  prevAgentStates = agentStates;
+
+  tmuxSilent("refresh-client", "-S");
+  lastState = stateKey;
+}
+
+const monitorInterval = setInterval(tick, INTERVAL);
+tick(); // run immediately
+
+// ---------------------------------------------------------------------------
+// Orchestrator (if enabled in ide.yml)
+// ---------------------------------------------------------------------------
+
+let stopOrchestrator: (() => void) | null = null;
+
+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
+  }
+}
+
+void startOrchestrator();
+
+// ---------------------------------------------------------------------------
+// Command Center HTTP + WebSocket server
+// ---------------------------------------------------------------------------
+
+let httpServer: Server | null = null;
+
+async function startCommandCenter(): Promise<void> {
+  try {
+    const { createApp } = await import("../command-center/server.ts");
+    const { getRequestListener } = await import("@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();
+
+// ---------------------------------------------------------------------------
+// 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);

package/src/lib/dot-path.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from "bun:test";
+import { getByPath, setByPath } from "./dot-path.ts";
+
+describe("getByPath", () => {
+  it("gets a top-level key", () => {
+    expect(getByPath({ name: "test" }, "name")).toBe("test");
+  });
+
+  it("gets a nested value", () => {
+    const obj = { rows: [{ panes: [{ title: "Shell" }] }] };
+    expect(getByPath(obj, "rows.0.panes.0.title")).toBe("Shell");
+  });
+
+  it("returns undefined for non-existent path", () => {
+    expect(getByPath({}, "a.b.c")).toBe(undefined);
+  });
+
+  it("returns undefined for partially valid path", () => {
+    expect(getByPath({ a: { b: 1 } }, "a.b.c")).toBe(undefined);
+  });
+});
+
+describe("setByPath", () => {
+  it("sets a top-level key", () => {
+    const obj = {};
+    setByPath(obj, "name", "test");
+    expect(obj).toEqual({ name: "test" });
+  });
+
+  it("sets a nested value", () => {
+    const obj = { rows: [{ panes: [{ title: "old" }] }] };
+    setByPath(obj, "rows.0.panes.0.title", "new");
+    expect(obj.rows[0].panes[0].title).toBe("new");
+  });
+
+  it("creates arrays for numeric keys", () => {
+    const obj = {};
+    setByPath(obj, "rows.0.title", "test");
+    expect(Array.isArray(obj.rows)).toBeTruthy();
+    expect(obj.rows[0].title).toBe("test");
+  });
+
+  it("creates objects for string keys", () => {
+    const obj = {};
+    setByPath(obj, "a.b.c", "val");
+    expect(obj).toEqual({ a: { b: { c: "val" } } });
+  });
+
+  it("handles duplicate segment values (regression)", () => {
+    // Bug: rows.0.panes.0 — both "0" segments caused indexOf to return
+    // the same index, breaking the lookahead for array vs object creation
+    const obj = {};
+    setByPath(obj, "rows.0.panes.0", "value");
+    expect(Array.isArray(obj.rows)).toBeTruthy();
+    expect(Array.isArray(obj.rows[0].panes)).toBeTruthy();
+    expect(obj.rows[0].panes[0]).toBe("value");
+  });
+
+  it("handles deeper duplicate segments", () => {
+    const obj = {};
+    setByPath(obj, "a.0.b.0.c", "deep");
+    expect(Array.isArray(obj.a)).toBeTruthy();
+    expect(Array.isArray(obj.a[0].b)).toBeTruthy();
+    expect(obj.a[0].b[0].c).toBe("deep");
+  });
+});

package/src/lib/dot-path.ts

@@ -0,0 +1,17 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export function getByPath(obj: Record<string, any>, path: string): unknown {
+  return path.split(".").reduce((o: any, k) => o?.[k], obj);
+}
+
+export function setByPath(obj: Record<string, any>, path: string, value: unknown): void {
+  const keys = path.split(".");
+  const last = keys.pop()!;
+  let i = 0;
+  const target = keys.reduce((o: any, k) => {
+    const nextKey = keys[i + 1] ?? last;
+    if (o[k] === undefined) o[k] = /^\d+$/.test(nextKey) ? [] : {};
+    i++;
+    return o[k];
+  }, obj);
+  target[last] = value;
+}

package/src/lib/errors.ts

@@ -0,0 +1,44 @@
+export class IdeError extends Error {
+  code: string | undefined;
+  exitCode: number;
+
+  constructor(
+    message: string,
+    { code, exitCode = 1, cause }: { code?: string; exitCode?: number; cause?: Error } = {},
+  ) {
+    super(message, { cause });
+    this.name = "IdeError";
+    this.code = code;
+    this.exitCode = exitCode;
+  }
+
+  toJSON(): { error: string; code: string | undefined; cause?: string } {
+    const obj: { error: string; code: string | undefined; cause?: string } = {
+      error: this.message,
+      code: this.code,
+    };
+    if (this.cause) obj.cause = (this.cause as Error).message;
+    return obj;
+  }
+}
+
+export class ConfigError extends IdeError {
+  constructor(message: string, code: string, { cause }: { cause?: Error } = {}) {
+    super(message, { code, exitCode: 1, cause });
+    this.name = "ConfigError";
+  }
+}
+
+export class TmuxError extends IdeError {
+  constructor(message: string, code: string, { cause }: { cause?: Error } = {}) {
+    super(message, { code, exitCode: 1, cause });
+    this.name = "TmuxError";
+  }
+}
+
+export class SessionError extends IdeError {
+  constructor(message: string, code: string, { cause }: { cause?: Error } = {}) {
+    super(message, { code, exitCode: 1, cause });
+    this.name = "SessionError";
+  }
+}