tmux-ide 2.7.0 → 2.9.0-beta.11

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

@@ -1,27 +0,0 @@
-import { type PaneInfo } from "./widgets/lib/pane-comms.ts";
-export declare const LONG_MESSAGE_THRESHOLD = 150;
-/**
- * Write a long message to a dispatch file and return the short trigger command.
- * Returns null if message is short enough to send directly.
- */
-export declare function writeDispatchFile(dir: string, paneId: string, message: string): {
-    filePath: string;
-    triggerCmd: string;
-} | null;
-interface SendOptions {
-    json?: boolean;
-    to?: string;
-    message?: string;
-    noEnter?: boolean;
-}
-/**
- * Resolve a target string to a pane. Priority:
- * 1. Exact pane ID (%N)
- * 2. @ide_name match
- * 3. Exact title match
- * 4. Role match (lead, teammate, planner)
- * 5. Case-insensitive partial title match
- */
-export declare function resolvePane(panes: PaneInfo[], target: string): PaneInfo | null;
-export declare function send(targetDir: string | undefined, opts: SendOptions): Promise<void>;
-export {};

package/packages/daemon/dist/server/index.d.ts

@@ -1,10 +0,0 @@
-import { type Server } from "node:http";
-import { Hono } from "hono";
-export interface StartedTmuxIdeServer {
-    port: number;
-    server: Server;
-    close(): Promise<void>;
-}
-export declare function resolvePort(port?: number): number;
-export declare function createApp(): Hono;
-export declare function start(port?: number): Promise<StartedTmuxIdeServer>;

package/packages/daemon/dist/server/pty-bridge.d.ts

