tmux-ide 2.6.0 → 2.6.1

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

@@ -0,0 +1,209 @@
+import { execFileSync } from "node:child_process";
+import type { PaneInfo } from "@tmux-ide/contracts";
+
+export type { PaneInfo };
+
+type TmuxExecutor = (cmd: string, args: string[], options?: object) => string;
+
+let _executor: TmuxExecutor = (cmd, args, options) =>
+  execFileSync(cmd, args, { encoding: "utf-8", ...options }).toString();
+
+export function _setExecutor(fn: TmuxExecutor): () => void {
+  const prev = _executor;
+  _executor = fn;
+  return () => {
+    _executor = prev;
+  };
+}
+
+function tmux(...args: string[]): string {
+  try {
+    return _executor("tmux", args, {
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+  } catch (error) {
+    const stderr = (error as { stderr?: Buffer | string })?.stderr?.toString() ?? "";
+    if (stderr.includes("no server running") || stderr.includes("can't find session")) {
+      return "";
+    }
+    throw error;
+  }
+}
+
+export function listSessionPanes(session: string): PaneInfo[] {
+  const format = [
+    "#{pane_id}",
+    "#{pane_index}",
+    "#{pane_title}",
+    "#{pane_current_command}",
+    "#{pane_width}",
+    "#{pane_height}",
+    "#{pane_active}",
+    "#{@ide_role}",
+    "#{@ide_name}",
+    "#{@ide_type}",
+  ].join("\t");
+
+  const output = tmux("list-panes", "-t", session, "-F", format);
+  if (!output) return [];
+
+  return output
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      const [id, index, title, cmd, width, height, active, role, name, type] = line.split("\t");
+      return {
+        id: id!,
+        index: parseInt(index!, 10),
+        title: title!,
+        currentCommand: cmd!,
+        width: parseInt(width!, 10),
+        height: parseInt(height!, 10),
+        active: active === "1",
+        role: (role || null) as PaneInfo["role"],
+        name: name || null,
+        type: type || null,
+      };
+    });
+}
+
+export function findPaneByTitle(session: string, title: string): string | null {
+  const panes = listSessionPanes(session);
+  const match = panes.find((p) => p.title === title);
+  return match?.id ?? null;
+}
+
+export function findPaneByPattern(session: string, pattern: string): string | null {
+  const panes = listSessionPanes(session);
+  const lower = pattern.toLowerCase();
+  const match = panes.find((p) => p.title.toLowerCase().includes(lower));
+  return match?.id ?? null;
+}
+
+export function findAdjacentPane(session: string, currentPaneId: string): string | null {
+  const panes = listSessionPanes(session);
+  const currentIdx = panes.findIndex((p) => p.id === currentPaneId);
+  if (currentIdx === -1 || panes.length < 2) return null;
+  const nextIdx = (currentIdx + 1) % panes.length;
+  return panes[nextIdx]!.id;
+}
+
+const BUSY_COMMANDS = new Set([
+  "claude",
+  "codex",
+  "vim",
+  "nvim",
+  "vi",
+  "nano",
+  "emacs",
+  "less",
+  "more",
+  "top",
+  "htop",
+  "man",
+]);
+
+const SHELL_COMMANDS = new Set(["zsh", "bash", "sh", "fish"]);
+
+export type PaneBusyStatus = "idle" | "busy" | "agent";
+
+export function isPaneBusy(session: string, paneId: string): boolean {
+  const panes = listSessionPanes(session);
+  const pane = panes.find((p) => p.id === paneId);
+  if (!pane) return true;
+  const cmd = pane.currentCommand.toLowerCase();
+  if (SHELL_COMMANDS.has(cmd)) return false;
+  if (BUSY_COMMANDS.has(cmd)) return true;
+  return true; // unknown command — assume busy
+}
+
+export function getPaneBusyStatus(session: string, paneId: string): PaneBusyStatus {
+  const panes = listSessionPanes(session);
+  const pane = panes.find((p) => p.id === paneId);
+  if (!pane) return "busy";
+  const cmd = pane.currentCommand.toLowerCase();
+  if (cmd.startsWith("claude") || cmd.startsWith("codex")) return "agent";
+  if (SHELL_COMMANDS.has(cmd)) return "idle";
+  return "busy";
+}
+
+export function sendText(session: string, paneId: string, text: string): void {
+  tmux("send-keys", "-t", paneId, "-l", "--", text);
+}
+
+// tmux pane ids (e.g. %10) are GLOBAL — they don't take a session prefix.
+// `tmux send-keys -t <session>:<%paneId>` makes tmux interpret the
+// session prefix and then look up `%paneId` as a window inside that
+// session, which fails ("can't find window: %10"). Pass the bare pane id.
+export function sendLiteralToPane(_session: string, paneId: string, text: string): void {
+  tmux("send-keys", "-t", paneId, "-l", "--", text);
+}
+
+export function sendEnterToPane(_session: string, paneId: string): void {
+  tmux("send-keys", "-t", paneId, "Enter");
+}
+
+function sleepMs(ms: number): void {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+export function sendCommand(session: string, paneId: string, command: string): boolean {
+  const status = getPaneBusyStatus(session, paneId);
+  try {
+    tmux("send-keys", "-t", paneId, "-l", "--", command);
+  } catch {
+    return false;
+  }
+  if (status === "agent") {
+    // Claude Code shows a [Pasted text] preview for long input (roughly >200 chars).
+    // Short commands land directly in the prompt — just need a brief delay for the
+    // TUI to register the input. Long commands trigger the paste preview which needs
+    // two Enters: one to confirm the preview, one to submit the prompt.
+    if (command.length < 200) {
+      sleepMs(150);
+    } else {
+      sleepMs(5000);
+      tmux("send-keys", "-t", paneId, "Enter");
+      sleepMs(2000);
+    }
+    tmux("send-keys", "-t", paneId, "Enter");
+    return true;
+  }
+  tmux("send-keys", "-t", paneId, "Enter");
+  return true;
+}
+
+export function openFileInEditor(session: string, paneId: string, filePath: string): void {
+  const editor = process.env.EDITOR ?? "vim";
+  sendCommand(session, paneId, `${editor} ${filePath}`);
+}
+
+export interface TargetOptions {
+  title?: string;
+  titlePattern?: string;
+  paneId?: string;
+  selfPaneId?: string;
+}
+
+export function resolveTarget(session: string, opts: TargetOptions): string | null {
+  if (opts.paneId) return opts.paneId;
+  if (opts.title) return findPaneByTitle(session, opts.title);
+  if (opts.titlePattern) return findPaneByPattern(session, opts.titlePattern);
+  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 "";
+  }
+}

