tmux-ide 2.1.4 → 2.6.0

package/packages/daemon/dist/inspect.js

@@ -0,0 +1,118 @@
+import { resolve, basename } from "node:path";
+import { readConfig } from "./lib/yaml-io.js";
+import { validateConfig } from "./validate.js";
+import { outputError } from "./lib/output.js";
+import { getSessionState, listPanes } from "@tmux-ide/tmux-bridge";
+export function buildInspection(dir, { config, configPath, running, panes, }) {
+    const errors = validateConfig(config);
+    const rows = Array.isArray(config?.rows) ? config.rows : [];
+    const resolvedRows = rows.map((row, rowIndex) => ({
+        index: rowIndex,
+        size: row.size ?? null,
+        panes: (Array.isArray(row?.panes) ? row.panes : []).map((pane, paneIndex) => ({
+            index: paneIndex,
+            title: pane.title ?? null,
+            command: pane.command ?? null,
+            dir: pane.dir ?? ".",
+            size: pane.size ?? null,
+            focus: pane.focus === true,
+            role: pane.role ?? null,
+            task: pane.task ?? null,
+            env: pane.env ?? {},
+        })),
+    }));
+    const focusPane = resolvedRows
+        .flatMap((row) => row.panes.map((pane) => ({ row: row.index, pane })))
+        .find(({ pane }) => pane.focus) ?? null;
+    const session = config?.name ?? basename(dir);
+    return {
+        dir,
+        configPath,
+        valid: errors.length === 0,
+        errors,
+        session,
+        before: config?.before ?? null,
+        summary: {
+            rows: resolvedRows.length,
+            panes: resolvedRows.reduce((sum, row) => sum + row.panes.length, 0),
+            focus: focusPane ? `rows.${focusPane.row}.panes.${focusPane.pane.index}` : null,
+        },
+        team: config?.team ?? null,
+        theme: config?.theme ?? null,
+        focus: focusPane
+            ? {
+                row: focusPane.row,
+                pane: focusPane.pane.index,
+                title: focusPane.pane.title,
+            }
+            : null,
+        rows: resolvedRows,
+        rawConfig: config,
+        tmux: {
+            running,
+            panes,
+        },
+    };
+}
+export async function inspect(targetDir, { json } = {}) {
+    const dir = resolve(targetDir ?? ".");
+    let config;
+    let configPath;
+    try {
+        ({ config, configPath } = readConfig(dir));
+    }
+    catch (error) {
+        outputError(`Cannot read ide.yml: ${error.message}`, "READ_ERROR");
+        return;
+    }
+    const session = config?.name ?? basename(dir);
+    const state = getSessionState(session);
+    const panes = state.running ? listPanes(session) : [];
+    const data = buildInspection(dir, { config, configPath, running: state.running, panes });
+    if (json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    console.log(`Directory: ${data.dir}`);
+    console.log(`Config:    ${data.configPath}`);
+    console.log(`Valid:     ${data.valid ? "yes" : "no"}`);
+    console.log(`Session:   ${data.session}`);
+    console.log(`Running:   ${data.tmux.running ? "yes" : "no"}`);
+    console.log(`Rows:      ${data.summary.rows}`);
+    console.log(`Panes:     ${data.summary.panes}`);
+    console.log(`Team:      ${data.team ? data.team.name : "disabled"}`);
+    if (data.focus) {
+        console.log(`Focus:     row ${data.focus.row}, pane ${data.focus.pane}${data.focus.title ? ` (${data.focus.title})` : ""}`);
+    }
+    if (!data.valid) {
+        console.log("\nValidation Errors:");
+        for (const error of data.errors) {
+            console.log(`  - ${error}`);
+        }
+    }
+    console.log("\nResolved Layout:");
+    for (const row of data.rows) {
+        console.log(`  Row ${row.index}${row.size ? ` (${row.size})` : ""}`);
+        for (const pane of row.panes) {
+            const parts = [];
+            if (pane.title)
+                parts.push(pane.title);
+            if (pane.command)
+                parts.push(`cmd=${pane.command}`);
+            if (pane.dir && pane.dir !== ".")
+                parts.push(`dir=${pane.dir}`);
+            if (pane.role)
+                parts.push(`role=${pane.role}`);
+            if (pane.focus)
+                parts.push("focus");
+            console.log(`    - pane ${pane.index}: ${parts.join(" | ") || "shell"}`);
+        }
+    }
+    if (data.tmux.running && data.tmux.panes.length > 0) {
+        console.log("\nLive Panes:");
+        for (const pane of data.tmux.panes) {
+            const active = pane.active ? " (active)" : "";
+            console.log(`  ${pane.index}: ${pane.title} [${pane.width}x${pane.height}]${active}`);
+        }
+    }
+}

package/packages/daemon/dist/launch.d.ts

@@ -0,0 +1,23 @@
+import type { Row } from "./types.ts";
+interface SplitPaneArgs {
+    targetPane: string;
+    direction: "vertical" | "horizontal";
+    cwd: string;
+    percent: number;
+}
+export declare function waitForPaneCommand(targetPane: string, expectedCommands: string[], { attempts, delayMs, getCurrentCommand, sleep, }?: {
+    attempts?: number;
+    delayMs?: number;
+    getCurrentCommand?: (pane: string) => string;
+    sleep?: (ms: number) => void;
+}): boolean;
+export declare function buildPaneMap(rows: Row[], dir: string, rootPaneId: string, splitPaneFn: (args: SplitPaneArgs) => string): {
+    paneMap: string[][];
+    firstPanesOfRows: Set<string>;
+};
+export declare function launch(targetDir: string | undefined, { json, attach, sessionName, }?: {
+    json?: boolean;
+    attach?: boolean;
+    sessionName?: string;
+}): Promise<void>;
+export {};

package/packages/daemon/dist/launch.js

@@ -0,0 +1,250 @@
+import { resolve } from "node:path";
+import { execSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readConfig, getSessionName } from "./lib/yaml-io.js";
+import { computeSizes, toSplitPercents } from "./lib/sizes.js";
+import { outputError } from "./lib/output.js";
+import { collectPaneStartupPlan } from "./lib/launch-plan.js";
+import { buildSessionOptions } from "./lib/session-options.js";
+import { attachSession, createDetachedSession, getPaneCurrentCommand, getSessionVariable, hasSession, runSessionCommand, selectPane, sendLiteral, setPaneOption, setPaneTitle, setSessionEnvironment, setSessionVariable, splitPane, } from "@tmux-ide/tmux-bridge";
+import { validateConfig } from "./validate.js";
+import { resolveSidebarConfig } from "./tui/chrome/sidebar.js";
+import { resolveWidgetCommand } from "./widgets/resolve.js";
+import { shellEscape } from "./lib/shell.js";
+function stripWidgetPanes(rows) {
+    return rows
+        .map((row) => ({
+        ...row,
+        panes: row.panes.filter((p) => !p.type),
+    }))
+        .filter((row) => row.panes.length > 0);
+}
+function sleepMs(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function configHash(config) {
+    return createHash("sha256").update(JSON.stringify(config)).digest("hex").slice(0, 12);
+}
+export function waitForPaneCommand(targetPane, expectedCommands, { attempts = 20, delayMs = 100, getCurrentCommand = getPaneCurrentCommand, sleep = sleepMs, } = {}) {
+    const allowed = new Set(expectedCommands.map((command) => command.toLowerCase()));
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        try {
+            const current = getCurrentCommand(targetPane)?.trim().toLowerCase();
+            if (current && allowed.has(current))
+                return true;
+        }
+        catch {
+            // Fall through to retry; tmux can briefly report transitional state.
+        }
+        if (attempt < attempts - 1) {
+            sleep(delayMs);
+        }
+    }
+    return false;
+}
+export function buildPaneMap(rows, dir, rootPaneId, splitPaneFn) {
+    const rowSizes = computeSizes(rows);
+    const rowSplitPercents = toSplitPercents(rowSizes);
+    // Create all rows vertically first so each row spans the full width.
+    const rowPaneIds = [rootPaneId];
+    for (let rowIdx = 1; rowIdx < rows.length; rowIdx++) {
+        const splitFrom = rowPaneIds[rowIdx - 1];
+        const newPaneId = splitPaneFn({
+            targetPane: splitFrom,
+            direction: "vertical",
+            cwd: dir,
+            percent: rowSplitPercents[rowIdx - 1],
+        });
+        rowPaneIds.push(newPaneId);
+    }
+    const paneMap = [];
+    const firstPanesOfRows = new Set(rowPaneIds);
+    for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+        const row = rows[rowIdx];
+        const panes = row.panes ?? [];
+        const rowPaneId = rowPaneIds[rowIdx];
+        const rowPanes = [rowPaneId];
+        const paneSizes = computeSizes(panes);
+        const paneSplitPercents = toSplitPercents(paneSizes);
+        for (let paneIdx = 1; paneIdx < panes.length; paneIdx++) {
+            const pane = panes[paneIdx];
+            const targetPane = rowPanes[paneIdx - 1];
+            const paneDir = pane.dir ? resolve(dir, pane.dir) : dir;
+            const newPaneId = splitPaneFn({
+                targetPane,
+                direction: "horizontal",
+                cwd: paneDir,
+                percent: paneSplitPercents[paneIdx - 1],
+            });
+            rowPanes.push(newPaneId);
+        }
+        paneMap.push(rowPanes);
+    }
+    return { paneMap, firstPanesOfRows };
+}
+function loadLaunchConfig(dir) {
+    let config;
+    try {
+        ({ config } = readConfig(dir));
+    }
+    catch (error) {
+        if (error?.code === "ENOENT") {
+            outputError(`No ide.yml found in ${dir}. Run "tmux-ide init" or "tmux-ide detect --write" to create one.`, "CONFIG_NOT_FOUND");
+        }
+        outputError(`Cannot read ide.yml: ${error.message}`, "READ_ERROR");
+    }
+    const errors = validateConfig(config);
+    if (errors.length > 0) {
+        outputError(`Invalid ide.yml in ${dir}. Run "tmux-ide validate" for details.`, "INVALID_CONFIG");
+    }
+    return config;
+}
+/**
+ * Best-effort: adopt the session into the native chrome (status bar + switcher
+ * popup + the shared background updater). A chrome failure must NEVER break
+ * launch, so it's fully swallowed; the import is dynamic to keep the hot path
+ * clean and the data-layer graph out of the common launch flow.
+ */
+async function bestEffortAdopt(session) {
+    try {
+        const { adoptSession } = await import("./tui/chrome/statusline.js");
+        adoptSession(session);
+    }
+    catch {
+        // chrome is optional — never let it block the session
+    }
+}
+function runBeforeHook(command, dir) {
+    if (!command)
+        return;
+    console.log(`Running: ${command}`);
+    try {
+        execSync(command, { cwd: dir, stdio: "inherit", timeout: 60_000 });
+    }
+    catch {
+        outputError(`The before hook failed: ${command}`, "BEFORE_HOOK_FAILED");
+    }
+}
+export async function launch(targetDir, { json = false, attach = true, sessionName, } = {}) {
+    const dir = resolve(targetDir ?? ".");
+    const config = loadLaunchConfig(dir);
+    const { name: fallbackName } = getSessionName(dir);
+    // A `sessionName` override lets a worktree checkout run under its own session
+    // name (e.g. `app@branch`) instead of colliding with the parent repo's
+    // `config.name`; the whole flow keys off `session`, so the override threads
+    // through session creation, adoption, and drift detection unchanged.
+    const session = sessionName ?? config.name ?? fallbackName;
+    const headless = config.orchestrator?.widgets === false;
+    const rows = headless ? stripWidgetPanes(config.rows) : config.rows;
+    const theme = config.theme ?? {};
+    const team = config.team ?? null;
+    runBeforeHook(config.before, dir);
+    // If session already exists, check for config drift and attach
+    if (hasSession(session)) {
+        const currentHash = configHash(config);
+        const storedHash = getSessionVariable(session, "@config_hash");
+        const configChanged = Boolean(storedHash && currentHash !== storedHash);
+        if (json) {
+            console.log(JSON.stringify({ session, running: true, configChanged }));
+        }
+        else if (configChanged) {
+            console.log(`Session "${session}" is running but ide.yml has changed.`);
+            console.log(`Run "tmux-ide restart" to apply changes.`);
+        }
+        else {
+            console.log(`Session "${session}" is already running. Attaching...`);
+        }
+        // Keep the chrome in place across re-launches (idempotent).
+        await bestEffortAdopt(session);
+        if (attach) {
+            attachSession(session);
+        }
+        return;
+    }
+    // Get terminal dimensions
+    const cols = process.stdout.columns ?? 200;
+    const lines = process.stdout.rows ?? 50;
+    // Create session with first pane
+    const rootPaneId = createDetachedSession(session, dir, { cols, lines });
+    // Set agent teams env var if team config is present
+    if (team) {
+        setSessionEnvironment(session, "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS", "1");
+    }
+    const { paneMap, firstPanesOfRows } = buildPaneMap(rows, dir, rootPaneId, ({ targetPane, direction, cwd, percent }) => splitPane(targetPane, direction, cwd, percent));
+    const { focusPane, paneActions } = collectPaneStartupPlan(rows, paneMap, firstPanesOfRows, dir);
+    for (const action of paneActions) {
+        if (action.title) {
+            setPaneTitle(action.targetPane, action.title);
+        }
+        // Set pane identity options for discovery by orchestrator/widgets
+        setPaneOption(action.targetPane, "@ide_role", action.paneRole ?? "shell");
+        setPaneOption(action.targetPane, "@ide_name", action.title ?? "");
+        setPaneOption(action.targetPane, "@ide_type", action.paneType ?? "shell");
+        // Lock agent pane titles so Claude Code can't overwrite them
+        if (action.paneRole === "lead" || action.paneRole === "teammate") {
+            setPaneOption(action.targetPane, "allow-rename", "off");
+        }
+        if (action.chdir) {
+            sendLiteral(action.targetPane, `cd ${shellEscape(action.chdir)}`);
+        }
+        for (const exportCommand of action.exports) {
+            sendLiteral(action.targetPane, exportCommand);
+        }
+        if (action.widgetType) {
+            const widgetCmd = resolveWidgetCommand(action.widgetType, {
+                session,
+                dir,
+                target: action.widgetTarget ?? null,
+                theme: config.theme ?? null,
+            });
+            sendLiteral(action.targetPane, widgetCmd);
+        }
+        else if (action.command) {
+            sendLiteral(action.targetPane, action.command);
+        }
+    }
+    for (const command of buildSessionOptions(session, { theme })) {
+        runSessionCommand(command);
+    }
+    // Store config hash for drift detection on re-launch
+    setSessionVariable(session, "@config_hash", configHash(config));
+    // Sidebar sugar: `sidebar: true` (or `{ width }`) injects the app nav column
+    // as a full-height left split of the whole window (`-h -b -f`), built AFTER
+    // the rows so `-f` spans their combined height. Best-effort — the layout must
+    // never fail because the chrome column couldn't open.
+    const sidebar = resolveSidebarConfig(config.sidebar);
+    if (sidebar.enabled) {
+        try {
+            const { openSidebarPane } = await import("./tui/chrome/sidebar.js");
+            openSidebarPane(session, dir, sidebar.width, config.theme ?? null);
+        }
+        catch {
+            // sidebar is optional chrome — never block launch
+        }
+    }
+    // Focus the correct pane (the sidebar split above steals focus to itself).
+    selectPane(focusPane);
+    // Launch summary
+    const totalPanes = rows.reduce((sum, r) => sum + (r.panes?.length ?? 0), 0);
+    console.log(`Starting "${session}" (${rows.length} row${rows.length === 1 ? "" : "s"}, ${totalPanes} pane${totalPanes === 1 ? "" : "s"})...`);
+    // Surface the command-center URL so users know where the API lives.
+    // Read the canonical daemon info file the daemon writes on startup;
+    // tolerate its absence (daemon may still be coming up, or running
+    // sessionless). Print only when we have a real port to advertise.
+    try {
+        const { readCanonicalDaemonInfo } = await import("./lib/canonical-daemon.js");
+        const info = readCanonicalDaemonInfo();
+        if (info) {
+            console.log(`Command center: http://${info.bindHostname}:${info.port}/`);
+        }
+    }
+    catch {
+        // Non-fatal — the daemon may still be coming up.
+    }
+    // Adopt into the native chrome so the new session shows the tmux-ide bar.
+    await bestEffortAdopt(session);
+    // Attach
+    if (attach) {
+        attachSession(session);
+    }
+}

