tmux-ide 2.1.4 → 2.6.0

package/packages/daemon/dist/schemas/registry.js

@@ -0,0 +1,43 @@
+/**
+ * Project registry contracts. The dashboard manages a list of projects the
+ * user has registered with tmux-ide; this schema is the wire shape exchanged
+ * over `/api/projects` and the `/ws/events` WebSocket channel.
+ *
+ * The shape is FROZEN — the dashboard imports these via `@tmux-ide/schemas`.
+ * Add new fields by appending optional properties; do not rename existing
+ * fields without bumping a major.
+ */
+import { z } from "zod";
+export const RegisteredProjectSchemaZ = z.object({
+    /** Unique registry key. Defaults to `basename(dir)`; collisions resolved by appending `-2`, `-3`, … */
+    name: z.string(),
+    /** Absolute path to the project directory. */
+    dir: z.string(),
+    /** Whether `<dir>/ide.yml` exists; refreshed on register and on `probe()`. */
+    hasIdeYml: z.boolean(),
+    /** Git remote origin URL, or `null` if not a git repo / no origin / probe failed. */
+    gitOrigin: z.string().nullable(),
+    /** Current git branch, or `null` if not a git repo / detached HEAD / probe failed. */
+    gitBranch: z.string().nullable(),
+    /** ISO-8601 timestamp the project was first registered. */
+    registeredAt: z.string(),
+});
+// ---------------------------------------------------------------------------
+// REST request bodies
+// ---------------------------------------------------------------------------
+export const RegisterProjectRequestSchemaZ = z.object({
+    dir: z.string().min(1),
+    name: z.string().min(1).optional(),
+});
+export const InitProjectRequestSchemaZ = z.object({
+    dir: z.string().min(1),
+    template: z.string().min(1).optional(),
+});
+// ---------------------------------------------------------------------------
+// Template metadata (returned by GET /api/projects/templates)
+// ---------------------------------------------------------------------------
+export const ProjectTemplateSchemaZ = z.object({
+    id: z.string(),
+    label: z.string(),
+    description: z.string(),
+});

package/packages/daemon/dist/schemas/ws-events.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Protocol contracts for the unified `/ws/events` WebSocket channel.
+ *
+ * Single push channel clients subscribe to for session / pane / workspace
+ * changes. One socket replaces a fan of individual SSE streams that hit
+ * Chrome's 6-per-origin HTTP/1.1 limit.
+ *
+ * Add new frame variants by appending to the union; do not rename existing
+ * fields.
+ */
+import { z } from "zod";
+export declare const SessionSnapshotSchemaZ: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type SessionSnapshot = z.infer<typeof SessionSnapshotSchemaZ>;
+export declare const ClientFrameSchemaZ: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"subscribe">;
+    sessions: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"unsubscribe">;
+    sessions: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"ping">;
+}, z.core.$strip>], "type">;
+export type ClientFrame = z.infer<typeof ClientFrameSchemaZ>;
+export declare const ServerFrameSchemaZ: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"hello">;
+    sessions: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        dir: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"snapshot">;
+    sessionName: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"sessions.changed">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"projects.changed">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"init.output">;
+    jobId: z.ZodString;
+    chunk: z.ZodString;
+    done: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"init.error">;
+    jobId: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"pong">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"action.complete">;
+    name: z.ZodString;
+    result: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"config.changed">;
+    sessionName: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"terminals.changed">;
+    sessionName: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"workspace.added">;
+    workspace: z.ZodObject<{
+        name: z.ZodString;
+        sessionName: z.ZodString;
+        projectDir: z.ZodString;
+        ideConfigPath: z.ZodNullable<z.ZodString>;
+        addedAt: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"workspace.removed">;
+    name: z.ZodString;
+}, z.core.$strip>], "type">;
+export type ServerFrame = z.infer<typeof ServerFrameSchemaZ>;

package/packages/daemon/dist/schemas/ws-events.js

