tmux-ide 2.1.4 → 2.6.0

package/packages/daemon/dist/lib/launch-plan.js

@@ -0,0 +1,76 @@
+import { resolve } from "node:path";
+import { shellEscape } from "./shell.js";
+export function buildPaneCommand(pane) {
+    if (!pane.command)
+        return null;
+    return pane.command;
+}
+export function collectPaneStartupPlan(rows, paneMap, firstPanesOfRows, dir) {
+    let focusPane = paneMap[0][0];
+    const paneActions = [];
+    for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+        const row = rows[rowIdx];
+        const panes = row.panes ?? [];
+        for (let paneIdx = 0; paneIdx < panes.length; paneIdx++) {
+            const pane = panes[paneIdx];
+            const tmuxPane = paneMap[rowIdx][paneIdx];
+            // Derive @ide_role from pane config
+            let paneRole;
+            if (pane.role === "lead") {
+                paneRole = "lead";
+            }
+            else if (pane.role === "teammate" || pane.role === "planner") {
+                paneRole = "teammate";
+            }
+            else if (pane.type) {
+                paneRole = "widget";
+            }
+            else {
+                paneRole = "shell";
+            }
+            // Derive @ide_type from pane config
+            let paneType;
+            if (pane.type) {
+                paneType = pane.type;
+            }
+            else if (pane.command && /claude|codex/i.test(pane.command)) {
+                paneType = "agent";
+            }
+            else {
+                paneType = "shell";
+            }
+            const action = {
+                targetPane: tmuxPane,
+                title: pane.title ?? null,
+                chdir: null,
+                exports: [],
+                command: null,
+                widgetType: pane.type ?? null,
+                widgetTarget: pane.target ?? null,
+                paneRole,
+                paneType,
+            };
+            if (pane.dir && firstPanesOfRows.has(tmuxPane)) {
+                action.chdir = resolve(dir, pane.dir);
+            }
+            if (pane.env && typeof pane.env === "object") {
+                action.exports = Object.entries(pane.env).map(([key, value]) => `export ${shellEscape(key)}=${shellEscape(String(value))}`);
+            }
+            let command = buildPaneCommand(pane);
+            // Inject --name flag into Claude/Codex commands so the agent
+            // sets its own pane title to match the configured name.
+            // This is agent-agnostic: any CLI that respects --name will work.
+            if (command && pane.title && /claude|codex/i.test(command) && !command.includes("--name")) {
+                command = `${command} --name ${shellEscape(pane.title)}`;
+            }
+            if (command) {
+                action.command = command;
+            }
+            if (pane.focus) {
+                focusPane = tmuxPane;
+            }
+            paneActions.push(action);
+        }
+    }
+    return { focusPane, paneActions };
+}

package/packages/daemon/dist/lib/log.d.ts

@@ -0,0 +1,40 @@
+/** Minimal structured logger for tmux-ide daemon processes. */
+type Level = "debug" | "info" | "warn" | "error";
+export declare function setLogLevel(level: Level): void;
+export interface LogEntry {
+    ts: string;
+    level: Level;
+    component: string;
+    msg: string;
+    data?: Record<string, unknown>;
+}
+type Subscriber = (entry: LogEntry) => void;
+/** Snapshot the current ring buffer; useful for SSE backfill. */
+export declare function getLogBuffer(): ReadonlyArray<LogEntry>;
+/**
+ * Subscribe to live log entries. Returns an unsubscribe function. The
+ * handler runs synchronously inside the writer — keep it cheap; throw
+ * inside the handler is caught + logged once so one bad subscriber
+ * can't stall the daemon.
+ */
+export declare function subscribeLogs(handler: Subscriber): () => void;
+export declare const logger: {
+    debug: (component: string, msg: string, data?: Record<string, unknown>) => void;
+    info: (component: string, msg: string, data?: Record<string, unknown>) => void;
+    warn: (component: string, msg: string, data?: Record<string, unknown>) => void;
+    error: (component: string, msg: string, data?: Record<string, unknown>) => void;
+};
+/**
+ * Thin logger shim compatible with VibeTunnel's module logger API (`createLogger`-style methods).
+ * Wraps `console.*` (distinct from structured JSON `logger` above).
+ */
+export type LogMethod = (...args: unknown[]) => void;
+export declare const log: {
+    /** Alias for `info` / console.log (VibeTunnel `createLogger` compatibility). */
+    log: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+};
+export {};