@@ -1,174 +0,0 @@
-import { EventEmitter } from "node:events";
-import * as fs from "node:fs";
-import type { PtyAdapter } from "../terminal/PtyAdapter.ts";
-/**
- * Test-only spawn signature that historic tests injected before T087
- * (see `options.pty?.spawn`). We keep it as a compat shim — anything more
- * intrusive (e.g. a full `pty.IPty` stub) should switch to
- * `options.ptyAdapter` (a `PtyAdapter` from `terminal/MockPtyAdapter.ts`).
- */
-type LegacyPtySpawn = (shell: string, args: string[], opts: {
-    name?: string;
-    cols: number;
-    rows: number;
-    cwd: string;
-    env: Record<string, string>;
-    encoding: null | "utf8";
-}) => {
-    pid: number;
-    cols?: number;
-    rows?: number;
-    onData(cb: (data: unknown) => void): {
-        dispose(): void;
-    };
-    onExit(cb: (evt: {
-        exitCode: number;
-        signal?: number | null;
-    }) => void): {
-        dispose(): void;
-    };
-    write(data: string | Buffer): void;
-    resize(cols: number, rows: number): void;
-    kill(signal?: NodeJS.Signals | string): void;
-};
-export interface PtyExit {
-    code: number;
-    signal: number | null;
-}
-export type TerminalCwdErrorReason = "notFound" | "notDirectory" | "statFailed";
-/**
- * Typed error thrown when a requested terminal cwd cannot be used to
- * spawn a PTY. Carries the offending cwd and a discriminator so the
- * WebSocket layer can surface a structured error frame to the client.
- */
-export declare class TerminalCwdError extends Error {
-    readonly cwd: string;
-    readonly reason: TerminalCwdErrorReason;
-    constructor(args: {
-        cwd: string;
-        reason: TerminalCwdErrorReason;
-        cause?: unknown;
-    });
-    private static formatMessage;
-}
-/**
- * Typed error thrown when caller-supplied PTY input is structurally
- * invalid (e.g. empty cwd for the project default terminal). Distinct
- * from {@link TerminalCwdError} which describes filesystem state.
- */
-export declare class TerminalSpawnInputError extends Error {
-    readonly field: string;
-    constructor(args: {
-        field: string;
-        message: string;
-    });
-}
-export interface PtyBridgeOptions {
-    id?: string;
-    shell?: string;
-    args?: string[];
-    cwd?: string;
-    env?: Record<string, string | undefined>;
-    name?: string;
-    coalesceMs?: number;
-    ringBufferBytes?: number;
-    /**
-     * Inject a `PtyAdapter` (T087). When omitted, the bridge uses the
-     * `defaultNodePtyAdapter`. Tests should pass a `MockPtyAdapter` from
-     * `terminal/__tests__/MockPtyAdapter.ts` so no native PTY is spawned.
-     */
-    ptyAdapter?: PtyAdapter;
-    /**
-     * Legacy injection point retained for back-compat with pre-T087 tests
-     * that hand-roll a `pty.spawn` stub. The bridge wraps the supplied
-     * function in an internal `NodePtyAdapter` so the rest of the code path
-     * stays uniform. New tests should prefer `ptyAdapter`.
-     */
-    pty?: {
-        spawn: LegacyPtySpawn;
-    };
-    /**
-     * Override for cwd validation. Defaults to a real `fs.statSync` check.
-     * Tests inject a stub to exercise the typed-error branches without
-     * touching the filesystem.
-     */
-    statCwd?: (cwd: string) => fs.Stats;
-}
-export interface PtySpawnOptions {
-    cwd?: string;
-    cmd?: string[];
-}
-/**
- * Validate that the supplied cwd exists and is a directory. Throws a
- * {@link TerminalCwdError} with a typed reason on any failure so the
- * caller can surface a structured error frame instead of leaking
- * stringly-typed errno checks.
- */
-export declare function assertValidCwd(cwd: string, statCwd?: (cwd: string) => fs.Stats): void;
-export declare function cleanEnv(): Record<string, string>;
-export declare class PtyBridge extends EventEmitter {
-    private ptyProcess;
-    private dataDispose;
-    private exitDispose;
-    private exitPoll;
-    private outputTimer;
-    private outputChunks;
-    private pausedOutputChunks;
-    private outputPaused;
-    private replayChunks;
-    private replayBytes;
-    private lastCwd;
-    private readonly options;
-    private readonly adapter;
-    private readonly ringBufferBytes;
-    private readonly statCwd;
-    constructor(options?: PtyBridgeOptions);
-    /**
-     * Returns the cwd used by the most recent spawn (or restart). `null`
-     * if the bridge has never been spawned. Used by ws-route to detect
-     * stale-cwd reuse and trigger a respawn.
-     */
-    getCwd(): string | null;
-    get pid(): number | null;
-    private lastCols;
-    private lastRows;
-    get cols(): number | null;
-    get rows(): number | null;
-    get running(): boolean;
-    getReplayBuffer(): Buffer;
-    flushReplayBuffer(): void;
-    spawn(cols: number, rows: number, spawnOptions?: PtySpawnOptions): void;
-    /**
-     * Stop the currently-running PTY process synchronously. Drops listeners
-     * and clears replay so a follow-up spawn starts from a clean slate.
-     * Idempotent — no-op when no process is running.
-     *
-     * Used by {@link restartWith} to swap out a sticky bridge whose cwd no
-     * longer matches the client request.
-     */
-    stopProcess(signal?: NodeJS.Signals): void;
-    /**
-     * Stop the running process (if any) and spawn a new one with the
-     * supplied options. Preserves bridge identity (id, registry slot) but
-     * resets the replay buffer — the prior process is gone, there is no
-     * meaningful output to replay. Used when a reconnect requests a new
-     * cwd; modeled on t3code's `stopProcess + spawn` pattern.
-     */
-    restartWith(cols: number, rows: number, spawnOptions?: PtySpawnOptions): void;
-    pause(): void;
-    resume(): void;
-    write(bytes: Buffer | Uint8Array | string): void;
-    resize(cols: number, rows: number): void;
-    kill(signal?: NodeJS.Signals): void;
-    dispose(): void;
-    private disposeListeners;
-    private enqueueOutput;
-    private flushCoalescedOutput;
-    private deliverOutput;
-    private flushPausedOutput;
-    private flushAllOutput;
-    private appendReplay;
-    private startExitPoll;
-    private emitExit;
-}
-export {};