@@ -0,0 +1,110 @@
+/**
+ * Protocol contracts for the unified `/ws/events` WebSocket channel.
+ *
+ * Single push channel clients subscribe to for session / pane / workspace
+ * changes. One socket replaces a fan of individual SSE streams that hit
+ * Chrome's 6-per-origin HTTP/1.1 limit.
+ *
+ * Add new frame variants by appending to the union; do not rename existing
+ * fields.
+ */
+import { z } from "zod";
+import { SessionOverviewSchemaZ } from "./domain.js";
+import { WorkspaceAddedFrameSchemaZ, WorkspaceRemovedFrameSchemaZ } from "@tmux-ide/contracts";
+// ---------------------------------------------------------------------------
+// Snapshot payload — mirrors what `/api/project/<name>/stream` already pushes
+// as its `snapshot` SSE event. Kept loose (passthrough) so that adding fields
+// on the producer side does not require shipping schema updates lock-step
+// with consumers. Consumers should validate fields they actually read.
+// ---------------------------------------------------------------------------
+export const SessionSnapshotSchemaZ = z.record(z.string(), z.unknown());
+// ---------------------------------------------------------------------------
+// Client → Server frames
+// ---------------------------------------------------------------------------
+const SubscribeFrameZ = z.object({
+    type: z.literal("subscribe"),
+    sessions: z.array(z.string()),
+});
+const UnsubscribeFrameZ = z.object({
+    type: z.literal("unsubscribe"),
+    sessions: z.array(z.string()),
+});
+const PingFrameZ = z.object({
+    type: z.literal("ping"),
+});
+export const ClientFrameSchemaZ = z.discriminatedUnion("type", [
+    SubscribeFrameZ,
+    UnsubscribeFrameZ,
+    PingFrameZ,
+]);
+// ---------------------------------------------------------------------------
+// Server → Client frames
+// ---------------------------------------------------------------------------
+const HelloFrameZ = z.object({
+    type: z.literal("hello"),
+    sessions: z.array(SessionOverviewSchemaZ),
+});
+const SnapshotFrameZ = z.object({
+    type: z.literal("snapshot"),
+    sessionName: z.string(),
+    data: SessionSnapshotSchemaZ,
+});
+const SessionsChangedFrameZ = z.object({
+    type: z.literal("sessions.changed"),
+});
+// Project-registry has changed (register / unregister / re-probe / init success).
+// Clients re-fetch GET /api/projects.
+const ProjectsChangedFrameZ = z.object({
+    type: z.literal("projects.changed"),
+});
+// Streaming output from `tmux-ide init` invoked via POST /api/projects/init.
+// `chunk` is a single line of stdout/stderr (newline stripped). `done: true`
+// is set on the final frame for the job; no more `init.output` frames will
+// follow for this jobId.
+const InitOutputFrameZ = z.object({
+    type: z.literal("init.output"),
+    jobId: z.string(),
+    chunk: z.string(),
+    done: z.boolean().optional(),
+});
+// Init job failed. Terminal — no `init.output` follow-ups.
+const InitErrorFrameZ = z.object({
+    type: z.literal("init.error"),
+    jobId: z.string(),
+    message: z.string(),
+});
+const PongFrameZ = z.object({
+    type: z.literal("pong"),
+});
+// Broadcast after a successful v2 action dispatch. Clients use these frames to
+// invalidate caches without ad-hoc refetches (e.g. invalidate the project list
+// after `project.launch` succeeds). `name` matches the action name in
+// `command-center/actions/contract.ts`. `result` is loose at the schema layer
+// because each action has its own result shape.
+const ActionCompleteFrameZ = z.object({
+    type: z.literal("action.complete"),
+    name: z.string(),
+    result: z.unknown(),
+});
+const ConfigChangedFrameZ = z.object({
+    type: z.literal("config.changed"),
+    sessionName: z.string(),
+});
+const TerminalsChangedFrameZ = z.object({
+    type: z.literal("terminals.changed"),
+    sessionName: z.string(),
+});
+export const ServerFrameSchemaZ = z.discriminatedUnion("type", [
+    HelloFrameZ,
+    SnapshotFrameZ,
+    SessionsChangedFrameZ,
+    ProjectsChangedFrameZ,
+    InitOutputFrameZ,
+    InitErrorFrameZ,
+    PongFrameZ,
+    ActionCompleteFrameZ,
+    ConfigChangedFrameZ,
+    TerminalsChangedFrameZ,
+    WorkspaceAddedFrameSchemaZ,
+    WorkspaceRemovedFrameSchemaZ,
+]);

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