package/packages/daemon/dist/lib/log.js

@@ -0,0 +1,86 @@
+/** Minimal structured logger for tmux-ide daemon processes. */
+const LEVEL_RANK = { debug: 0, info: 1, warn: 2, error: 3 };
+let minLevel = process.env.LOG_LEVEL ?? "info";
+export function setLogLevel(level) {
+    minLevel = level;
+}
+const LOG_BUFFER_SIZE = 1_000;
+const logBuffer = [];
+const subscribers = new Set();
+/** Snapshot the current ring buffer; useful for SSE backfill. */
+export function getLogBuffer() {
+    return logBuffer.slice();
+}
+/**
+ * Subscribe to live log entries. Returns an unsubscribe function. The
+ * handler runs synchronously inside the writer — keep it cheap; throw
+ * inside the handler is caught + logged once so one bad subscriber
+ * can't stall the daemon.
+ */
+export function subscribeLogs(handler) {
+    subscribers.add(handler);
+    return () => {
+        subscribers.delete(handler);
+    };
+}
+function writeStructuredLog(level, component, message, data) {
+    if (LEVEL_RANK[level] < LEVEL_RANK[minLevel])
+        return;
+    const entry = {
+        ts: new Date().toISOString(),
+        level,
+        component,
+        msg: message,
+        ...(data ? { data } : {}),
+    };
+    // Push to ring + drop oldest when over budget.
+    logBuffer.push(entry);
+    if (logBuffer.length > LOG_BUFFER_SIZE)
+        logBuffer.shift();
+    // Fan out to subscribers; isolate failures.
+    for (const sub of subscribers) {
+        try {
+            sub(entry);
+        }
+        catch (err) {
+            // Avoid recursion via the logger; write directly to stderr.
+            process.stderr.write(`[log.ts] subscriber threw: ${err instanceof Error ? err.message : String(err)}\n`);
+        }
+    }
+    // Stream form for humans tailing the process. The data field is
+    // serialized inline (matches the previous wire shape).
+    const wire = {
+        ts: entry.ts,
+        level: entry.level,
+        component: entry.component,
+        msg: entry.msg,
+    };
+    if (data)
+        Object.assign(wire, data);
+    const out = level === "error" ? process.stderr : process.stdout;
+    out.write(JSON.stringify(wire) + "\n");
+}
+export const logger = {
+    debug: (component, msg, data) => writeStructuredLog("debug", component, msg, data),
+    info: (component, msg, data) => writeStructuredLog("info", component, msg, data),
+    warn: (component, msg, data) => writeStructuredLog("warn", component, msg, data),
+    error: (component, msg, data) => writeStructuredLog("error", component, msg, data),
+};
+export const log = {
+    /** Alias for `info` / console.log (VibeTunnel `createLogger` compatibility). */
+    log: (...args) => {
+        console.log(...args);
+    },
+    info: (...args) => {
+        console.log(...args);
+    },
+    warn: (...args) => {
+        console.warn(...args);
+    },
+    error: (...args) => {
+        console.error(...args);
+    },
+    debug: (...args) => {
+        console.debug(...args);
+    },
+};

package/packages/daemon/dist/lib/output.d.ts