package/packages/daemon/src/widgets/lib/theme.ts

@@ -0,0 +1,194 @@
+import { DEFAULT_THEME, type AppTheme } from "../../lib/app-config.ts";
+
+export type RGBA = { r: number; g: number; b: number; a: number };
+
+export interface WidgetTheme {
+  bg: RGBA;
+  fg: RGBA;
+  fgMuted: RGBA;
+  accent: RGBA;
+  border: RGBA;
+  /** Per-agent-status colors, shared with the tmux chrome via the app theme. */
+  statusBlocked: RGBA;
+  statusWorking: RGBA;
+  statusDone: RGBA;
+  statusIdle: RGBA;
+  statusUnknown: RGBA;
+  selected: RGBA;
+  selectedText: RGBA;
+  dirName: RGBA;
+  rowAlt: RGBA;
+  indentGuide: RGBA;
+  ignored: RGBA;
+  gitModified: RGBA;
+  gitAdded: RGBA;
+  gitDeleted: RGBA;
+  gitUntracked: RGBA;
+  diffAdded: RGBA;
+  diffAddedBg: RGBA;
+  diffRemoved: RGBA;
+  diffRemovedBg: RGBA;
+  diffContext: RGBA;
+  diffContextBg: RGBA;
+  diffHunk: RGBA;
+  diffLineNumber: RGBA;
+}
+
+function rgba(r: number, g: number, b: number, a = 255) {
+  return { r, g, b, a };
+}
+
+const DEFAULTS: WidgetTheme = {
+  bg: rgba(30, 30, 40),
+  fg: rgba(200, 200, 210),
+  fgMuted: rgba(120, 120, 140),
+  accent: rgba(130, 170, 255),
+  border: rgba(60, 60, 80),
+  statusBlocked: rgba(255, 95, 95),
+  statusWorking: rgba(255, 215, 95),
+  statusDone: rgba(135, 175, 255),
+  statusIdle: rgba(135, 215, 135),
+  statusUnknown: rgba(128, 128, 128),
+  selected: rgba(50, 50, 70),
+  selectedText: rgba(255, 255, 255),
+  dirName: rgba(100, 160, 255),
+  rowAlt: rgba(255, 255, 255, 5),
+  indentGuide: rgba(60, 60, 80),
+  ignored: rgba(80, 80, 100),
+  gitModified: rgba(230, 180, 80),
+  gitAdded: rgba(80, 200, 120),
+  gitDeleted: rgba(230, 80, 80),
+  gitUntracked: rgba(120, 120, 140),
+  diffAdded: rgba(80, 200, 120),
+  diffAddedBg: rgba(20, 60, 30),
+  diffRemoved: rgba(230, 80, 80),
+  diffRemovedBg: rgba(60, 20, 20),
+  diffContext: rgba(160, 160, 170),
+  diffContextBg: rgba(30, 30, 40),
+  diffHunk: rgba(100, 180, 220),
+  diffLineNumber: rgba(80, 80, 100),
+};
+
+/**
+ * Parse a tmux/CSS color string into RGBA.
+ * Supports: colourN / colorN (0-255), #rgb, #rrggbb.
+ */
+function parseColor(color: string): RGBA | null {
+  // tmux colour0–colour255
+  const tmuxMatch = color.match(/^colou?r(\d+)$/);
+  if (tmuxMatch) {
+    const rawIndex = tmuxMatch[1];
+    if (!rawIndex) return null;
+    const n = parseInt(rawIndex, 10);
+    if (n < 0 || n > 255) return null;
+
+    // Standard colors 0–15 (approximate to common terminal defaults)
+    const STANDARD: [number, number, number][] = [
+      [0, 0, 0],
+      [128, 0, 0],
+      [0, 128, 0],
+      [128, 128, 0],
+      [0, 0, 128],
+      [128, 0, 128],
+      [0, 128, 128],
+      [192, 192, 192],
+      [128, 128, 128],
+      [255, 0, 0],
+      [0, 255, 0],
+      [255, 255, 0],
+      [0, 0, 255],
+      [255, 0, 255],
+      [0, 255, 255],
+      [255, 255, 255],
+    ];
+    if (n < 16) {
+      const standard = STANDARD[n];
+      if (!standard) return null;
+      return rgba(standard[0], standard[1], standard[2]);
+    }
+
+    // 6×6×6 color cube (16–231)
+    if (n < 232) {
+      const idx = n - 16;
+      const LEVELS: number[] = [0, 95, 135, 175, 215, 255];
+      const r = LEVELS[Math.floor(idx / 36)];
+      const g = LEVELS[Math.floor((idx % 36) / 6)];
+      const b = LEVELS[idx % 6];
+      if (r == null || g == null || b == null) return null;
+      return rgba(r, g, b);
+    }
+
+    // Grayscale ramp (232–255)
+    const level = 8 + 10 * (n - 232);
+    return rgba(level, level, level);
+  }
+
+  // Hex: #rgb or #rrggbb
+  const hexMatch = color.match(/^#([0-9a-fA-F]{3,6})$/);
+  if (hexMatch) {
+    let hex = hexMatch[1];
+    if (!hex) return null;
+    if (hex.length === 3) {
+      const [r, g, b] = hex.split("");
+      if (!r || !g || !b) return null;
+      hex = r + r + g + g + b + b;
+    }
+    if (hex.length !== 6) return null;
+    return rgba(
+      parseInt(hex.slice(0, 2), 16),
+      parseInt(hex.slice(2, 4), 16),
+      parseInt(hex.slice(4, 6), 16),
+    );
+  }
+
+  return null;
+}
+
+/**
+ * Map the shared app-theme tokens ({@link AppTheme}) onto a {@link WidgetTheme}
+ * base: accent, muted→fgMuted, fg, and the per-status colors. This is the layer
+ * that makes the OpenTUI widgets share the tmux chrome's palette. Unmappable
+ * tokens (e.g. a hex the parser rejects) keep their default.
+ */
+function applyAppTheme(base: WidgetTheme, appTheme: AppTheme): void {
+  const assign = (prop: keyof WidgetTheme, token: string) => {
+    const parsed = parseColor(token);
+    if (parsed) base[prop] = parsed;
+  };
+  assign("accent", appTheme.accent);
+  assign("fgMuted", appTheme.muted);
+  assign("fg", appTheme.fg);
+  assign("statusBlocked", appTheme.status.blocked);
+  assign("statusWorking", appTheme.status.working);
+  assign("statusDone", appTheme.status.done);
+  assign("statusIdle", appTheme.status.idle);
+  assign("statusUnknown", appTheme.status.unknown);
+}
+
+/**
+ * Build a widget theme. The shared app-theme tokens (`appTheme`, defaulting to
+ * {@link DEFAULT_THEME}) form the base palette so widgets and chrome match; the
+ * per-project ide.yml `theme` (`config`: accent/border/bg/fg) overrides on top.
+ */
+export function createTheme(
+  config?: Record<string, string>,
+  appTheme: AppTheme = DEFAULT_THEME,
+): WidgetTheme {
+  const theme = { ...DEFAULTS };
+  applyAppTheme(theme, appTheme);
+  if (!config) return theme;
+  const MAP: Record<string, keyof WidgetTheme> = {
+    accent: "accent",
+    border: "border",
+    bg: "bg",
+    fg: "fg",
+  };
+  for (const [key, prop] of Object.entries(MAP)) {
+    const val = config[key];
+    if (val) {
+      const parsed = parseColor(val);
+      if (parsed) theme[prop] = parsed;
+    }
+  }
+  return theme;
+}

package/packages/daemon/src/widgets/lib/watcher.ts

@@ -0,0 +1,132 @@
+import { watch as fsWatch, type FSWatcher } from "node:fs";
+import { join, sep } from "node:path";
+
+export interface WatchEvent {
+  type: "create" | "update" | "delete";
+  path: string;
+}
+
+/**
+ * File watching that survives BOTH runtimes. In a dev checkout / node install
+ * we use `@parcel/watcher` (fast, native, recursive with real ignore globs).
+ * In the compiled `tmux-ide-tui` binary that native `.node` addon can't be
+ * embedded by `bun build --compile`, so importing it throws — we catch that
+ * once and fall back to node's builtin `fs.watch`. The fallback is coarser
+ * (segment-level ignores, synthesized "update" events) but keeps the explorer
+ * and changes surfaces live instead of crashing on boot.
+ */
+
+interface ParcelSubscription {
+  unsubscribe(): Promise<void>;
+}
+interface ParcelWatcher {
+  subscribe(
+    dir: string,
+    cb: (err: Error | null, events: { type: string; path: string }[]) => void,
+    opts?: { ignore?: string[] },
+  ): Promise<ParcelSubscription>;
+}
+
+// undefined = not attempted yet, null = confirmed unavailable (compiled binary).
+let parcel: ParcelWatcher | null | undefined;
+
+async function loadParcel(): Promise<ParcelWatcher | null> {
+  if (parcel !== undefined) return parcel;
+  try {
+    const mod = (await import("@parcel/watcher")) as unknown as ParcelWatcher;
+    if (typeof mod.subscribe !== "function") throw new Error("no subscribe");
+    parcel = mod;
+  } catch {
+    parcel = null;
+  }
+  return parcel;
+}
+
+function fsWatchDirectory(
+  dir: string,
+  onChange: (events: WatchEvent[]) => void,
+  ignore: string[],
+  debounceMs: number,
+): () => Promise<void> {
+  const ignoreSet = new Set(ignore);
+  let timeout: ReturnType<typeof setTimeout> | null = null;
+  let handle: FSWatcher | null = null;
+  try {
+    handle = fsWatch(dir, { recursive: true }, (_event, filename) => {
+      if (!filename) return;
+      const rel = filename.toString();
+      if (rel.split(sep).some((part) => ignoreSet.has(part))) return;
+      if (timeout) clearTimeout(timeout);
+      timeout = setTimeout(() => onChange([{ type: "update", path: join(dir, rel) }]), debounceMs);
+    });
+  } catch {
+    // Directory may be unreadable/vanished — degrade to a no-op watcher.
+  }
+  return async () => {
+    if (timeout) clearTimeout(timeout);
+    handle?.close();
+  };
+}
+
+export async function watchDirectory(
+  dir: string,
+  onChange: (events: WatchEvent[]) => void,
+  options?: { debounceMs?: number; ignore?: string[] },
+): Promise<() => Promise<void>> {
+  const debounceMs = options?.debounceMs ?? 300;
+  const ignore = options?.ignore ?? ["node_modules", ".git", "dist", "build", ".next"];
+
+  const native = await loadParcel();
+  if (!native) return fsWatchDirectory(dir, onChange, ignore, debounceMs);
+
+  let timeout: ReturnType<typeof setTimeout> | null = null;
+  const subscription = await native.subscribe(
+    dir,
+    (err, events) => {
+      if (err) return;
+      if (timeout) clearTimeout(timeout);
+      timeout = setTimeout(() => onChange(events as unknown as WatchEvent[]), debounceMs);
+    },
+    { ignore },
+  );
+
+  return async () => {
+    if (timeout) clearTimeout(timeout);
+    await subscription.unsubscribe();
+  };
+}
+
+export async function watchGitHead(
+  dir: string,
+  onBranchChange: () => void,
+): Promise<(() => Promise<void>) | null> {
+  const gitDir = join(dir, ".git");
+
+  const native = await loadParcel();
+  if (!native) {
+    try {
+      const handle = fsWatch(gitDir, (_event, filename) => {
+        if (filename && filename.toString().endsWith("HEAD")) onBranchChange();
+      });
+      return async () => handle.close();
+    } catch {
+      return null;
+    }
+  }
+
+  try {
+    const subscription = await native.subscribe(
+      gitDir,
+      (err, events) => {
+        if (err) return;
+        if (events.some((e) => e.path.endsWith("HEAD"))) {
+          onBranchChange();
+        }
+      },
+      { ignore: ["objects", "pack", "refs", "logs"] },
+    );
+    return () => subscription.unsubscribe();
+  } catch {
+    return null;
+  }
+}

package/packages/daemon/src/widgets/preview/README.md

@@ -0,0 +1,3 @@
+# `preview` — daemon TUI widget
+
+File content preview. See [ARCHITECTURE.md §3](../../../../../ARCHITECTURE.md#§3--package-map) and the [`preview` row in docs/widget-index.md](../../../../../docs/widget-index.md#daemon-tui-widgets-8).