tmux-ide 1.3.1 → 2.1.0

package/src/lib/session-monitor.ts

@@ -0,0 +1,282 @@
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
+
+const INTERVAL = 1000;
+const SPINNERS = /^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏⠂⠒⠢⠆⠐⠠⠄◐◓◑◒|/\\-] /;
+
+interface MonitorPane {
+  id: string;
+  pid: string;
+  cmd?: string;
+  title?: string;
+  role?: string;
+  type?: string;
+  name?: string;
+}
+
+// --- Port detection (pure helpers) ---
+
+function getListeningPids(): Set<string> {
+  // Returns Set of PIDs that have a listening TCP port in range 1024-20000
+  try {
+    const raw = execFileSync("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN", "-FpPn"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    const pids = new Set<string>();
+    let currentPid: string | null = null;
+    for (const line of raw.split("\n")) {
+      if (line.startsWith("p")) {
+        currentPid = line.slice(1);
+      } else if (line.startsWith("n") && currentPid) {
+        const match = line.match(/:(\d+)$/);
+        if (match) {
+          const port = parseInt(match[1]!, 10);
+          if (port >= 1024 && port <= 20000) pids.add(currentPid);
+        }
+      }
+    }
+    return pids;
+  } catch {
+    return new Set<string>();
+  }
+}
+
+function getProcessTree(): Map<string, string> {
+  // Returns Map<pid, ppid>
+  try {
+    const raw = execFileSync("ps", ["-axo", "pid=,ppid="], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    const tree = new Map<string, string>();
+    for (const line of raw.trim().split("\n")) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length === 2) tree.set(parts[0]!, parts[1]!);
+    }
+    return tree;
+  } catch {
+    return new Map<string, string>();
+  }
+}
+
+export function computePortPanes(
+  panes: MonitorPane[],
+  { listeners, tree }: { listeners?: Set<string>; tree?: Map<string, string> } = {},
+): Set<string> {
+  // Walk up from each listening PID to find which pane owns it
+  const resolvedListeners = listeners ?? getListeningPids();
+  const resolvedTree = tree ?? getProcessTree();
+  if (resolvedListeners.size === 0) return new Set<string>();
+
+  const panePids = new Map(panes.map((p) => [p.pid, p.id]));
+  const result = new Set<string>();
+
+  for (const listenerPid of resolvedListeners) {
+    let pid: string | undefined = listenerPid;
+    while (pid && pid !== "0") {
+      if (panePids.has(pid)) {
+        result.add(panePids.get(pid)!);
+        break;
+      }
+      pid = resolvedTree.get(pid);
+    }
+  }
+  return result;
+}
+
+// --- Agent detection ---
+
+export function computeAgentStates(panes: MonitorPane[]): Map<string, "busy" | "idle" | null> {
+  // Returns Map<paneId, "busy" | "idle" | null>
+  const states = new Map<string, "busy" | "idle" | null>();
+  for (const pane of panes) {
+    const role = pane.role ?? "";
+
+    // Primary: use @ide_role pane option if available
+    if (role === "lead" || role === "teammate") {
+      states.set(pane.id, SPINNERS.test(pane.title ?? "") ? "busy" : "idle");
+      continue;
+    }
+
+    // Fallback: command-based detection for pre-upgrade sessions
+    const cmd = (pane.cmd ?? "").toLowerCase();
+    if (!cmd.includes("claude") && !cmd.includes("codex")) {
+      states.set(pane.id, null);
+      continue;
+    }
+    states.set(pane.id, SPINNERS.test(pane.title ?? "") ? "busy" : "idle");
+  }
+  return states;
+}
+
+// --- Main loop (only runs when executed directly) ---
+
+const isMainModule = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+
+if (isMainModule) {
+  const session: string = process.argv[2]!;
+  if (!session) process.exit(1);
+
+  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,
+      };
+    });
+  }
+
+  let lastState = "";
+
+  function tick(): void {
+    if (!sessionExists()) process.exit(0);
+    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);
+      }
+    }
+
+    tmuxSilent("refresh-client", "-S");
+    lastState = stateKey;
+  }
+
+  const monitorInterval = setInterval(tick, INTERVAL);
+  tick(); // run immediately
+
+  // Unified shutdown handler — cleans up everything on SIGTERM/SIGINT
+  let stopOrchestrator: (() => void) | null = null;
+
+  function shutdown() {
+    clearInterval(monitorInterval);
+    if (stopOrchestrator) stopOrchestrator();
+    process.exit(0);
+  }
+
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+
+  // Start orchestrator if enabled in config
+  (async () => {
+    try {
+      const { readConfig } = await import("./yaml-io.ts");
+      const { config } = readConfig(process.cwd());
+
+      if (config.orchestrator?.enabled) {
+        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()),
+                );
+              }
+            }
+          }
+
+          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 ?? {},
+            research: orch.research,
+          });
+        } catch {
+          // Orchestrator module not available yet
+        }
+      }
+    } catch {
+      // Config not readable — skip orchestrator
+    }
+  })();
+}