@@ -0,0 +1,9 @@
+import { IdeError, TmuxError } from "./errors.ts";
+import type { IdeConfig } from "../types.ts";
+export declare function printLayout(config: IdeConfig): void;
+export declare function outputError(message: string, code: string, { exitCode }?: {
+    exitCode?: number;
+}): never;
+export declare function printCommandError(error: IdeError | TmuxError, { json }?: {
+    json?: boolean;
+}): never;

package/packages/daemon/dist/lib/output.js

@@ -0,0 +1,65 @@
+import { IdeError } from "./errors.js";
+export function printLayout(config) {
+    const INNER = 40;
+    const rows = config.rows ?? [];
+    if (rows.length === 0)
+        return;
+    for (let r = 0; r < rows.length; r++) {
+        const panes = rows[r].panes ?? [];
+        const count = panes.length || 1;
+        const widths = [];
+        let remaining = INNER;
+        for (let i = 0; i < count; i++) {
+            const w = i < count - 1 ? Math.floor(INNER / count) : remaining;
+            widths.push(w);
+            remaining -= w;
+        }
+        // Top border or mid divider
+        if (r === 0) {
+            let top = "  \u250c";
+            for (let i = 0; i < count; i++) {
+                top += "\u2500".repeat(widths[i]);
+                top += i < count - 1 ? "\u252c" : "\u2510";
+            }
+            console.log(top);
+        }
+        else {
+            console.log("  \u251c" + "\u2500".repeat(INNER + count - 1) + "\u2524");
+        }
+        // Content line
+        const sizeLabel = rows[r].size ?? "";
+        let line = "  \u2502";
+        for (let i = 0; i < count; i++) {
+            const title = panes[i]?.title ?? "";
+            const w = widths[i];
+            const pad = Math.max(0, w - title.length);
+            const left = Math.floor(pad / 2);
+            const right = pad - left;
+            line += " ".repeat(left) + title + " ".repeat(right) + "\u2502";
+        }
+        if (sizeLabel)
+            line += "  " + sizeLabel;
+        console.log(line);
+        // Bottom border (last row only)
+        if (r === rows.length - 1) {
+            let bot = "  \u2514";
+            for (let i = 0; i < count; i++) {
+                bot += "\u2500".repeat(widths[i]);
+                bot += i < count - 1 ? "\u2534" : "\u2518";
+            }
+            console.log(bot);
+        }
+    }
+}
+export function outputError(message, code, { exitCode = 1 } = {}) {
+    throw new IdeError(message, { code, exitCode });
+}
+export function printCommandError(error, { json = false } = {}) {
+    if (json) {
+        console.error(JSON.stringify(error.toJSON(), null, 2));
+    }
+    else {
+        console.error(error.message);
+    }
+    process.exit(error.exitCode ?? 1);
+}

