tmux-ide 2.1.4 → 2.6.0

package/packages/daemon/dist/widgets/lib/pane-comms.js

@@ -0,0 +1,189 @@
+import { execFileSync } from "node:child_process";
+let _executor = (cmd, args, options) => execFileSync(cmd, args, { encoding: "utf-8", ...options }).toString();
+export function _setExecutor(fn) {
+    const prev = _executor;
+    _executor = fn;
+    return () => {
+        _executor = prev;
+    };
+}
+function tmux(...args) {
+    try {
+        return _executor("tmux", args, {
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+    }
+    catch (error) {
+        const stderr = error?.stderr?.toString() ?? "";
+        if (stderr.includes("no server running") || stderr.includes("can't find session")) {
+            return "";
+        }
+        throw error;
+    }
+}
+export function listSessionPanes(session) {
+    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),
+            name: name || null,
+            type: type || null,
+        };
+    });
+}
+export function findPaneByTitle(session, title) {
+    const panes = listSessionPanes(session);
+    const match = panes.find((p) => p.title === title);
+    return match?.id ?? null;
+}
+export function findPaneByPattern(session, pattern) {
+    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, currentPaneId) {
+    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 function isPaneBusy(session, paneId) {
+    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, paneId) {
+    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, paneId, text) {
+    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, paneId, text) {
+    tmux("send-keys", "-t", paneId, "-l", "--", text);
+}
+export function sendEnterToPane(_session, paneId) {
+    tmux("send-keys", "-t", paneId, "Enter");
+}
+function sleepMs(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+export function sendCommand(session, paneId, command) {
+    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, paneId, filePath) {
+    const editor = process.env.EDITOR ?? "vim";
+    sendCommand(session, paneId, `${editor} ${filePath}`);
+}
+export function resolveTarget(session, opts) {
+    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) {
+    try {
+        return _executor("tmux", ["capture-pane", "-t", paneId, "-p", "-S", "-1"], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return "";
+    }
+}

package/packages/daemon/dist/widgets/lib/theme.d.ts

@@ -0,0 +1,44 @@
+import { 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;
+}
+/**
+ * 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 declare function createTheme(config?: Record<string, string>, appTheme?: AppTheme): WidgetTheme;

package/packages/daemon/dist/widgets/lib/theme.js

@@ -0,0 +1,153 @@
+import { DEFAULT_THEME } from "../../lib/app-config.js";
+function rgba(r, g, b, a = 255) {
+    return { r, g, b, a };
+}
+const DEFAULTS = {
+    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) {
+    // 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 = [
+            [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 = [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, appTheme) {
+    const assign = (prop, token) => {
+        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, appTheme = DEFAULT_THEME) {
+    const theme = { ...DEFAULTS };
+    applyAppTheme(theme, appTheme);
+    if (!config)
+        return theme;
+    const MAP = {
+        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/dist/widgets/lib/watcher.d.ts

@@ -0,0 +1,9 @@
+export interface WatchEvent {
+    type: "create" | "update" | "delete";
+    path: string;
+}
+export declare function watchDirectory(dir: string, onChange: (events: WatchEvent[]) => void, options?: {
+    debounceMs?: number;
+    ignore?: string[];
+}): Promise<() => Promise<void>>;
+export declare function watchGitHead(dir: string, onBranchChange: () => void): Promise<(() => Promise<void>) | null>;

package/packages/daemon/dist/widgets/lib/watcher.js

@@ -0,0 +1,92 @@
+import { watch as fsWatch } from "node:fs";
+import { join, sep } from "node:path";
+// undefined = not attempted yet, null = confirmed unavailable (compiled binary).
+let parcel;
+async function loadParcel() {
+    if (parcel !== undefined)
+        return parcel;
+    try {
+        const mod = (await import("@parcel/watcher"));
+        if (typeof mod.subscribe !== "function")
+            throw new Error("no subscribe");
+        parcel = mod;
+    }
+    catch {
+        parcel = null;
+    }
+    return parcel;
+}
+function fsWatchDirectory(dir, onChange, ignore, debounceMs) {
+    const ignoreSet = new Set(ignore);
+    let timeout = null;
+    let handle = 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, onChange, options) {
+    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 = null;
+    const subscription = await native.subscribe(dir, (err, events) => {
+        if (err)
+            return;
+        if (timeout)
+            clearTimeout(timeout);
+        timeout = setTimeout(() => onChange(events), debounceMs);
+    }, { ignore });
+    return async () => {
+        if (timeout)
+            clearTimeout(timeout);
+        await subscription.unsubscribe();
+    };
+}
+export async function watchGitHead(dir, onBranchChange) {
+    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/dist/widgets/preview/index.d.ts

@@ -0,0 +1 @@
+export {};