package/packages/daemon/dist/server/ws-route.d.ts

@@ -1,74 +0,0 @@
-import type { RawData, WebSocket } from "ws";
-import { type PtyExit, type PtySpawnOptions } from "./pty-bridge.ts";
-export interface PtyBridgeLike {
-    spawn(cols: number, rows: number, options?: PtySpawnOptions): void;
-    restartWith?(cols: number, rows: number, options?: PtySpawnOptions): void;
-    getCwd?(): string | null;
-    readonly running?: boolean;
-    getReplayBuffer?(): Buffer;
-    flushReplayBuffer?(): void;
-    write(bytes: Buffer): void;
-    resize(cols: number, rows: number): void;
-    pause(): void;
-    resume(): void;
-    kill(signal?: NodeJS.Signals): void;
-    on(event: "output", listener: (bytes: Buffer) => void): this;
-    on(event: "exit", listener: (exit: PtyExit) => void): this;
-    off(event: "output", listener: (bytes: Buffer) => void): this;
-    off(event: "exit", listener: (exit: PtyExit) => void): this;
-}
-/**
- * Wire reason codes for terminal-cwd errors. Mirrors the bridge's
- * {@link TerminalCwdErrorReason} discriminator into the kebab-case the
- * WS protocol speaks. Adding a new reason is a single-line change in
- * both directions.
- */
-export type CwdErrorWireReason = "cwd-not-found" | "cwd-not-directory" | "cwd-stat-failed";
-interface WsLike {
-    readyState: number;
-    bufferedAmount?: number;
-    send(data: string | Buffer, options?: {
-        binary?: boolean;
-    }): void;
-    close(code?: number, reason?: string): void;
-    on(event: "message", listener: (data: RawData | string, isBinary: boolean) => void): this;
-    on(event: "close", listener: () => void): this;
-    on(event: "error", listener: () => void): this;
-}
-export interface PtyWebSocketOptions {
-    createBridge?: (id: string) => PtyBridgeLike;
-    registry?: PtyBridgeRegistry;
-    idleMs?: number;
-}
-export interface PtyWebSocketConnection {
-    getBridge(): PtyBridgeLike | null;
-}
-export declare class PtyBridgeRegistry {
-    private entries;
-    acquire(id: string, createBridge: (id: string) => PtyBridgeLike, options?: {
-        idleMs?: number;
-    }): {
-        bridge: PtyBridgeLike;
-        reused: boolean;
-        release: () => void;
-    };
-    /**
-     * Look up a bridge by id without acquiring it. Returns `null` when no
-     * bridge is registered for the id. Used by server-side action handlers
-     * (terminal.respawn, terminal.stop) that need to operate on an existing
-     * bridge — they should not bump the client refcount.
-     */
-    peek(id: string): PtyBridgeLike | null;
-    /**
-     * Drop the bridge for `id`, killing it synchronously. Used by the
-     * terminal.stop action handler to release a sticky bridge whose owner
-     * has explicitly asked to terminate it.
-     */
-    delete(id: string): boolean;
-    shutdown(): void;
-    size(): number;
-}
-export declare const defaultPtyBridgeRegistry: PtyBridgeRegistry;
-export declare function shutdownPtyBridges(): void;
-export declare function handlePtyWebSocket(ws: WebSocket | WsLike, id: string, options?: PtyWebSocketOptions): PtyWebSocketConnection;
-export {};

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

@@ -1,3 +0,0 @@
-export declare function status(targetDir: string | undefined, { json }?: {
-    json?: boolean;
-}): Promise<void>;

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

@@ -1,3 +0,0 @@
-export declare function stop(targetDir: string | undefined, { json }?: {
-    json?: boolean;
-}): Promise<void>;

package/packages/daemon/dist/terminal/NodePtyAdapter.d.ts