package/packages/daemon/dist/lib/project-init-runner.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Run `tmux-ide init [--template <id>]` in a target directory and stream the
+ * output line-by-line. Used by `POST /api/projects/init` so the dashboard can
+ * scaffold new projects from the UI.
+ *
+ * The spawn helper is pluggable so tests can drive the runner without
+ * actually shelling out.
+ */
+import { type ChildProcessWithoutNullStreams } from "node:child_process";
+/**
+ * The minimal contract of `child_process.spawn` we depend on. Tests pass in
+ * a synthetic implementation that emits lines deterministically.
+ */
+export type SpawnFn = (command: string, args: string[], options: {
+    cwd: string;
+}) => ChildProcessWithoutNullStreams;
+export interface InitRunnerOptions {
+    template?: string;
+    cwd: string;
+    onChunk: (chunk: string) => void;
+    /** Override for tests. */
+    spawnFn?: SpawnFn;
+    /** Defaults to 30s. */
+    timeoutMs?: number;
+    /** The binary to run. Defaults to `tmux-ide`; tests pin to a no-op. */
+    command?: string;
+}
+export declare class ProjectInitTimeoutError extends Error {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+export declare class ProjectInitFailedError extends Error {
+    readonly exitCode: number | null;
+    readonly stderr: string;
+    constructor(exitCode: number | null, stderr: string);
+}
+/**
+ * Spawn `tmux-ide init` and resolve when it exits. Streams stdout+stderr
+ * through `onChunk` line-by-line so callers can fan them out over WebSocket.
+ *
+ * Resolves with `{ ok: true }` on exit code 0, rejects with
+ * `ProjectInitFailedError` (non-zero) or `ProjectInitTimeoutError` (>30s).
+ */
+export declare function runInit(options: InitRunnerOptions): Promise<{
+    ok: true;
+}>;

package/packages/daemon/dist/lib/project-init-runner.js

@@ -0,0 +1,117 @@
+/**
+ * Run `tmux-ide init [--template <id>]` in a target directory and stream the
+ * output line-by-line. Used by `POST /api/projects/init` so the dashboard can
+ * scaffold new projects from the UI.
+ *
+ * The spawn helper is pluggable so tests can drive the runner without
+ * actually shelling out.
+ */
+import { spawn } from "node:child_process";
+const DEFAULT_TIMEOUT_MS = 30_000;
+export class ProjectInitTimeoutError extends Error {
+    timeoutMs;
+    constructor(timeoutMs) {
+        super(`tmux-ide init timed out after ${timeoutMs}ms`);
+        this.name = "ProjectInitTimeoutError";
+        this.timeoutMs = timeoutMs;
+    }
+}
+export class ProjectInitFailedError extends Error {
+    exitCode;
+    stderr;
+    constructor(exitCode, stderr) {
+        super(`tmux-ide init exited with code ${exitCode ?? "(killed)"}: ${stderr || "no stderr"}`);
+        this.name = "ProjectInitFailedError";
+        this.exitCode = exitCode;
+        this.stderr = stderr;
+    }
+}
+/**
+ * Buffer stream chunks into newline-delimited lines, emit each line through
+ * `onChunk`. Returns a `flush()` to drain any trailing partial line on close.
+ */
+function lineStreamer(onChunk) {
+    let pending = "";
+    return {
+        push(text) {
+            pending += text;
+            let newline = pending.indexOf("\n");
+            while (newline >= 0) {
+                const line = pending.slice(0, newline).replace(/\r$/, "");
+                pending = pending.slice(newline + 1);
+                onChunk(line);
+                newline = pending.indexOf("\n");
+            }
+        },
+        flush() {
+            if (pending.length === 0)
+                return;
+            onChunk(pending.replace(/\r$/, ""));
+            pending = "";
+        },
+    };
+}
+/**
+ * Spawn `tmux-ide init` and resolve when it exits. Streams stdout+stderr
+ * through `onChunk` line-by-line so callers can fan them out over WebSocket.
+ *
+ * Resolves with `{ ok: true }` on exit code 0, rejects with
+ * `ProjectInitFailedError` (non-zero) or `ProjectInitTimeoutError` (>30s).
+ */
+export async function runInit(options) {
+    const spawnFn = options.spawnFn ?? spawn;
+    const command = options.command ?? "tmux-ide";
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const args = ["init"];
+    if (options.template)
+        args.push("--template", options.template);
+    const child = spawnFn(command, args, { cwd: options.cwd });
+    const stderrStreamer = lineStreamer(options.onChunk);
+    const stdoutStreamer = lineStreamer(options.onChunk);
+    let stderrBuffer = "";
+    child.stdout.setEncoding?.("utf-8");
+    child.stderr.setEncoding?.("utf-8");
+    child.stdout.on("data", (data) => {
+        stdoutStreamer.push(typeof data === "string" ? data : data.toString("utf-8"));
+    });
+    child.stderr.on("data", (data) => {
+        const text = typeof data === "string" ? data : data.toString("utf-8");
+        stderrBuffer += text;
+        stderrStreamer.push(text);
+    });
+    return new Promise((resolveResult, reject) => {
+        let timer = null;
+        let settled = false;
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            stdoutStreamer.flush();
+            stderrStreamer.flush();
+            fn();
+        };
+        timer = setTimeout(() => {
+            try {
+                child.kill("SIGKILL");
+            }
+            catch {
+                // child may already be gone
+            }
+            settle(() => reject(new ProjectInitTimeoutError(timeoutMs)));
+        }, timeoutMs);
+        timer.unref?.();
+        child.on("error", (err) => {
+            settle(() => reject(err));
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                settle(() => resolveResult({ ok: true }));
+            }
+            else {
+                settle(() => reject(new ProjectInitFailedError(code, stderrBuffer.trim())));
+            }
+        });
+    });
+}

