tmux-ide 2.1.4 → 2.6.0

package/src/lib/session-monitor.ts

@@ -1,282 +0,0 @@
-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

@@ -1,146 +0,0 @@
-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

@@ -1,100 +0,0 @@
-/**
- * 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

@@ -1,20 +0,0 @@
-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/sizes.test.ts

@@ -1,73 +0,0 @@
-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

@@ -1,36 +0,0 @@
-/**
- * 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;
-}