@@ -1,44 +0,0 @@
-/**
- * NodePtyAdapter — concrete `PtyAdapter` backed by the `node-pty` native
- * module (T087). The only place in the daemon that imports `node-pty`.
- *
- * One-time setup:
- *   - macOS / Linux: node-pty ships a `spawn-helper` binary. The
- *     `chmod +x` is occasionally lost during install (npm tarball
- *     metadata edge cases). Borrowing t3's
- *     `ensureNodePtySpawnHelperExecutable`, we walk the published candidate
- *     paths and chmod 0755 once per process. Failure is best-effort —
- *     spawning will surface a real error if it actually matters.
- */
-import { type Stats } from "node:fs";
-import * as pty from "node-pty";
-import { type PtyAdapter, type PtyProcess, type PtySpawnInput } from "./PtyAdapter.ts";
-/**
- * Chmod node-pty's `spawn-helper` to 0755 the first time we touch it.
- * No-op on Windows (no helper binary). Idempotent across calls.
- * Exported for the unit test that asserts the chmod side effect.
- */
-export declare function ensureNodePtySpawnHelperExecutable(options?: {
-    explicitPath?: string;
-    force?: boolean;
-}): void;
-export interface NodePtyAdapterOptions {
-    /** Override node-pty's `spawn` for tests. */
-    spawnPty?: typeof pty.spawn;
-    /** Override `fs.statSync` for cwd validation in tests. */
-    statCwd?: (cwd: string) => Stats;
-    /** Skip the spawn-helper chmod (test isolation). */
-    skipHelperEnsure?: boolean;
-}
-export declare class NodePtyAdapter implements PtyAdapter {
-    readonly id = "node-pty";
-    private readonly spawnPty;
-    private readonly statCwd;
-    private readonly skipHelperEnsure;
-    constructor(options?: NodePtyAdapterOptions);
-    spawn(input: PtySpawnInput): Promise<PtyProcess>;
-    spawnSync(input: PtySpawnInput): PtyProcess;
-    private spawnSyncInternal;
-}
-/** Convenience singleton — most call sites just want `defaultNodePtyAdapter`. */
-export declare const defaultNodePtyAdapter: PtyAdapter;

package/packages/daemon/dist/terminal/PtyAdapter.d.ts