package/packages/daemon/dist/lib/project-inspect.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Project inspect — looks at an arbitrary directory and reports whether it
+ * has an `ide.yml`, basic git identity, and the detected stack signals from
+ * `src/detect.ts`. Crucially, this is registry-agnostic: it never touches
+ * `~/.tmux-ide/projects.json`, so the dashboard can probe directories the
+ * user is just considering before deciding to register them.
+ *
+ * The git + ide.yml bits delegate to `probeProject` so we don't duplicate
+ * the timeout-bounded git invocations. The stack detection delegates to
+ * `detectStack` from `src/detect.ts` so the wire format stays in sync with
+ * `tmux-ide detect`.
+ */
+import type { ProjectInspect } from "../schemas/inspect.ts";
+import { type ProbeIo } from "./project-probe.ts";
+export declare class InspectDirNotFoundError extends Error {
+    readonly code = "DIR_NOT_FOUND";
+    constructor(dir: string);
+}
+export interface InspectIo {
+    exists?: (path: string) => boolean;
+    probeIo?: ProbeIo;
+}
+/**
+ * Inspect a directory and return identity + detected stack. Throws
+ * `InspectDirNotFoundError` if the directory doesn't exist; otherwise
+ * never throws (probe + detect both swallow internal failures).
+ */
+export declare function inspectProject(dir: string, io?: InspectIo): Promise<ProjectInspect>;

package/packages/daemon/dist/lib/project-inspect.js

