tmux-ide 2.1.5 → 2.6.1

package/packages/daemon/dist/terminal/NodePtyAdapter.js

@@ -0,0 +1,253 @@
+/**
+ * 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 { chmodSync, existsSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { createRequire } from "node:module";
+import * as pty from "node-pty";
+import { PtySpawnError, } from "./PtyAdapter.js";
+const ADAPTER_ID = "node-pty";
+let helperEnsured = false;
+function candidateSpawnHelperPaths() {
+    const requireForNodePty = createRequire(import.meta.url);
+    let pkgJsonPath;
+    try {
+        pkgJsonPath = requireForNodePty.resolve("node-pty/package.json");
+    }
+    catch {
+        // node-pty package missing — `pty.spawn` will throw a richer error.
+        return [];
+    }
+    const pkgDir = dirname(pkgJsonPath);
+    return [
+        join(pkgDir, "build", "Release", "spawn-helper"),
+        join(pkgDir, "build", "Debug", "spawn-helper"),
+        join(pkgDir, "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper"),
+    ];
+}
+/**
+ * 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 function ensureNodePtySpawnHelperExecutable(options = {}) {
+    if (process.platform === "win32")
+        return;
+    if (!options.force && !options.explicitPath && helperEnsured)
+        return;
+    const candidates = options.explicitPath ? [options.explicitPath] : candidateSpawnHelperPaths();
+    for (const candidate of candidates) {
+        if (!existsSync(candidate))
+            continue;
+        try {
+            chmodSync(candidate, 0o755);
+        }
+        catch {
+            // Best-effort: a hardened filesystem may forbid chmod even when the
+            // bit is already set. Continue to the next candidate so we never
+            // fail spawning just because the helper was already executable.
+        }
+    }
+    if (!options.explicitPath)
+        helperEnsured = true;
+}
+function assertValidCwd(cwd, statFn) {
+    let stats;
+    try {
+        stats = statFn(cwd);
+    }
+    catch (err) {
+        throw new PtySpawnError({
+            adapter: ADAPTER_ID,
+            code: "cwd_invalid",
+            message: `cwd does not exist or cannot be stat'd: ${cwd}`,
+            cause: err,
+        });
+    }
+    if (!stats.isDirectory()) {
+        throw new PtySpawnError({
+            adapter: ADAPTER_ID,
+            code: "cwd_invalid",
+            message: `cwd is not a directory: ${cwd}`,
+        });
+    }
+}
+/**
+ * Wrap a live `node-pty` IPty with the `PtyProcess` interface. Disposes are
+ * idempotent; `kill` emits a synthetic exit if node-pty doesn't fire one
+ * (e.g. when the child has already gone away under us).
+ */
+class NodePtyProcess {
+    exited = false;
+    child;
+    dataListeners = new Set();
+    exitListeners = new Set();
+    constructor(child) {
+        this.child = child;
+        // node-pty hands us strings by default; we want raw buffers for
+        // byte-accurate WS bridging. The encoding:null on spawn opts gives us
+        // buffers in the typings of node-pty@1.2.0-beta.12.
+        this.child.onData((data) => {
+            const buf = Buffer.isBuffer(data) ? data : Buffer.from(String(data), "utf8");
+            for (const listener of this.dataListeners)
+                listener(buf);
+        });
+        this.child.onExit((evt) => {
+            this.exited = true;
+            const event = {
+                exitCode: evt.exitCode ?? 0,
+                signal: typeof evt.signal === "number" ? evt.signal : null,
+            };
+            for (const listener of this.exitListeners)
+                listener(event);
+        });
+    }
+    get pid() {
+        return this.child.pid;
+    }
+    write(data) {
+        if (this.exited)
+            return;
+        if (typeof data === "string")
+            this.child.write(data);
+        else
+            this.child.write(Buffer.from(data).toString("binary"));
+    }
+    resize(cols, rows) {
+        if (this.exited)
+            return;
+        if (!Number.isInteger(cols) || cols <= 0)
+            throw new RangeError("cols must be a positive integer");
+        if (!Number.isInteger(rows) || rows <= 0)
+            throw new RangeError("rows must be a positive integer");
+        try {
+            this.child.resize(cols, rows);
+        }
+        catch {
+            // node-pty throws if the underlying fd is gone — treat as no-op so
+            // bridge resize handlers don't have to special-case.
+        }
+    }
+    kill(signal) {
+        if (this.exited)
+            return;
+        try {
+            this.child.kill(typeof signal === "number" ? String(signal) : signal);
+        }
+        catch {
+            // Already gone. Synthesize an exit so listeners detach cleanly.
+            this.exited = true;
+            for (const listener of this.exitListeners)
+                listener({ exitCode: 0, signal: null });
+        }
+    }
+    onData(callback) {
+        this.dataListeners.add(callback);
+        return () => {
+            this.dataListeners.delete(callback);
+        };
+    }
+    onExit(callback) {
+        if (this.exited) {
+            // Adapters MUST guarantee at most one terminal onExit — late
+            // subscribers get an inert disposer.
+            return () => undefined;
+        }
+        this.exitListeners.add(callback);
+        return () => {
+            this.exitListeners.delete(callback);
+        };
+    }
+}
+export class NodePtyAdapter {
+    id = ADAPTER_ID;
+    spawnPty;
+    statCwd;
+    skipHelperEnsure;
+    constructor(options = {}) {
+        this.spawnPty = options.spawnPty ?? pty.spawn;
+        this.statCwd = options.statCwd ?? statSync;
+        this.skipHelperEnsure = options.skipHelperEnsure ?? false;
+    }
+    async spawn(input) {
+        if (!this.skipHelperEnsure)
+            ensureNodePtySpawnHelperExecutable();
+        return this.spawnSyncInternal(input);
+    }
+    spawnSync(input) {
+        if (!this.skipHelperEnsure)
+            ensureNodePtySpawnHelperExecutable();
+        return this.spawnSyncInternal(input);
+    }
+    spawnSyncInternal(input) {
+        assertValidCwd(input.cwd, this.statCwd);
+        if (!Number.isInteger(input.cols) || input.cols <= 0) {
+            throw new PtySpawnError({
+                adapter: ADAPTER_ID,
+                code: "unknown",
+                message: `cols must be a positive integer (got ${input.cols})`,
+            });
+        }
+        if (!Number.isInteger(input.rows) || input.rows <= 0) {
+            throw new PtySpawnError({
+                adapter: ADAPTER_ID,
+                code: "unknown",
+                message: `rows must be a positive integer (got ${input.rows})`,
+            });
+        }
+        // node-pty wants `Record<string, string>` for env — strip undefined values.
+        const env = {};
+        for (const [key, value] of Object.entries(input.env)) {
+            if (typeof value === "string")
+                env[key] = value;
+        }
+        let child;
+        try {
+            child = this.spawnPty(input.shell, [...(input.args ?? [])], {
+                name: input.name ?? "xterm-256color",
+                cols: input.cols,
+                rows: input.rows,
+                cwd: input.cwd,
+                env,
+                encoding: input.encoding === "utf8" ? "utf8" : null,
+            });
+        }
+        catch (err) {
+            const errno = err?.code;
+            if (errno === "ENOENT") {
+                throw new PtySpawnError({
+                    adapter: ADAPTER_ID,
+                    code: "shell_not_found",
+                    message: `shell not found in PATH: ${input.shell}`,
+                    cause: err,
+                });
+            }
+            if (errno === "EACCES" || errno === "EPERM") {
+                throw new PtySpawnError({
+                    adapter: ADAPTER_ID,
+                    code: "permission_denied",
+                    message: `permission denied spawning ${input.shell}`,
+                    cause: err,
+                });
+            }
+            throw new PtySpawnError({
+                adapter: ADAPTER_ID,
+                code: "unknown",
+                message: `node-pty spawn failed: ${err instanceof Error ? err.message : String(err)}`,
+                cause: err,
+            });
+        }
+        return new NodePtyProcess(child);
+    }
+}
+/** Convenience singleton — most call sites just want `defaultNodePtyAdapter`. */
+export const defaultNodePtyAdapter = new NodePtyAdapter();

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