@@ -1,124 +0,0 @@
-/**
- * PtyAdapter — terminal PTY adapter service contract (T087).
- *
- * Defines the process primitives required by terminal session management
- * without binding to a specific PTY implementation. Mirrors t3's
- * `apps/server/src/terminal/Services/PTY.ts` shape minus the Effect runtime
- * (Effect adoption is G14-T07 territory; we stay on plain TS Promises here).
- *
- * Why:
- *   - `node-pty` is a native module whose `onData` callback never fires
- *     under Bun (T085 burned half a day on the diagnosis). Routing every
- *     daemon-side PTY spawn through this interface lets us swap runtimes
- *     without touching consumers and lets tests stub the entire layer with
- *     a `MockPtyAdapter` that returns scripted output.
- *   - The Electron preload + future remote-PTY transports will eventually
- *     ship their own adapters. Keeping the seam thin makes that drop-in.
- *
- * Synchronous vs async:
- *   - `spawn(input): Promise<PtyProcess>` is the canonical entry point.
- *     Async because some adapters do real setup (e.g. NodePtyAdapter chmods
- *     node-pty's `spawn-helper` binary the first time, t3 does the same).
- *   - `spawnSync(input): PtyProcess` is a sibling for legacy synchronous
- *     callers (today: `PtyBridge.spawn` in `server/pty-bridge.ts`). It MUST
- *     have the same observable semantics as `spawn` once any one-shot setup
- *     has been done. Adapters that genuinely need async work should throw
- *     `PtySpawnError` ("sync_unsupported") from `spawnSync` so the caller
- *     can fall back to the async path.
- */
-export interface PtySpawnInput {
-    /** Executable to run. Defaults are adapter-defined when omitted. */
-    shell: string;
-    /** Argv for the executable (without argv[0]). Optional; adapters may apply defaults. */
-    args?: ReadonlyArray<string>;
-    /** Working directory for the spawned process. Must exist + be a directory. */
-    cwd: string;
-    /** Initial cols. Must be a positive integer. */
-    cols: number;
-    /** Initial rows. Must be a positive integer. */
-    rows: number;
-    /** Environment vars handed to the child. */
-    env: NodeJS.ProcessEnv;
-    /**
-     * Terminal name (`$TERM`) handed to the child. Defaults to
-     * `xterm-256color` when omitted. Some adapters honour it, some pin it.
-     */
-    name?: string;
-    /**
-     * Output encoding. `null` (default) yields raw `Buffer` data — required
-     * for byte-accurate WebSocket bridging.
-     */
-    encoding?: "utf8" | null;
-}
-export interface PtyExitEvent {
-    /** Process exit code. `0` is clean shutdown. */
-    exitCode: number;
-    /** Terminating signal (numeric), or `null` when the process exited cleanly. */
-    signal: number | null;
-}
-/**
- * Handle to a live PTY child returned by `PtyAdapter.spawn`. Modelled on
- * t3's `PtyProcess` and `node-pty`'s `IPty` so wrapping is trivial.
- *
- * Listeners returned by `onData`/`onExit` are disposers — call them to
- * detach. After `kill()` the adapter is expected to emit a single
- * synthetic `onExit` event so the bridge layer can converge on shutdown.
- */
-export interface PtyProcess {
-    /** Underlying OS PID (or a synthetic positive integer for mocks). */
-    readonly pid: number;
-    /** Write raw bytes (string is interpreted as UTF-8) into the child stdin. */
-    write(data: string | Uint8Array): void;
-    /** Resize the controlling terminal. */
-    resize(cols: number, rows: number): void;
-    /**
-     * Send a signal to the child. Defaults to `SIGTERM` so adapters that
-     * can't deliver arbitrary signals (mocks, sandboxed remotes) still
-     * honour the common case.
-     */
-    kill(signal?: NodeJS.Signals | number): void;
-    /**
-     * Subscribe to data emissions. Returns a disposer; calling it detaches
-     * the listener without affecting any sibling subscribers.
-     */
-    onData(callback: (data: Buffer) => void): () => void;
-    /**
-     * Subscribe to exit. Returns a disposer. Adapters MUST guarantee at
-     * most one terminal `onExit` per process; resubscribing after exit is
-     * a no-op that returns an inert disposer.
-     */
-    onExit(callback: (event: PtyExitEvent) => void): () => void;
-}
-/** Discriminator codes for `PtySpawnError`. */
-export type PtySpawnErrorCode = "cwd_invalid" | "shell_not_found" | "permission_denied" | "sync_unsupported" | "unknown";
-/**
- * Typed failure for `PtyAdapter.spawn` / `spawnSync`. Adapters MUST throw
- * (or reject with) this class so the WS bridge can translate to a
- * structured error frame without sniffing native error message strings.
- */
-export declare class PtySpawnError extends Error {
-    readonly adapter: string;
-    readonly code: PtySpawnErrorCode;
-    constructor(args: {
-        adapter: string;
-        code: PtySpawnErrorCode;
-        message: string;
-        cause?: unknown;
-    });
-}
-/**
- * The adapter contract every PTY backend must satisfy. Async is the
- * canonical surface; `spawnSync` is provided for the synchronous callers
- * that exist today (PtyBridge / ws-route). New code should prefer `spawn`.
- */
-export interface PtyAdapter {
-    /** Human-readable adapter id, surfaced in `PtySpawnError.adapter`. */
-    readonly id: string;
-    /** Canonical async spawn. Resolves once the child PID is known. */
-    spawn(input: PtySpawnInput): Promise<PtyProcess>;
-    /**
-     * Synchronous spawn. Adapters that can't satisfy this (because they
-     * need async setup) MUST throw `PtySpawnError({ code: "sync_unsupported" })`.
-     */
-    spawnSync(input: PtySpawnInput): PtyProcess;
-}

package/packages/daemon/dist/terminal/__tests__/MockPtyAdapter.d.ts