package/packages/daemon/dist/lib/active-projects.d.ts

@@ -0,0 +1,12 @@
+export interface ProjectActivationOptions {
+    orchestrate?: boolean;
+}
+export interface ProjectActivationBackend {
+    activateProject(name: string, options?: ProjectActivationOptions): Promise<void>;
+    deactivateProject(name: string): Promise<void>;
+}
+export declare function setActivationBackend(next: ProjectActivationBackend | null): void;
+export declare function isProjectActive(name: string): boolean;
+export declare function activateProject(name: string, options?: ProjectActivationOptions): Promise<void>;
+export declare function deactivateProject(name: string): Promise<void>;
+export declare function listActiveProjects(): string[];

package/packages/daemon/dist/lib/active-projects.js

@@ -0,0 +1,35 @@
+let backend = null;
+const active = new Set();
+export function setActivationBackend(next) {
+    backend = next;
+    active.clear();
+}
+export function isProjectActive(name) {
+    return active.has(name);
+}
+export async function activateProject(name, options = {}) {
+    if (active.has(name) && !options.orchestrate)
+        return;
+    if (!backend) {
+        throw new Error("No active-project backend is registered");
+    }
+    await backend.activateProject(name, options);
+    active.add(name);
+}
+export async function deactivateProject(name) {
+    if (!active.has(name))
+        return;
+    if (!backend) {
+        active.delete(name);
+        return;
+    }
+    try {
+        await backend.deactivateProject(name);
+    }
+    finally {
+        active.delete(name);
+    }
+}
+export function listActiveProjects() {
+    return Array.from(active);
+}