package/src/lib/session-options.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect } from "bun:test";
+import {
+  buildSessionOptions,
+  themeOptions,
+  borderOptions,
+  behaviorOptions,
+  statusBarOptions,
+  keyBindings,
+} from "./session-options.ts";
+
+describe("buildSessionOptions", () => {
+  it("returns an array of command arrays", () => {
+    const options = buildSessionOptions("my-session");
+
+    expect(Array.isArray(options)).toBeTruthy();
+    expect(options.length > 0).toBeTruthy();
+    for (const cmd of options) {
+      expect(Array.isArray(cmd)).toBeTruthy();
+      expect(cmd.length >= 2).toBeTruthy();
+    }
+  });
+
+  it("composes all sub-builders", () => {
+    const session = "test";
+    const theme = {};
+    const all = buildSessionOptions(session, { theme });
+    const expected = [
+      ...themeOptions(session, theme),
+      ...borderOptions(session, theme),
+      ...behaviorOptions(session),
+      ...statusBarOptions(session, theme),
+      ...keyBindings(),
+    ];
+
+    expect(all).toEqual(expected);
+  });
+});
+
+describe("themeOptions", () => {
+  it("includes expected color settings", () => {
+    const opts = themeOptions("my-session", {});
+
+    const optionNames = opts.map((o) => o[3]);
+    expect(optionNames.includes("status-style")).toBeTruthy();
+    expect(optionNames.includes("pane-border-style")).toBeTruthy();
+    expect(optionNames.includes("pane-active-border-style")).toBeTruthy();
+  });
+
+  it("uses default colors when no theme provided", () => {
+    const opts = themeOptions("s", {});
+
+    expect(opts[0]).toEqual(["set-option", "-t", "s", "status-style", "bg=colour235,fg=colour248"]);
+    expect(opts[1]).toEqual(["set-option", "-t", "s", "pane-border-style", "fg=colour238"]);
+    expect(opts[2]).toEqual(["set-option", "-t", "s", "pane-active-border-style", "fg=colour75"]);
+  });
+
+  it("respects custom theme overrides", () => {
+    const opts = themeOptions("my-session", { accent: "red", border: "blue" });
+
+    expect(opts[1]).toEqual(["set-option", "-t", "my-session", "pane-border-style", "fg=blue"]);
+    expect(opts[2]).toEqual([
+      "set-option",
+      "-t",
+      "my-session",
+      "pane-active-border-style",
+      "fg=red",
+    ]);
+  });
+});
+
+describe("borderOptions", () => {
+  it("includes pane-border-status and pane-border-format", () => {
+    const opts = borderOptions("my-session", {});
+
+    expect(opts[0]).toEqual(["set-option", "-t", "my-session", "pane-border-status", "top"]);
+    expect(opts[1][3]).toBe("pane-border-format");
+    expect(opts[1][4].includes("pane_current_path")).toBeTruthy();
+  });
+});
+
+describe("behaviorOptions", () => {
+  it("includes mouse, escape-time, and status-interval", () => {
+    const opts = behaviorOptions("test-session");
+
+    const mouseOpt = opts.find((o) => o[3] === "mouse");
+    expect(mouseOpt).toEqual(["set-option", "-t", "test-session", "mouse", "on"]);
+
+    const escapeOpt = opts.find((o) => o[3] === "escape-time");
+    expect(escapeOpt).toEqual(["set-option", "-t", "test-session", "escape-time", "0"]);
+
+    const intervalOpt = opts.find((o) => o[3] === "status-interval");
+    expect(intervalOpt).toEqual(["set-option", "-t", "test-session", "status-interval", "1"]);
+  });
+});
+
+describe("statusBarOptions", () => {
+  it("includes two-line status mode", () => {
+    const opts = statusBarOptions("my-session", {});
+    const statusOpt = opts.find((o) => o[3] === "status");
+    expect(statusOpt).toEqual(["set-option", "-t", "my-session", "status", "2"]);
+  });
+
+  it("includes status-format[1] with pane tabs", () => {
+    const opts = statusBarOptions("my-session", {});
+    const formatOpt = opts.find((o) => o[3] === "status-format[1]");
+    expect(formatOpt).toBeTruthy();
+    expect(formatOpt[4].includes("#{P:")).toBeTruthy();
+    expect(formatOpt[4].includes("pane_id")).toBeTruthy();
+  });
+
+  it("includes status-left with session name", () => {
+    const opts = statusBarOptions("my-session", {});
+    const leftOpt = opts.find((o) => o[3] === "status-left");
+    expect(leftOpt[4].includes("MY-SESSION IDE")).toBeTruthy();
+  });
+
+  it("includes all expected status bar settings", () => {
+    const opts = statusBarOptions("s", {});
+    const names = opts.map((o) => o[3]);
+
+    expect(names.includes("status-left")).toBeTruthy();
+    expect(names.includes("status-left-length")).toBeTruthy();
+    expect(names.includes("status-right")).toBeTruthy();
+    expect(names.includes("status-justify")).toBeTruthy();
+    expect(names.includes("window-status-current-format")).toBeTruthy();
+    expect(names.includes("window-status-format")).toBeTruthy();
+    expect(names.includes("status")).toBeTruthy();
+    expect(names.includes("status-format[1]")).toBeTruthy();
+  });
+});
+
+describe("keyBindings", () => {
+  it("includes the mouse click binding", () => {
+    const bindings = keyBindings();
+
+    expect(bindings.length).toBe(1);
+    expect(bindings[0]).toEqual([
+      "bind-key",
+      "-n",
+      "MouseDown1StatusDefault",
+      "select-pane",
+      "-t",
+      "=",
+    ]);
+  });
+});