@@ -0,0 +1,67 @@
+/**
+ * Project inspect — looks at an arbitrary directory and reports whether it
+ * has an `ide.yml`, basic git identity, and the detected stack signals from
+ * `src/detect.ts`. Crucially, this is registry-agnostic: it never touches
+ * `~/.tmux-ide/projects.json`, so the dashboard can probe directories the
+ * user is just considering before deciding to register them.
+ *
+ * The git + ide.yml bits delegate to `probeProject` so we don't duplicate
+ * the timeout-bounded git invocations. The stack detection delegates to
+ * `detectStack` from `src/detect.ts` so the wire format stays in sync with
+ * `tmux-ide detect`.
+ */
+import { existsSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import { detectStack } from "../detect.js";
+import { probeProject } from "./project-probe.js";
+export class InspectDirNotFoundError extends Error {
+    code = "DIR_NOT_FOUND";
+    constructor(dir) {
+        super(`Directory "${dir}" does not exist`);
+        this.name = "InspectDirNotFoundError";
+    }
+}
+const KNOWN_PACKAGE_MANAGERS = new Set(["pnpm", "npm", "yarn", "bun"]);
+function narrowPackageManager(raw) {
+    if (!raw)
+        return null;
+    return KNOWN_PACKAGE_MANAGERS.has(raw) ? raw : null;
+}
+/**
+ * Compute a sensible test command from the detected stack. We don't have a
+ * dedicated test detector in `detectStack`, so we compose one from the
+ * package manager — best-effort, can be edited by the user in the wizard.
+ */
+function inferTestCommand(packageManager) {
+    if (!packageManager)
+        return null;
+    return packageManager === "npm" ? "npm test" : `${packageManager} test`;
+}
+/**
+ * Inspect a directory and return identity + detected stack. Throws
+ * `InspectDirNotFoundError` if the directory doesn't exist; otherwise
+ * never throws (probe + detect both swallow internal failures).
+ */
+export async function inspectProject(dir, io = {}) {
+    const exists = io.exists ?? existsSync;
+    const absoluteDir = isAbsolute(dir) ? dir : resolve(dir);
+    if (!exists(absoluteDir)) {
+        throw new InspectDirNotFoundError(absoluteDir);
+    }
+    const probe = await probeProject(absoluteDir, io.probeIo);
+    const stack = detectStack(absoluteDir);
+    const detected = {
+        packageManager: narrowPackageManager(stack.packageManager),
+        frameworks: stack.frameworks,
+        devCommand: stack.devCommand,
+        testCommand: inferTestCommand(stack.packageManager),
+    };
+    return {
+        name: probe.name,
+        dir: probe.dir,
+        hasIdeYml: probe.hasIdeYml,
+        gitOrigin: probe.gitOrigin,
+        gitBranch: probe.gitBranch,
+        detected,
+    };
+}

package/packages/daemon/dist/lib/project-onboard.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Project onboard — composes a sensible `ide.yml` from a small set of
+ * inputs (project name, agent count, optional dev/test commands) and
+ * writes it to disk so the project can be registered.
+ *
+ * `composeIdeYml` is the pure-logic bit (string in → string out) so the
+ * shape of the generated config is exhaustively unit-tested without
+ * touching the filesystem. The wrapper around `writeConfig` lives in the
+ * server route, which calls this function and then `registerProject`.
+ */
+import type { IdeConfig } from "../schemas/ide-config.ts";
+export declare class OnboardConflictError extends Error {
+    readonly code = "IDE_YML_EXISTS";
+    constructor(path: string);
+}
+export declare class OnboardInvalidInputError extends Error {
+    readonly code = "INVALID_INPUT";
+    constructor(message: string);
+}
+export interface ComposeIdeYmlInput {
+    /** Final project name written to the `name:` field. */
+    name: string;
+    /** 1, 2, or 3 — how many Claude panes to put in the top row. */
+    agents: number;
+    /**
+     * Optional per-agent pane titles. When provided, length must equal
+     * `agents`; otherwise it's ignored and the canonical defaults are used
+     * (`Lead`/`Teammate N` for team layouts, `Claude N` for solo).
+     */
+    agentNames?: string[];
+    /** Dev server command. `null` / undefined → no dev pane. */
+    devCommand?: string | null;
+    /** Test command. Currently unused in the generated layout but kept for future. */
+    testCommand?: string | null;
+    /** Lint command. Currently unused in the generated layout but kept for future. */
+    lintCommand?: string | null;
+}
+/**
+ * Build the `IdeConfig` value the wizard should write. Pure: same input →
+ * same output, no io.
+ *
+ * Layout shape:
+ *   - Row 0 (70%): N Claude panes, first focused. When `agents > 1`, the
+ *     `team:` block is added so Claude Code launches with team mode.
+ *   - Row 1 (30%): Dev pane (if `devCommand` set) + Shell pane.
+ */
+export declare function composeIdeYmlConfig(input: ComposeIdeYmlInput): IdeConfig;
+/**
+ * Render a composed `IdeConfig` as YAML. Wrapper over `js-yaml` with the
+ * same options used elsewhere so the output shape is identical.
+ */
+export declare function composeIdeYml(input: ComposeIdeYmlInput): string;
+/**
+ * Reject onboarding when `ide.yml` already exists. The caller writes the
+ * file separately via `writeConfig`; this helper exists so the route can
+ * 409 cleanly without ever overwriting user content.
+ */
+export declare function assertNoExistingIdeYml(dir: string, exists?: (path: string) => boolean): void;