@@ -0,0 +1,27 @@
+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/send.js

@@ -0,0 +1,141 @@
+import { randomUUID } from "node:crypto";
+import { resolve, join } from "node:path";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { getSessionName } from "./lib/yaml-io.js";
+import { getSessionState } from "@tmux-ide/tmux-bridge";
+import { listSessionPanes, sendCommand, sendText, getPaneBusyStatus, } from "./widgets/lib/pane-comms.js";
+import { IdeError } from "./lib/errors.js";
+export 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 function writeDispatchFile(dir, paneId, message) {
+    if (message.length <= LONG_MESSAGE_THRESHOLD)
+        return null;
+    const dispatchDir = join(dir, ".tasks", "dispatch");
+    if (!existsSync(dispatchDir))
+        mkdirSync(dispatchDir, { recursive: true });
+    const paneSlug = paneId.replace("%", "");
+    const filename = `send-${paneSlug}-${Date.now()}-${randomUUID().slice(0, 8)}.md`;
+    const filePath = join(dispatchDir, filename);
+    writeFileSync(filePath, message);
+    return { filePath, triggerCmd: `Read and execute: .tasks/dispatch/${filename}` };
+}
+/**
+ * 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 function resolvePane(panes, target) {
+    // 1. Exact pane ID
+    if (target.startsWith("%")) {
+        return panes.find((p) => p.id === target) ?? null;
+    }
+    // 2. @ide_name match
+    const byName = panes.find((p) => p.name === target);
+    if (byName)
+        return byName;
+    // 3. Exact title match
+    const byTitle = panes.find((p) => p.title === target);
+    if (byTitle)
+        return byTitle;
+    // 4. Role match
+    const lower = target.toLowerCase();
+    if (["lead", "teammate", "planner"].includes(lower)) {
+        const byRole = panes.find((p) => p.role === lower);
+        if (byRole)
+            return byRole;
+    }
+    // 5. Case-insensitive partial title match
+    const byPattern = panes.find((p) => p.title.toLowerCase().includes(lower));
+    if (byPattern)
+        return byPattern;
+    return null;
+}
+function prepareMessage(message, busyStatus) {
+    if (busyStatus === "agent") {
+        // Collapse multiline to single line for Claude Code TUI
+        // Prevents paste preview that requires manual Enter
+        return message.replace(/\n+/g, " ").trim();
+    }
+    return message;
+}
+export async function send(targetDir, opts) {
+    const dir = resolve(targetDir ?? ".");
+    const { name: session } = getSessionName(dir);
+    const { json, to: target, message: rawMessage, noEnter } = opts;
+    if (!target) {
+        throw new IdeError("Missing target. Usage: tmux-ide send <target> <message>", {
+            code: "USAGE",
+        });
+    }
+    if (!rawMessage) {
+        throw new IdeError("Missing message. Usage: tmux-ide send <target> <message>", {
+            code: "USAGE",
+        });
+    }
+    // Verify session is running
+    const state = getSessionState(session);
+    if (!state.running) {
+        throw new IdeError(`Session "${session}" is not running`, {
+            code: "SESSION_NOT_FOUND",
+        });
+    }
+    const panes = listSessionPanes(session);
+    const pane = resolvePane(panes, target);
+    if (!pane) {
+        const available = panes
+            .map((p) => {
+            const label = p.name ?? p.title;
+            return `  ${p.id}  ${label}${p.role ? ` (${p.role})` : ""}`;
+        })
+            .join("\n");
+        throw new IdeError(`Pane "${target}" not found.\n\nAvailable panes:\n${available}`, {
+            code: "PANE_NOT_FOUND",
+        });
+    }
+    const busyStatus = getPaneBusyStatus(session, pane.id);
+    const message = prepareMessage(rawMessage, busyStatus);
+    let sentViaFile = false;
+    if (noEnter) {
+        sendText(session, pane.id, message);
+    }
+    else {
+        const dispatch = writeDispatchFile(dir, pane.id, message);
+        if (dispatch) {
+            sendCommand(session, pane.id, dispatch.triggerCmd);
+            sentViaFile = true;
+        }
+        else {
+            sendCommand(session, pane.id, message);
+        }
+    }
+    const result = {
+        ok: true,
+        session,
+        target: {
+            paneId: pane.id,
+            name: pane.name,
+            title: pane.title,
+            role: pane.role,
+        },
+        message,
+        busyStatus,
+        sentViaFile,
+        ...(busyStatus === "agent" ? { warning: "agent_busy" } : {}),
+    };
+    if (json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const label = pane.name ?? pane.title;
+    const preview = message.length > 60 ? message.slice(0, 60) + "..." : message;
+    console.log(`Sent to "${label}" (${pane.id}): ${preview}`);
+    if (busyStatus === "agent") {
+        console.log("Warning: agent appears busy. Message sent anyway.");
+    }
+}

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

@@ -0,0 +1,10 @@
+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/index.js

@@ -0,0 +1,55 @@
+import { createServer } from "node:http";
+import { parse } from "node:url";
+import { Hono } from "hono";
+import { getRequestListener } from "@hono/node-server";
+import { WebSocketServer } from "ws";
+import { handlePtyWebSocket, shutdownPtyBridges } from "./ws-route.js";
+const DEFAULT_PORT = 6070;
+export function resolvePort(port) {
+    const raw = port ?? Number.parseInt(process.env.TMUX_IDE_PORT ?? String(DEFAULT_PORT), 10);
+    if (!Number.isInteger(raw) || raw <= 0) {
+        throw new Error(`Invalid server port: ${String(port ?? process.env.TMUX_IDE_PORT)}`);
+    }
+    return raw;
+}
+export function createApp() {
+    const app = new Hono();
+    app.get("/", (c) => c.text("tmux-ide server"));
+    app.get("/health", (c) => c.json({ ok: true }));
+    return app;
+}
+export async function start(port) {
+    const resolvedPort = resolvePort(port);
+    const app = createApp();
+    const server = createServer(getRequestListener(app.fetch));
+    const ptyWss = new WebSocketServer({ noServer: true });
+    server.on("upgrade", (req, socket, head) => {
+        const { pathname } = parse(req.url ?? "/", true);
+        const match = pathname?.match(/^\/ws\/pty\/([^/]+)$/);
+        if (!match) {
+            socket.destroy();
+            return;
+        }
+        const id = decodeURIComponent(match[1] ?? "");
+        ptyWss.handleUpgrade(req, socket, head, (ws) => {
+            handlePtyWebSocket(ws, id);
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(resolvedPort, "0.0.0.0", () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    console.log(`tmux-ide server listening on http://0.0.0.0:${resolvedPort}`);
+    return {
+        port: resolvedPort,
+        server,
+        close: () => new Promise((resolve, reject) => {
+            shutdownPtyBridges();
+            ptyWss.close();
+            server.close((err) => (err ? reject(err) : resolve()));
+        }),
+    };
+}

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

@@ -0,0 +1,174 @@
+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 {};