package/packages/daemon/dist/lib/agent-discovery.d.ts

@@ -0,0 +1,43 @@
+/** A coding agent tmux-ide knows how to detect. */
+export interface KnownAgent {
+    /** Stable id — also the `tmux-ide integration <install|status> <id>` selector. */
+    id: string;
+    /** The binary we probe for on PATH. */
+    bin: string;
+    /** True → tmux-ide ships a lifecycle-integration installer for this agent. */
+    integration: boolean;
+}
+/**
+ * The agents tmux-ide recognizes. `integration: true` means we HAVE an installer
+ * (a real lifecycle hook → ground-truth pane state); the rest are detected via
+ * screen-manifest scraping only, with no lifecycle hook yet.
+ */
+export declare const KNOWN_AGENTS: readonly KnownAgent[];
+/** One probed agent: its registry facts plus what the PATH/integration probe found. */
+export interface DiscoveredAgent {
+    id: string;
+    bin: string;
+    /** Whether tmux-ide ships an installer for this agent (copied from the registry). */
+    integration: boolean;
+    /** Absolute path to the binary (first `which` hit), or null when absent from PATH. */
+    path: string | null;
+    /**
+     * The INTEGRATION-installed state: true only for an agent we integrate whose
+     * integration is actually installed. Always false for agents we don't
+     * integrate (there's nothing to install) and for any agent absent from PATH.
+     */
+    installed: boolean;
+}
+/** Resolve a binary to its absolute path, or null. Must never throw. */
+export type WhichRunner = (bin: string) => string | null;
+/** Report whether a given agent's integration is installed. Must never throw. */
+export type IntegrationProbe = (agentId: string) => boolean;
+/**
+ * Probe the current PATH for every {@link KNOWN_AGENTS} entry. For agents we
+ * integrate, `installed` carries the real integration status; for the rest it's
+ * always false (nothing to install). Both the PATH probe and the integration
+ * check are injectable for tests; this never throws.
+ */
+export declare function discoverAgents(which?: WhichRunner, isInstalled?: IntegrationProbe): DiscoveredAgent[];
+/** The subset of discovered agents actually present on PATH (path resolved). */
+export declare function presentAgents(agents: DiscoveredAgent[]): DiscoveredAgent[];

