tmux-ide 1.2.1 → 1.3.1

package/dist/init.js

@@ -0,0 +1,67 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve, basename, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+import { detectStack, suggestConfig } from "./detect.js";
+import { outputError, printLayout } from "./lib/output.js";
+export async function init({ template, json, } = {}) {
+    const dir = process.cwd();
+    const configPath = resolve(dir, "ide.yml");
+    if (existsSync(configPath)) {
+        outputError("ide.yml already exists in this directory", "EXISTS");
+    }
+    // If a specific template is requested, use it
+    if (template) {
+        const templatePath = resolve(__dirname, "..", "templates", `${template}.yml`);
+        if (!existsSync(templatePath)) {
+            outputError(`Template "${template}" not found`, "NOT_FOUND");
+        }
+        let content = readFileSync(templatePath, "utf-8");
+        const name = basename(dir);
+        content = content.replace(/^name: .+/m, `name: ${name}`);
+        writeFileSync(configPath, content);
+        if (json) {
+            console.log(JSON.stringify({ created: true, template, name }));
+        }
+        else {
+            console.log(`Created ide.yml from "${template}" template for "${name}"`);
+            const yaml = (await import("js-yaml")).default;
+            printLayout(yaml.load(content));
+        }
+        return;
+    }
+    // Smart detection
+    const detected = detectStack(dir);
+    const name = basename(dir);
+    if (detected.frameworks.length > 0) {
+        // Use detected stack to generate config
+        const config = suggestConfig(dir, detected);
+        const yaml = (await import("js-yaml")).default;
+        writeFileSync(configPath, yaml.dump(config, { lineWidth: -1, noRefs: true, quotingType: '"' }));
+        const desc = detected.frameworks.join(" + ");
+        if (json) {
+            console.log(JSON.stringify({ created: true, detected: detected.frameworks, name }));
+        }
+        else {
+            console.log(`Detected ${desc}. Created ide.yml for "${name}".`);
+            printLayout(config);
+            console.log("Edit it to customize, then run: tmux-ide");
+        }
+    }
+    else {
+        // Fallback to default template
+        const templatePath = resolve(__dirname, "..", "templates", "default.yml");
+        let content = readFileSync(templatePath, "utf-8");
+        content = content.replace(/^name: .+/m, `name: ${name}`);
+        writeFileSync(configPath, content);
+        if (json) {
+            console.log(JSON.stringify({ created: true, template: "default", name }));
+        }
+        else {
+            console.log(`Created ide.yml for "${name}"`);
+            const yaml = (await import("js-yaml")).default;
+            printLayout(yaml.load(content));
+            console.log("Edit it to configure your workspace, then run: tmux-ide");
+        }
+    }
+}

package/dist/inspect.d.ts

@@ -0,0 +1,54 @@
+import { listPanes } from "./lib/tmux.ts";
+import type { IdeConfig } from "./types.ts";
+interface ResolvedPane {
+    index: number;
+    title: string | null;
+    command: string | null;
+    dir: string;
+    size: string | null;
+    focus: boolean;
+    role: string | null;
+    task: string | null;
+    env: Record<string, unknown>;
+}
+interface ResolvedRow {
+    index: number;
+    size: string | null;
+    panes: ResolvedPane[];
+}
+interface Inspection {
+    dir: string;
+    configPath: string;
+    valid: boolean;
+    errors: string[];
+    session: string;
+    before: string | null;
+    summary: {
+        rows: number;
+        panes: number;
+        focus: string | null;
+    };
+    team: IdeConfig["team"] | null;
+    theme: IdeConfig["theme"] | null;
+    focus: {
+        row: number;
+        pane: number;
+        title: string | null;
+    } | null;
+    rows: ResolvedRow[];
+    rawConfig: IdeConfig;
+    tmux: {
+        running: boolean;
+        panes: ReturnType<typeof listPanes>;
+    };
+}
+export declare function buildInspection(dir: string, { config, configPath, running, panes, }: {
+    config: IdeConfig;
+    configPath: string;
+    running: boolean;
+    panes: ReturnType<typeof listPanes>;
+}): Inspection;
+export declare function inspect(targetDir: string | undefined, { json }?: {
+    json?: boolean;
+}): Promise<void>;
+export {};

package/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 "./lib/tmux.js";
+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/dist/launch.d.ts

@@ -0,0 +1,22 @@
+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 }?: {
+    json?: boolean;
+    attach?: boolean;
+}): Promise<void>;
+export {};

package/dist/launch.js

@@ -0,0 +1,174 @@
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+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, setPaneTitle, setSessionEnvironment, setSessionVariable, splitPane, startSessionMonitor, } from "./lib/tmux.js";
+import { validateConfig } from "./validate.js";
+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;
+}
+function runBeforeHook(command, dir) {
+    if (!command)
+        return;
+    console.log(`Running: ${command}`);
+    try {
+        execSync(command, { cwd: dir, stdio: "inherit" });
+    }
+    catch {
+        outputError(`The before hook failed: ${command}`, "BEFORE_HOOK_FAILED");
+    }
+}
+export async function launch(targetDir, { json = false, attach = true } = {}) {
+    const dir = resolve(targetDir ?? ".");
+    const config = loadLaunchConfig(dir);
+    const { name: fallbackName } = getSessionName(dir);
+    const session = config.name ?? fallbackName;
+    const 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...`);
+        }
+        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);
+        }
+        if (action.chdir) {
+            sendLiteral(action.targetPane, `cd ${action.chdir}`);
+        }
+        for (const exportCommand of action.exports) {
+            sendLiteral(action.targetPane, exportCommand);
+        }
+        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));
+    // Start background session monitor (port detection + agent status)
+    const monitorScript = resolve(dirname(fileURLToPath(import.meta.url)), "lib", "session-monitor.js");
+    startSessionMonitor(session, monitorScript);
+    // Focus the correct pane
+    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"})...`);
+    // Attach
+    if (attach) {
+        attachSession(session);
+    }
+}