@@ -1,77 +0,0 @@
-/**
- * MockPtyAdapter — scripted PTY backend for tests (T087).
- *
- * Mirrors the `PtyAdapter` contract but spawns no real processes. Every
- * call to {@link MockPtyAdapter.spawn} or {@link MockPtyAdapter.spawnSync}
- * returns a fresh {@link MockPtyProcess} the test then drives manually via
- * {@link MockPtyProcess.pushOutput} / {@link MockPtyProcess.emitExit}.
- *
- * Drop-in for any layer that takes a `PtyAdapter`. The adapter also keeps
- * a `spawnLog` of every `PtySpawnInput` so tests can assert wiring without
- * inspecting node-pty internals.
- *
- * Why this lives under `__tests__/`: it is purely test infrastructure and
- * MUST NOT be bundled into the production daemon. Vitest's `include`
- * pulls it in implicitly when sibling tests import it.
- */
-import { PtySpawnError, type PtyAdapter, type PtyExitEvent, type PtyProcess, type PtySpawnInput } from "../PtyAdapter.ts";
-export interface MockPtyOptions {
-    /** Force `spawn` to reject with this error. Used by error-path tests. */
-    failNext?: {
-        code: PtySpawnError["code"];
-        message: string;
-    };
-    /** When true, throw `sync_unsupported` from `spawnSync` to exercise async fallback. */
-    syncUnsupported?: boolean;
-    /** Synthetic starting pid for spawned processes; auto-increments. */
-    startingPid?: number;
-}
-export declare class MockPtyProcess implements PtyProcess {
-    readonly pid: number;
-    /** Append-only log of every `write(...)` call so tests can assert input. */
-    readonly writeLog: Array<string | Uint8Array>;
-    /** Append-only log of every `resize(...)` call. */
-    readonly resizeLog: Array<{
-        cols: number;
-        rows: number;
-    }>;
-    /** Records the last signal observed by `kill(...)`. */
-    killed: NodeJS.Signals | number | null;
-    private exited;
-    private readonly dataListeners;
-    private readonly exitListeners;
-    private readonly _input;
-    constructor(pid: number, input: PtySpawnInput);
-    /** Original spawn input — handy for assertions. */
-    get spawnInput(): PtySpawnInput;
-    write(data: string | Uint8Array): void;
-    resize(cols: number, rows: number): void;
-    kill(signal?: NodeJS.Signals | number): void;
-    onData(callback: (data: Buffer) => void): () => void;
-    onExit(callback: (event: PtyExitEvent) => void): () => void;
-    /** Push synthetic PTY output bytes to every `onData` subscriber. */
-    pushOutput(data: string | Uint8Array | Buffer): void;
-    /** Fire the terminal exit event (idempotent — subsequent calls are no-ops). */
-    emitExit(event: PtyExitEvent): void;
-    /** Number of currently attached data listeners — handy for leak assertions. */
-    get dataListenerCount(): number;
-    /** Number of currently attached exit listeners. */
-    get exitListenerCount(): number;
-}
-export declare class MockPtyAdapter implements PtyAdapter {
-    readonly id = "mock";
-    readonly spawnLog: PtySpawnInput[];
-    readonly spawned: MockPtyProcess[];
-    private nextPid;
-    private _failNext;
-    private readonly syncUnsupported;
-    constructor(options?: MockPtyOptions);
-    /** Arm the next spawn to throw a typed error. */
-    failNext(code: PtySpawnError["code"], message: string): void;
-    spawn(input: PtySpawnInput): Promise<PtyProcess>;
-    spawnSync(input: PtySpawnInput): PtyProcess;
-    /** Read-only view of all spawns so tests can assert wiring. */
-    get spawnCount(): number;
-    /** The most recently spawned mock process, or `null` if there were none. */
-    lastSpawned(): MockPtyProcess | null;
-}

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

@@ -1,2 +0,0 @@
-export type { Pane, Row, ThemeConfig, OrchestratorYamlConfig, CommandCenterConfig, DashboardConfig, IdeConfig, PaneAction, SessionState, } from "./schemas/ide-config.ts";
-export type TmuxCommand = string[];

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

@@ -1,4 +0,0 @@
-export declare function validateConfig(config: unknown): string[];
-export declare function validate(targetDir: string | undefined, { json }?: {
-    json?: boolean;
-}): Promise<void>;