@@ -0,0 +1,124 @@
+/**
+ * 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/PtyAdapter.js

@@ -0,0 +1,43 @@
+/**
+ * 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.
+ */
+/**
+ * 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 class PtySpawnError extends Error {
+    adapter;
+    code;
+    constructor(args) {
+        super(args.message, args.cause !== undefined ? { cause: args.cause } : undefined);
+        this.name = "PtySpawnError";
+        this.adapter = args.adapter;
+        this.code = args.code;
+    }
+}

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

@@ -0,0 +1,77 @@
+/**
+ * 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/terminal/__tests__/MockPtyAdapter.js

@@ -0,0 +1,155 @@
+/**
+ * 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, } from "../PtyAdapter.js";
+export class MockPtyProcess {
+    pid;
+    /** Append-only log of every `write(...)` call so tests can assert input. */
+    writeLog = [];
+    /** Append-only log of every `resize(...)` call. */
+    resizeLog = [];
+    /** Records the last signal observed by `kill(...)`. */
+    killed = null;
+    exited = false;
+    dataListeners = new Set();
+    exitListeners = new Set();
+    _input;
+    constructor(pid, input) {
+        this.pid = pid;
+        this._input = input;
+    }
+    /** Original spawn input — handy for assertions. */
+    get spawnInput() {
+        return this._input;
+    }
+    write(data) {
+        if (this.exited)
+            return;
+        this.writeLog.push(data);
+    }
+    resize(cols, rows) {
+        if (this.exited)
+            return;
+        this.resizeLog.push({ cols, rows });
+    }
+    kill(signal) {
+        if (this.exited)
+            return;
+        this.killed = signal ?? "SIGTERM";
+        // Synthesize an exit so subscribers detach cleanly — matches the
+        // node-pty fallback inside NodePtyAdapter.
+        this.emitExit({ exitCode: 0, signal: typeof signal === "number" ? signal : null });
+    }
+    onData(callback) {
+        this.dataListeners.add(callback);
+        return () => {
+            this.dataListeners.delete(callback);
+        };
+    }
+    onExit(callback) {
+        if (this.exited)
+            return () => undefined;
+        this.exitListeners.add(callback);
+        return () => {
+            this.exitListeners.delete(callback);
+        };
+    }
+    // ------------------------------------------------------------------
+    // Test-only drivers — never called by production code.
+    // ------------------------------------------------------------------
+    /** Push synthetic PTY output bytes to every `onData` subscriber. */
+    pushOutput(data) {
+        if (this.exited)
+            return;
+        const buf = data instanceof Buffer
+            ? data
+            : typeof data === "string"
+                ? Buffer.from(data, "utf8")
+                : Buffer.from(data);
+        for (const listener of this.dataListeners)
+            listener(buf);
+    }
+    /** Fire the terminal exit event (idempotent — subsequent calls are no-ops). */
+    emitExit(event) {
+        if (this.exited)
+            return;
+        this.exited = true;
+        for (const listener of this.exitListeners)
+            listener(event);
+    }
+    /** Number of currently attached data listeners — handy for leak assertions. */
+    get dataListenerCount() {
+        return this.dataListeners.size;
+    }
+    /** Number of currently attached exit listeners. */
+    get exitListenerCount() {
+        return this.exitListeners.size;
+    }
+}
+export class MockPtyAdapter {
+    id = "mock";
+    spawnLog = [];
+    spawned = [];
+    nextPid;
+    _failNext;
+    syncUnsupported;
+    constructor(options = {}) {
+        this.nextPid = options.startingPid ?? 100_000;
+        this._failNext = options.failNext;
+        this.syncUnsupported = options.syncUnsupported ?? false;
+    }
+    /** Arm the next spawn to throw a typed error. */
+    failNext(code, message) {
+        this._failNext = { code, message };
+    }
+    async spawn(input) {
+        if (this._failNext) {
+            const err = this._failNext;
+            this._failNext = undefined;
+            throw new PtySpawnError({ adapter: this.id, code: err.code, message: err.message });
+        }
+        this.spawnLog.push(input);
+        const proc = new MockPtyProcess(this.nextPid++, input);
+        this.spawned.push(proc);
+        return proc;
+    }
+    spawnSync(input) {
+        if (this.syncUnsupported) {
+            throw new PtySpawnError({
+                adapter: this.id,
+                code: "sync_unsupported",
+                message: "MockPtyAdapter is configured with syncUnsupported=true",
+            });
+        }
+        if (this._failNext) {
+            const err = this._failNext;
+            this._failNext = undefined;
+            throw new PtySpawnError({ adapter: this.id, code: err.code, message: err.message });
+        }
+        this.spawnLog.push(input);
+        const proc = new MockPtyProcess(this.nextPid++, input);
+        this.spawned.push(proc);
+        return proc;
+    }
+    /** Read-only view of all spawns so tests can assert wiring. */
+    get spawnCount() {
+        return this.spawnLog.length;
+    }
+    /** The most recently spawned mock process, or `null` if there were none. */
+    lastSpawned() {
+        return this.spawned.at(-1) ?? null;
+    }
+}

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

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

package/packages/daemon/dist/types.js

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

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

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