package/src/lib/session-options.ts

@@ -0,0 +1,100 @@
+/**
+ * Composable builders for tmux session configuration.
+ * Each returns an array of tmux command arrays.
+ */
+
+import type { ThemeConfig, TmuxCommand } from "../types.ts";
+
+export function buildSessionOptions(
+  session: string,
+  { theme = {} }: { theme?: ThemeConfig } = {},
+): TmuxCommand[] {
+  return [
+    ...themeOptions(session, theme),
+    ...borderOptions(session, theme),
+    ...behaviorOptions(session),
+    ...statusBarOptions(session, theme),
+    ...keyBindings(),
+  ];
+}
+
+export function themeOptions(session: string, theme: ThemeConfig): TmuxCommand[] {
+  const accent = theme.accent ?? "colour75";
+  const border = theme.border ?? "colour238";
+  const bg = theme.bg ?? "colour235";
+  const fg = theme.fg ?? "colour248";
+
+  return [
+    ["set-option", "-t", session, "status-style", `bg=${bg},fg=${fg}`],
+    ["set-option", "-t", session, "pane-border-style", `fg=${border}`],
+    ["set-option", "-t", session, "pane-active-border-style", `fg=${accent}`],
+  ];
+}
+
+export function borderOptions(session: string, theme: ThemeConfig): TmuxCommand[] {
+  const accent = theme.accent ?? "colour75";
+  const border = theme.border ?? "colour238";
+  const fg = theme.fg ?? "colour248";
+
+  return [
+    ["set-option", "-t", session, "pane-border-status", "top"],
+    [
+      "set-option",
+      "-t",
+      session,
+      "pane-border-format",
+      ` #{?pane_active,#[fg=${accent}#,bold]▸ #T  #[fg=${fg}]#{pane_current_path},#[fg=${border}]· #T  #{pane_current_path}} `,
+    ],
+  ];
+}
+
+export function behaviorOptions(session: string): TmuxCommand[] {
+  return [
+    ["set-option", "-t", session, "mouse", "on"],
+    ["set-option", "-t", session, "escape-time", "0"],
+    ["set-option", "-t", session, "status-interval", "1"],
+  ];
+}
+
+export function statusBarOptions(session: string, theme: ThemeConfig): TmuxCommand[] {
+  const accent = theme.accent ?? "colour75";
+  const border = theme.border ?? "colour238";
+  const fg = theme.fg ?? "colour248";
+
+  // Pane tab components — each is a self-contained piece
+  const agentIndicator = [
+    `#{?#{==:#{@agent_busy},1},#[fg=${accent}]⏺ ,`,
+    `#{?#{==:#{@agent_idle},1},#[fg=${border}]● ,}}`,
+  ].join("");
+  const portIndicator = `#{?#{==:#{@has_port},1},#[fg=green]⏺ ,}`;
+  const paneStyle = `#{?pane_active,#[fg=${accent}],#[fg=${border}]}`;
+  const paneTab = `${agentIndicator}${portIndicator}${paneStyle}#[range=pane|#{pane_id}] #T #[norange]#[default]`;
+  const separator = `#{?loop_last_flag,,#[fg=${border}]│}`;
+
+  return [
+    [
+      "set-option",
+      "-t",
+      session,
+      "status-left",
+      `#[fg=colour0,bg=${accent},bold]  ${session.toUpperCase()} IDE #[default] `,
+    ],
+    ["set-option", "-t", session, "status-left-length", "30"],
+    [
+      "set-option",
+      "-t",
+      session,
+      "status-right",
+      `#[fg=colour243]%H:%M #[fg=${accent}]│ #[fg=${fg}]%b %d `,
+    ],
+    ["set-option", "-t", session, "status-justify", "centre"],
+    ["set-option", "-t", session, "window-status-current-format", `#[fg=${accent},bold]●`],
+    ["set-option", "-t", session, "window-status-format", `#[fg=${border}]○`],
+    ["set-option", "-t", session, "status", "2"],
+    ["set-option", "-t", session, "status-format[1]", `  #{P:${paneTab}${separator}}`],
+  ];
+}
+
+export function keyBindings(): TmuxCommand[] {
+  return [["bind-key", "-n", "MouseDown1StatusDefault", "select-pane", "-t", "="]];
+}

