tmux-ide 2.0.0 → 2.1.1

package/src/launch.ts

@@ -1,6 +1,6 @@
 import { resolve, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { execSync, spawn, type SpawnOptions } from "node:child_process";
+import { execSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { readConfig, getSessionName } from "./lib/yaml-io.ts";
@@ -30,56 +30,6 @@ import { shellEscape } from "./lib/shell.ts";
 import type { IdeConfig, Row, Pane } from "./types.ts";
 
 const DEFAULT_COMMAND_CENTER_PORT = 6060;
-const DEFAULT_DASHBOARD_PORT = 6061;
-
-function packageRoot(): string {
-  return resolve(dirname(fileURLToPath(import.meta.url)), "..");
-}
-
-export function resolveDashboardDir(rootDir = packageRoot()): string | null {
-  const dashboardDir = join(rootDir, "dashboard");
-  return existsSync(join(dashboardDir, "package.json")) ? dashboardDir : null;
-}
-
-export function startDashboard(
-  session: string,
-  apiPort: number,
-  {
-    dashboardPort = DEFAULT_DASHBOARD_PORT,
-    dashboardDir = resolveDashboardDir(),
-    spawnFn = spawn,
-    setVar = setSessionVariable,
-  }: {
-    dashboardPort?: number;
-    dashboardDir?: string | null;
-    spawnFn?: (
-      command: string,
-      args: readonly string[],
-      options: SpawnOptions,
-    ) => { pid?: number; unref: () => void };
-    setVar?: (sessionName: string, name: string, value: string) => void;
-  } = {},
-): string | null {
-  if (!dashboardDir) return null;
-
-  const url = `http://localhost:${dashboardPort}`;
-  const child = spawnFn("pnpm", ["dev", "--port", String(dashboardPort)], {
-    cwd: dashboardDir,
-    detached: true,
-    stdio: "ignore",
-    env: {
-      ...process.env,
-      NEXT_PUBLIC_API_URL: `http://localhost:${apiPort}`,
-    },
-  });
-  child.unref();
-
-  if (child.pid != null) {
-    setVar(session, "@dashboard_pid", String(child.pid));
-  }
-  setVar(session, "@dashboard_url", url);
-  return url;
-}
 
 function stripWidgetPanes(rows: Row[]): Row[] {
   return rows
@@ -230,6 +180,30 @@ function runBeforeHook(command: string | undefined, dir: string): void {
   }
 }
 
+async function waitForDaemon(port: number, maxAttempts = 30, delayMs = 100): Promise<boolean> {
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      const res = await fetch(`http://localhost:${port}/health`);
+      if (res.ok) return true;
+    } catch {
+      // Not ready yet
+    }
+    await new Promise((r) => setTimeout(r, delayMs));
+  }
+  return false;
+}
+
+async function isDaemonAlive(port: number): Promise<boolean> {
+  try {
+    const res = await fetch(`http://localhost:${port}/health`, {
+      signal: AbortSignal.timeout(1000),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
 export async function launch(
   targetDir: string | undefined,
   { json = false, attach = true }: { json?: boolean; attach?: boolean } = {},
@@ -251,22 +225,31 @@ export async function launch(
     const currentHash = configHash(config);
     const storedHash = getSessionVariable(session, "@config_hash");
     const configChanged = Boolean(storedHash && currentHash !== storedHash);
-    const commandCenterUrl = `http://localhost:${config.orchestrator?.port ?? config.command_center?.port ?? DEFAULT_COMMAND_CENTER_PORT}`;
-    const dashboardUrl = getSessionVariable(session, "@dashboard_url");
+    const commandCenterPort =
+      config.orchestrator?.port ?? config.command_center?.port ?? DEFAULT_COMMAND_CENTER_PORT;
+    const commandCenterUrl = `http://localhost:${commandCenterPort}`;
+
+    // Verify daemon is alive, restart if dead
+    const daemonAlive = await isDaemonAlive(commandCenterPort);
+    if (!daemonAlive) {
+      console.log("Daemon not responding — restarting...");
+      const monitorScript = resolve(
+        dirname(fileURLToPath(import.meta.url)),
+        "lib",
+        "daemon-watchdog.ts",
+      );
+      startSessionMonitor(session, monitorScript, commandCenterPort);
+      await waitForDaemon(commandCenterPort);
+    }
 
     if (json) {
-      console.log(
-        JSON.stringify({ session, running: true, configChanged, commandCenterUrl, dashboardUrl }),
-      );
+      console.log(JSON.stringify({ session, running: true, configChanged, commandCenterUrl }));
     } else if (configChanged) {
       console.log(`Session "${session}" is running but ide.yml has changed.`);
       console.log(`Run "tmux-ide restart" to apply changes.`);
     } else {
       console.log(`Session "${session}" is already running. Attaching...`);
-      console.log(`Command Center: ${commandCenterUrl}`);
-      if (dashboardUrl) {
-        console.log(`Dashboard: ${dashboardUrl}`);
-      }
+      console.log(`Dashboard: ${commandCenterUrl}`);
     }
 
     if (attach) {
@@ -348,10 +331,11 @@ export async function launch(
   const commandCenterPort =
     config.orchestrator?.port ?? config.command_center?.port ?? DEFAULT_COMMAND_CENTER_PORT;
   startSessionMonitor(session, monitorScript, commandCenterPort);
-  const dashboardPort = config.dashboard?.port ?? DEFAULT_DASHBOARD_PORT;
-  const dashboardUrl = startDashboard(session, commandCenterPort, {
-    dashboardPort,
-  });
+
+  const daemonReady = await waitForDaemon(commandCenterPort);
+  if (!daemonReady) {
+    console.log("Warning: daemon did not respond to health check within 3s — continuing anyway");
+  }
 
   // Inject master agent prompt and task docs if orchestrator is enabled
   if (config.orchestrator?.enabled) {
@@ -377,10 +361,7 @@ export async function launch(
   console.log(
     `Starting "${session}" (${rows.length} row${rows.length === 1 ? "" : "s"}, ${totalPanes} pane${totalPanes === 1 ? "" : "s"})...`,
   );
-  console.log(`Command Center: http://localhost:${commandCenterPort}`);
-  if (dashboardUrl) {
-    console.log(`Dashboard: ${dashboardUrl}`);
-  }
+  console.log(`Dashboard: http://localhost:${commandCenterPort}`);
 
   // Attach
   if (attach) {

package/src/lib/daemon.ts

@@ -326,7 +326,6 @@ async function startCommandCenter(): Promise<void> {
       new Promise<boolean>((res, rej) => {
         server.once("error", (err: NodeJS.ErrnoException) => {
           if (err.code === "EADDRINUSE") {
-            console.error(`[daemon] Command Center port ${port} is in use; skipping HTTP server`);
             server.removeAllListeners("error");
             res(false);
           } else {
@@ -343,6 +342,29 @@ async function startCommandCenter(): Promise<void> {
     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

package/src/lib/orchestrator.ts

@@ -21,7 +21,7 @@
  *
  * @module orchestrator
  */
-import { execSync, execFileSync } from "node:child_process";
+import { execSync } from "node:child_process";
 import {
   existsSync,
   readFileSync,
@@ -51,7 +51,12 @@ import {
 } from "./task-store.ts";
 import { slugify } from "./slugify.ts";
 import { recordTaskTime } from "./token-tracker.ts";
-import { listSessionPanes, sendCommand, type PaneInfo } from "../widgets/lib/pane-comms.ts";
+import {
+  listSessionPanes,
+  sendCommand,
+  captureLastLine,
+  type PaneInfo,
+} from "../widgets/lib/pane-comms.ts";
 import { appendEvent, readEvents, type OrchestratorEvent } from "./event-log.ts";
 import { loadSkill } from "./skill-registry.ts";
 import { isGhAvailable, createMissionPr } from "./github-pr.ts";
@@ -170,15 +175,8 @@ export function isAgentBusy(pane: PaneInfo): boolean {
  * can show stale spinners after the agent finishes.
  */
 function isAtAgentPrompt(paneId: string): boolean {
-  try {
-    const lastLine = execFileSync("tmux", ["capture-pane", "-t", paneId, "-p", "-S", "-1"], {
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-    return lastLine.includes("❯");
-  } catch {
-    return false;
-  }
+  const lastLine = captureLastLine(paneId);
+  return lastLine.includes("❯");
 }
 
 export function isIdleForDispatch(pane: PaneInfo): boolean {

package/src/stop.test.ts

@@ -3,7 +3,7 @@ import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { _setExecutor } from "./lib/tmux.ts";
-import { stop, stopDashboard } from "./stop.ts";
+import { stop } from "./stop.ts";
 
 let mockExec;
 let restoreExec;
@@ -149,28 +149,3 @@ describe("stop", () => {
     }
   });
 });
-
-describe("stopDashboard", () => {
-  it("kills the stored dashboard pid", () => {
-    writeIdeYml("my-app");
-    mockExec.mockImplementation((_cmd, args) => {
-      if (args[0] === "show-option" && args[3] === "@dashboard_pid") return "4321\n";
-      return "\n";
-    });
-
-    const origKill = process.kill;
-    const kills: Array<{ pid: number; signal?: string | number }> = [];
-    process.kill = ((pid: number, signal?: string | number) => {
-      kills.push({ pid, signal });
-      return true;
-    }) as typeof process.kill;
-
-    try {
-      stopDashboard("my-app");
-    } finally {
-      process.kill = origKill;
-    }
-
-    expect(kills[0]).toEqual({ pid: -4321, signal: "SIGTERM" });
-  });
-});

package/src/stop.ts

@@ -1,25 +1,7 @@
 import { resolve } from "node:path";
 import { getSessionName } from "./lib/yaml-io.ts";
 import { outputError } from "./lib/output.ts";
-import { getSessionVariable, killSession, stopSessionMonitor } from "./lib/tmux.ts";
-
-export function stopDashboard(session: string): void {
-  const pid = getSessionVariable(session, "@dashboard_pid");
-  if (!pid) return;
-
-  const numPid = Number.parseInt(pid, 10);
-  if (Number.isNaN(numPid)) return;
-
-  try {
-    process.kill(-numPid, "SIGTERM");
-  } catch {
-    try {
-      process.kill(numPid, "SIGTERM");
-    } catch {
-      // Process already gone.
-    }
-  }
-}
+import { killSession, stopSessionMonitor } from "./lib/tmux.ts";
 
 export async function stop(
   targetDir: string | undefined,
@@ -30,7 +12,6 @@ export async function stop(
 
   // Stop the session monitor before killing the session
   stopSessionMonitor(session);
-  stopDashboard(session);
 
   const result = killSession(session);
 

package/src/widgets/lib/pane-comms.ts

@@ -190,3 +190,18 @@ export function resolveTarget(session: string, opts: TargetOptions): string | nu
   if (opts.selfPaneId) return findAdjacentPane(session, opts.selfPaneId);
   return null;
 }
+
+/**
+ * Capture the last line of a tmux pane. Uses the mockable executor so tests
+ * can intercept the call instead of hitting a real tmux server.
+ */
+export function captureLastLine(paneId: string): string {
+  try {
+    return _executor("tmux", ["capture-pane", "-t", paneId, "-p", "-S", "-1"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+  } catch {
+    return "";
+  }
+}