tmux-ide 2.6.0 → 2.7.0

package/packages/daemon/src/lib/project-registry.ts

@@ -0,0 +1,296 @@
+/**
+ * Project registry — persists the list of projects the user has registered
+ * with tmux-ide via the dashboard. Stored at `~/.tmux-ide/projects.json`,
+ * written atomically via temp+rename (same approach as task-store).
+ *
+ * The pure decider (`applyAction`) is exported separately from the io-bound
+ * accessors so tests can reason about state transitions without hitting the
+ * filesystem. The module also exposes a `projectRegistryEmitter` that the
+ * `/ws/events` channel listens on to broadcast `projects.changed` frames.
+ */
+
+import { EventEmitter } from "node:events";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { z } from "zod";
+import { RegisteredProjectSchemaZ, type RegisteredProject } from "../schemas/registry.ts";
+import { probeProject, sanitizeName, type ProbeIo, type ProjectProbe } from "./project-probe.ts";
+
+const REGISTRY_DIR_ENV = "TMUX_IDE_REGISTRY_DIR";
+
+const RegistryFileSchemaZ = z.object({
+  version: z.literal(1),
+  projects: z.array(RegisteredProjectSchemaZ),
+});
+
+type RegistryFile = z.infer<typeof RegistryFileSchemaZ>;
+
+// ---------------------------------------------------------------------------
+// Typed errors — never use stringly-typed catches at the boundary
+// ---------------------------------------------------------------------------
+
+export class ProjectRegistryError extends Error {
+  readonly code: string;
+  constructor(message: string, code: string) {
+    super(message);
+    this.name = "ProjectRegistryError";
+    this.code = code;
+  }
+}
+
+export class ProjectAlreadyRegisteredError extends ProjectRegistryError {
+  readonly suggestion: string;
+  constructor(name: string, suggestion: string) {
+    super(`Project "${name}" is already registered`, "ALREADY_REGISTERED");
+    this.name = "ProjectAlreadyRegisteredError";
+    this.suggestion = suggestion;
+  }
+}
+
+export class ProjectNotFoundError extends ProjectRegistryError {
+  constructor(name: string) {
+    super(`Project "${name}" not found in registry`, "NOT_FOUND");
+    this.name = "ProjectNotFoundError";
+  }
+}
+
+export class ProjectDirNotFoundError extends ProjectRegistryError {
+  constructor(dir: string) {
+    super(`Directory "${dir}" does not exist`, "DIR_NOT_FOUND");
+    this.name = "ProjectDirNotFoundError";
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Pure decider: state in → state out. No io.
+// ---------------------------------------------------------------------------
+
+export type RegistryAction =
+  | { type: "register"; project: RegisteredProject }
+  | { type: "unregister"; name: string }
+  | { type: "replace"; project: RegisteredProject };
+
+export function applyAction(
+  state: readonly RegisteredProject[],
+  action: RegistryAction,
+): RegisteredProject[] {
+  switch (action.type) {
+    case "register":
+      return [...state, action.project];
+    case "unregister":
+      return state.filter((p) => p.name !== action.name);
+    case "replace":
+      return state.map((p) => (p.name === action.project.name ? action.project : p));
+  }
+}
+
+/**
+ * Resolve a unique name for a probed project, appending `-2`, `-3`, … until
+ * we don't collide with an existing entry.
+ */
+export function resolveUniqueName(state: readonly RegisteredProject[], desired: string): string {
+  const used = new Set(state.map((p) => p.name));
+  if (!used.has(desired)) return desired;
+  let counter = 2;
+  while (used.has(`${desired}-${counter}`)) counter++;
+  return `${desired}-${counter}`;
+}
+
+/**
+ * Build a `RegisteredProject` value from a probe + chosen name + timestamp.
+ * Pure — separated from `registerProject` so tests can verify the shape
+ * without io.
+ */
+export function buildRegisteredProject(
+  probe: ProjectProbe,
+  name: string,
+  registeredAt: string,
+): RegisteredProject {
+  return {
+    name,
+    dir: probe.dir,
+    hasIdeYml: probe.hasIdeYml,
+    gitOrigin: probe.gitOrigin,
+    gitBranch: probe.gitBranch,
+    registeredAt,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Module-level emitter — listened on by ws-events.handleWsEventsConnection
+// ---------------------------------------------------------------------------
+
+export const projectRegistryEmitter = new EventEmitter();
+// One listener per connected ws-events client; can grow with tabs.
+projectRegistryEmitter.setMaxListeners(0);
+
+// ---------------------------------------------------------------------------
+// Persistence — io-bound, single mutex (registry is small + writes are rare)
+// ---------------------------------------------------------------------------
+
+function registryDir(): string {
+  const override = process.env[REGISTRY_DIR_ENV];
+  if (override && override.length > 0) return override;
+  return join(homedir(), ".tmux-ide");
+}
+
+function registryPath(): string {
+  return join(registryDir(), "projects.json");
+}
+
+let cache: RegisteredProject[] | null = null;
+
+function readDisk(): RegisteredProject[] {
+  const path = registryPath();
+  if (!existsSync(path)) return [];
+  const raw = readFileSync(path, "utf-8");
+  if (raw.trim().length === 0) return [];
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    console.warn("[project-registry] %s contains invalid JSON; ignoring", path);
+    return [];
+  }
+  const result = RegistryFileSchemaZ.safeParse(parsed);
+  if (!result.success) {
+    console.warn(
+      "[project-registry] %s failed schema validation; ignoring (%s)",
+      path,
+      result.error.issues
+        .slice(0, 3)
+        .map((i) => `${i.path.join(".")}: ${i.message}`)
+        .join("; "),
+    );
+    return [];
+  }
+  return result.data.projects;
+}
+
+function writeDisk(projects: RegisteredProject[]): void {
+  const path = registryPath();
+  const dir = dirname(path);
+  mkdirSync(dir, { recursive: true });
+  const file: RegistryFile = { version: 1, projects };
+  const tmpPath = `${path}.tmp`;
+  writeFileSync(tmpPath, JSON.stringify(file, null, 2) + "\n");
+  renameSync(tmpPath, path);
+}
+
+function ensureCache(): RegisteredProject[] {
+  if (cache !== null) return cache;
+  cache = readDisk();
+  return cache;
+}
+
+function commit(next: RegisteredProject[]): void {
+  cache = next;
+  writeDisk(next);
+  projectRegistryEmitter.emit("change");
+}
+
+// ---------------------------------------------------------------------------
+// Public api
+// ---------------------------------------------------------------------------
+
+export function listProjects(): RegisteredProject[] {
+  // Return a defensive copy so callers can't mutate the cache.
+  return [...ensureCache()];
+}
+
+export function getProject(name: string): RegisteredProject | null {
+  return ensureCache().find((p) => p.name === name) ?? null;
+}
+
+export interface RegisterInput {
+  dir: string;
+  name?: string;
+  /** Pluggable io for tests. */
+  io?: ProbeIo;
+  /** Override `Date.now()` for deterministic tests. */
+  now?: () => Date;
+  /** Override existsSync for the dir-validity check (tests). */
+  exists?: (path: string) => boolean;
+}
+
+export async function registerProject(input: RegisterInput): Promise<RegisteredProject> {
+  const exists = input.exists ?? existsSync;
+  const absoluteDir = isAbsolute(input.dir) ? input.dir : resolve(input.dir);
+  if (!exists(absoluteDir)) {
+    throw new ProjectDirNotFoundError(absoluteDir);
+  }
+
+  const probe = await probeProject(absoluteDir, input.io);
+  const state = ensureCache();
+
+  // If a name was explicitly requested, treat collisions as hard errors and
+  // suggest an alternative. If no name was given, auto-resolve via -2/-3/…
+  const desired = input.name ? sanitizeName(input.name) : probe.name;
+  const cleaned = desired.length > 0 ? desired : probe.name;
+  let resolvedName: string;
+  if (input.name) {
+    if (state.some((p) => p.name === cleaned)) {
+      throw new ProjectAlreadyRegisteredError(cleaned, resolveUniqueName(state, cleaned));
+    }
+    resolvedName = cleaned;
+  } else {
+    resolvedName = resolveUniqueName(state, cleaned);
+  }
+
+  // Reject re-registering the same dir (different name). Probe again under a
+  // different name is fine, but we want to avoid duplicate dirs in the list.
+  const dupDir = state.find((p) => p.dir === probe.dir);
+  if (dupDir) {
+    throw new ProjectAlreadyRegisteredError(dupDir.name, dupDir.name);
+  }
+
+  const now = (input.now ?? (() => new Date()))();
+  const project = buildRegisteredProject(probe, resolvedName, now.toISOString());
+  commit(applyAction(state, { type: "register", project }));
+  return project;
+}
+
+export function unregisterProject(name: string): void {
+  const state = ensureCache();
+  if (!state.some((p) => p.name === name)) {
+    throw new ProjectNotFoundError(name);
+  }
+  commit(applyAction(state, { type: "unregister", name }));
+}
+
+export interface ProbeOptions {
+  io?: ProbeIo;
+}
+
+/**
+ * Re-probe a registered project by name, persist the refreshed snapshot, and
+ * broadcast the change. Throws if the project isn't registered.
+ */
+export async function refreshProject(
+  name: string,
+  options: ProbeOptions = {},
+): Promise<RegisteredProject> {
+  const state = ensureCache();
+  const existing = state.find((p) => p.name === name);
+  if (!existing) throw new ProjectNotFoundError(name);
+
+  const probe = await probeProject(existing.dir, options.io);
+  const refreshed = buildRegisteredProject(probe, existing.name, existing.registeredAt);
+  commit(applyAction(state, { type: "replace", project: refreshed }));
+  return refreshed;
+}
+
+// ---------------------------------------------------------------------------
+// Test helpers — never call from production code
+// ---------------------------------------------------------------------------
+
+/** Reset the in-memory cache. Tests use this between cases. */
+export function _resetCacheForTests(): void {
+  cache = null;
+}
+
+/** Force a re-read from disk on next access. */
+export function _invalidateCacheForTests(): void {
+  cache = null;
+}

package/packages/daemon/src/lib/session-monitor.ts

@@ -0,0 +1,122 @@
+import { execFileSync } from "node:child_process";
+
+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"],
+      timeout: 2000,
+    });
+    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"],
+      timeout: 2000,
+    });
+    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;
+}
+
+// The per-session tick loop / orchestrator bootstrap that used to live
+// here was orphaned by the canonical-tree fold — `daemon-embed.ts` owns
+// both responsibilities now (see `startEmbeddedDaemon` + its
+// orchestrator branch). Removing the legacy CLI block also fixes the
+// esbuild-bundle case where `import.meta.url`-vs-`process.argv[1]`
+// resolved to true at the bin/cli.js entry, causing the daemon's
+// session monitor to hijack every CLI invocation (see N1 of
+// docs/npm-distribution-audit.md). The pure exports above
+// (`computeAgentStates`, `computePortPanes`) remain — that's what
+// `daemon-embed.ts` actually imports.

package/packages/daemon/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/packages/daemon/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/packages/daemon/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;
+}