package/src/lib/shell.test.ts

@@ -0,0 +1,20 @@
+import { describe, it, expect } from "bun:test";
+import { shellEscape } from "./shell.ts";
+
+describe("shellEscape", () => {
+  it("wraps plain strings in single quotes", () => {
+    expect(shellEscape("hello")).toBe("'hello'");
+  });
+
+  it("escapes embedded single quotes", () => {
+    expect(shellEscape("don't")).toBe("'don'\\''t'");
+  });
+
+  it("handles empty string", () => {
+    expect(shellEscape("")).toBe("''");
+  });
+
+  it("handles newlines and shell metacharacters literally inside quotes", () => {
+    expect(shellEscape("a; rm -rf /")).toBe("'a; rm -rf /'");
+  });
+});

package/src/lib/shell.ts

@@ -0,0 +1,8 @@
+/**
+ * Quote a string for safe embedding in POSIX sh/bash commands as a single word.
+ * Wraps in single quotes; embedded `'` becomes `'\''` (end quote, literal quote, resume).
+ */
+export function shellEscape(s: string): string {
+  // Each "'" in the input becomes '\'' outside a single-quoted string.
+  return "'" + s.replace(/'/g, "'\\''") + "'";
+}

package/src/lib/sizes.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from "bun:test";
+import { computeSizes, toSplitPercents } from "./sizes.ts";
+
+describe("computeSizes", () => {
+  it("distributes remaining space to items without size", () => {
+    const result = computeSizes([{ size: "70%" }, {}]);
+    expect(result).toEqual([70, 30]);
+  });
+
+  it("passes through all explicit sizes", () => {
+    const result = computeSizes([{ size: "60%" }, { size: "40%" }]);
+    expect(result).toEqual([60, 40]);
+  });
+
+  it("splits equally when no sizes specified", () => {
+    const result = computeSizes([{}, {}, {}]);
+    const expected = [100 / 3, 100 / 3, 100 / 3];
+    expect(result).toEqual(expected);
+  });
+
+  it("handles 3 items with mixed sizes", () => {
+    const result = computeSizes([{ size: "60%" }, { size: "25%" }, {}]);
+    expect(result).toEqual([60, 25, 15]);
+  });
+
+  it("handles single item without size", () => {
+    const result = computeSizes([{}]);
+    expect(result).toEqual([100]);
+  });
+
+  it("handles single item with size", () => {
+    const result = computeSizes([{ size: "50%" }]);
+    expect(result).toEqual([50]);
+  });
+
+  it("handles empty array", () => {
+    const result = computeSizes([]);
+    expect(result).toEqual([]);
+  });
+
+  it("clamps remaining to zero when sizes exceed 100", () => {
+    const result = computeSizes([{ size: "80%" }, { size: "30%" }, {}]);
+    expect(result).toEqual([80, 30, 0]);
+  });
+});
+
+describe("toSplitPercents", () => {
+  it("converts 70/30 to [30]", () => {
+    expect(toSplitPercents([70, 30])).toEqual([30]);
+  });
+
+  it("converts 60/25/15 correctly", () => {
+    const result = toSplitPercents([60, 25, 15]);
+    expect(result).toEqual([40, 38]);
+  });
+
+  it("converts equal 50/50 to [50]", () => {
+    expect(toSplitPercents([50, 50])).toEqual([50]);
+  });
+
+  it("converts equal thirds", () => {
+    const result = toSplitPercents([100 / 3, 100 / 3, 100 / 3]);
+    expect(result).toEqual([67, 50]);
+  });
+
+  it("returns empty array for single item", () => {
+    expect(toSplitPercents([100])).toEqual([]);
+  });
+
+  it("returns empty array for empty input", () => {
+    expect(toSplitPercents([])).toEqual([]);
+  });
+});

package/src/lib/sizes.ts

@@ -0,0 +1,36 @@
+/**
+ * Compute absolute sizes for items where some have explicit sizes and others don't.
+ * Items with `size` (e.g. "70%") keep their value; remaining space is split equally
+ * among items without a size.
+ */
+export function computeSizes(items: { size?: string }[]): number[] {
+  let claimed = 0;
+  let unclaimed = 0;
+  for (const item of items) {
+    if (item.size) {
+      claimed += parseFloat(item.size);
+    } else {
+      unclaimed++;
+    }
+  }
+  const remaining = Math.max(0, 100 - claimed);
+  const defaultSize = unclaimed > 0 ? remaining / unclaimed : 0;
+  return items.map((item) => (item.size ? parseFloat(item.size) : defaultSize));
+}
+
+/**
+ * Convert absolute sizes (e.g. [70, 30]) to tmux split percentages for sequential splits.
+ * Returns array of -p values (one per split after the first item).
+ *
+ * Each tmux split divides the current pane. The percentage given to -p is
+ * the portion allocated to the NEW (bottom/right) pane.
+ */
+export function toSplitPercents(sizes: number[]): number[] {
+  const percents: number[] = [];
+  for (let i = 1; i < sizes.length; i++) {
+    const remaining = sizes.slice(i - 1).reduce((a, b) => a + b, 0);
+    const topShare = sizes[i - 1]!;
+    percents.push(Math.round(((remaining - topShare) / remaining) * 100));
+  }
+  return percents;
+}