package/dist/lib/dot-path.d.ts

@@ -0,0 +1,2 @@
+export declare function getByPath(obj: Record<string, any>, path: string): unknown;
+export declare function setByPath(obj: Record<string, any>, path: string, value: unknown): void;

package/dist/lib/dot-path.js

@@ -0,0 +1,17 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export function getByPath(obj, path) {
+    return path.split(".").reduce((o, k) => o?.[k], obj);
+}
+export function setByPath(obj, path, value) {
+    const keys = path.split(".");
+    const last = keys.pop();
+    let i = 0;
+    const target = keys.reduce((o, k) => {
+        const nextKey = keys[i + 1] ?? last;
+        if (o[k] === undefined)
+            o[k] = /^\d+$/.test(nextKey) ? [] : {};
+        i++;
+        return o[k];
+    }, obj);
+    target[last] = value;
+}

package/dist/lib/errors.d.ts

@@ -0,0 +1,29 @@
+export declare class IdeError extends Error {
+    code: string | undefined;
+    exitCode: number;
+    constructor(message: string, { code, exitCode, cause }?: {
+        code?: string;
+        exitCode?: number;
+        cause?: Error;
+    });
+    toJSON(): {
+        error: string;
+        code: string | undefined;
+        cause?: string;
+    };
+}
+export declare class ConfigError extends IdeError {
+    constructor(message: string, code: string, { cause }?: {
+        cause?: Error;
+    });
+}
+export declare class TmuxError extends IdeError {
+    constructor(message: string, code: string, { cause }?: {
+        cause?: Error;
+    });
+}
+export declare class SessionError extends IdeError {
+    constructor(message: string, code: string, { cause }?: {
+        cause?: Error;
+    });
+}

package/dist/lib/errors.js

@@ -0,0 +1,37 @@
+export class IdeError extends Error {
+    code;
+    exitCode;
+    constructor(message, { code, exitCode = 1, cause } = {}) {
+        super(message, { cause });
+        this.name = "IdeError";
+        this.code = code;
+        this.exitCode = exitCode;
+    }
+    toJSON() {
+        const obj = {
+            error: this.message,
+            code: this.code,
+        };
+        if (this.cause)
+            obj.cause = this.cause.message;
+        return obj;
+    }
+}
+export class ConfigError extends IdeError {
+    constructor(message, code, { cause } = {}) {
+        super(message, { code, exitCode: 1, cause });
+        this.name = "ConfigError";
+    }
+}
+export class TmuxError extends IdeError {
+    constructor(message, code, { cause } = {}) {
+        super(message, { code, exitCode: 1, cause });
+        this.name = "TmuxError";
+    }
+}
+export class SessionError extends IdeError {
+    constructor(message, code, { cause } = {}) {
+        super(message, { code, exitCode: 1, cause });
+        this.name = "SessionError";
+    }
+}

package/dist/lib/launch-plan.d.ts

@@ -0,0 +1,6 @@
+import type { Pane, Row, PaneAction } from "../types.ts";
+export declare function buildPaneCommand(pane: Pane): string | null;
+export declare function collectPaneStartupPlan(rows: Row[], paneMap: string[][], firstPanesOfRows: Set<string>, dir: string): {
+    focusPane: string;
+    paneActions: PaneAction[];
+};

package/dist/lib/launch-plan.js

@@ -0,0 +1,40 @@
+import { resolve } from "node:path";
+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];
+            const action = {
+                targetPane: tmuxPane,
+                title: pane.title ?? null,
+                chdir: null,
+                exports: [],
+                command: null,
+            };
+            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 ${key}=${value}`);
+            }
+            const command = buildPaneCommand(pane);
+            if (command) {
+                action.command = command;
+            }
+            if (pane.focus) {
+                focusPane = tmuxPane;
+            }
+            paneActions.push(action);
+        }
+    }
+    return { focusPane, paneActions };
+}

package/dist/lib/output.d.ts

@@ -0,0 +1,9 @@
+import { IdeError } 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, { json }?: {
+    json?: boolean;
+}): never;

package/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/dist/lib/session-monitor.d.ts

@@ -0,0 +1,12 @@
+interface MonitorPane {
+    id: string;
+    pid: string;
+    cmd?: string;
+    title?: string;
+}
+export declare function computePortPanes(panes: MonitorPane[], { listeners, tree }?: {
+    listeners?: Set<string>;
+    tree?: Map<string, string>;
+}): Set<string>;
+export declare function computeAgentStates(panes: MonitorPane[]): Map<string, "busy" | "idle" | null>;
+export {};