package/packages/daemon/dist/lib/agent-discovery.js

@@ -0,0 +1,85 @@
+/**
+ * Agent auto-discovery — which coding agents live on THIS machine, and do we
+ * have a lifecycle integration for each.
+ *
+ * The onboarding gap this closes: tmux-ide can hook Claude Code's lifecycle for
+ * ground-truth pane state (`tmux-ide integration install claude`), but nothing
+ * told the user that agent was even detected. Discovery makes the tool notice —
+ * doctor lists what it found, the first adopt offers the integration.
+ *
+ * {@link KNOWN_AGENTS} is the pure registry: each entry names an agent, the
+ * binary we probe for, and whether tmux-ide ships an installer for it
+ * (`integration: true` → we can hook its lifecycle; `false` → we only have
+ * screen-manifest detection). {@link discoverAgents} probes the current PATH via
+ * an injectable which-runner and, for agents we integrate, reports whether that
+ * integration is installed. Both the probe and the integration check are
+ * injectable so tests never shell out or read the real settings.
+ */
+import { execFileSync } from "node:child_process";
+import { claudeIntegrationStatus } from "../tui/integrations/claude.js";
+/**
+ * The agents tmux-ide recognizes. `integration: true` means we HAVE an installer
+ * (a real lifecycle hook → ground-truth pane state); the rest are detected via
+ * screen-manifest scraping only, with no lifecycle hook yet.
+ */
+export const KNOWN_AGENTS = [
+    { id: "claude", bin: "claude", integration: true },
+    { id: "codex", bin: "codex", integration: false },
+    { id: "opencode", bin: "opencode", integration: false },
+    { id: "gemini", bin: "gemini", integration: false },
+    { id: "aider", bin: "aider", integration: false },
+];
+/**
+ * Default which-runner: `which <bin>`, hard-capped at 2s, swallowing every
+ * failure (not-found, missing `which`, timeout) into `null`. Returns the FIRST
+ * line only — a shell function/alias shadowing plus a real binary can make
+ * `which` emit several.
+ */
+const defaultWhich = (bin) => {
+    try {
+        const out = execFileSync("which", [bin], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 2000,
+        }).trim();
+        if (out.length === 0)
+            return null;
+        return out.split("\n")[0].trim() || null;
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Default integration probe: only `claude` has an installer, so only it can be
+ * "installed". Reads the real Claude settings; any failure degrades to false so
+ * discovery never throws.
+ */
+const defaultIntegrationProbe = (agentId) => {
+    if (agentId !== "claude")
+        return false;
+    try {
+        return claudeIntegrationStatus().installed;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Probe the current PATH for every {@link KNOWN_AGENTS} entry. For agents we
+ * integrate, `installed` carries the real integration status; for the rest it's
+ * always false (nothing to install). Both the PATH probe and the integration
+ * check are injectable for tests; this never throws.
+ */
+export function discoverAgents(which = defaultWhich, isInstalled = defaultIntegrationProbe) {
+    return KNOWN_AGENTS.map((agent) => {
+        const path = which(agent.bin);
+        const present = path !== null;
+        const installed = present && agent.integration ? isInstalled(agent.id) : false;
+        return { id: agent.id, bin: agent.bin, integration: agent.integration, path, installed };
+    });
+}
+/** The subset of discovered agents actually present on PATH (path resolved). */
+export function presentAgents(agents) {
+    return agents.filter((a) => a.path !== null);
+}