@termfleet/terminal 0.1.0

package/README.md

@@ -0,0 +1,31 @@
+# `@termfleet/terminal`
+
+Framework-neutral terminal transport and durable tmux session primitives shared
+by Termfleet and embedders such as Supercode.
+
+The package owns terminal attachment lifetimes. Closing an attachment releases
+its WebSocket, PTY client, listeners, timers, and file descriptors; it does not
+terminate the durable tmux session. Session termination remains a separate,
+explicit operation controlled by the embedding host.
+
+Exports are split by environment without splitting the package:
+
+- `@termfleet/terminal/client.js` — browser-safe terminal WebSocket client and
+  wire contract.
+- `@termfleet/terminal/attach.js` — Node CLI attachment loop with deterministic
+  TTY restoration and `Ctrl-b d` detach.
+- `@termfleet/terminal/tmux.js` — Node tmux session, capture, input, and ownership
+  primitives.
+- `@termfleet/terminal/tmux-stream.js` — Node PTY-to-WebSocket attachment with
+  idempotent handle cleanup.
+
+`@homebridge/node-pty-prebuilt-multiarch` and `ws` are optional peers because
+browser-only consumers need neither. A host importing `tmux-stream.js` must
+provide both.
+
+The tmux helpers accept an optional `socket` everywhere, so applications can
+use an isolated tmux server instead of touching the user's default server.
+Created sessions can carry an app-namespaced ownership mark; discovery does not
+claim or terminate unmarked sessions. Terminal attachment is intentionally
+separate from session termination: disposing a viewer only detaches its
+ephemeral PTY client and releases all handles.

package/dist/attach.d.ts

@@ -0,0 +1,29 @@
+import { Buffer } from "node:buffer";
+export declare const detachPrefixByte = 2;
+export declare const detachKeyByte = 100;
+export type DetachFilter = {
+    feed: (chunk: Buffer | string) => void;
+};
+export declare function createDetachFilter(opts: {
+    key?: number;
+    onDetach: () => void;
+    onInput: (data: string) => void;
+    prefix?: number;
+}): DetachFilter;
+export type AttachResult = {
+    exitCode?: number;
+    reason: "detached" | "exited";
+};
+export type AttachStreams = {
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WritableStream & {
+        columns?: number;
+        rows?: number;
+    };
+};
+export declare function attachTerminal(opts: {
+    authToken?: () => string | undefined;
+    baseUrl: string;
+    streams?: AttachStreams;
+    terminalId: string;
+}): Promise<AttachResult>;

package/dist/attach.js

@@ -0,0 +1,141 @@
+import { Buffer } from "node:buffer";
+import { TerminalClient } from "./client.js";
+// Connect the calling terminal directly to a live provider terminal — the raw
+// PTY pipe behind `termfleet attach` / `control` / `chat --attach`. It reuses
+// the same duplex socket the browser mirror speaks (TerminalClient: an `output`
+// stream in, `input` writes out), so there is no second transport: stdin →
+// input, output → stdout, and a tmux-style prefix key detaches without killing
+// the session (it stays live on the provider, durable on disk, reapable).
+// Ctrl-b, then `d` — the tmux detach chord. A lone prefix is held until the next
+// key so a real Ctrl-b still reaches the inner program (delayed one keystroke);
+// Ctrl-b Ctrl-b sends a literal Ctrl-b. This is the ONE place the chord is
+// decoded, kept pure (no socket/tty) so it is unit-testable.
+export const detachPrefixByte = 0x02; // Ctrl-b
+export const detachKeyByte = 0x64; // d
+export function createDetachFilter(opts) {
+    const prefix = opts.prefix ?? detachPrefixByte;
+    const key = opts.key ?? detachKeyByte;
+    let armed = false;
+    return {
+        feed(chunk) {
+            const bytes = typeof chunk === "string" ? [...Buffer.from(chunk, "utf8")] : [...chunk];
+            const out = [];
+            const flush = () => {
+                if (out.length === 0)
+                    return;
+                opts.onInput(Buffer.from(out).toString("utf8"));
+                out.length = 0;
+            };
+            for (const byte of bytes) {
+                if (armed) {
+                    armed = false;
+                    if (byte === key) {
+                        flush();
+                        opts.onDetach();
+                        return;
+                    }
+                    // Ctrl-b Ctrl-b → a literal Ctrl-b reaches the inner program; any
+                    // other key after the prefix forwards both bytes unchanged.
+                    out.push(prefix);
+                    if (byte !== prefix)
+                        out.push(byte);
+                    continue;
+                }
+                if (byte === prefix) {
+                    armed = true;
+                    continue;
+                }
+                out.push(byte);
+            }
+            flush();
+        }
+    };
+}
+// Raw-pipe the calling terminal to `terminalId` on the provider at `baseUrl`.
+// Resolves when the remote pane exits or the user detaches (Ctrl-b d). Restores
+// the local tty on every exit path. The pane size is fixed at connect from the
+// current terminal — the socket protocol carries no live resize yet.
+export async function attachTerminal(opts) {
+    const stdin = opts.streams?.stdin ?? process.stdin;
+    const stdout = opts.streams?.stdout ?? process.stdout;
+    const cols = stdout.columns ?? 80;
+    const rows = stdout.rows ?? 24;
+    const client = new TerminalClient({
+        ...(opts.authToken ? { authToken: opts.authToken } : {}),
+        baseUrl: opts.baseUrl,
+        cols,
+        rows,
+        terminalId: opts.terminalId
+    });
+    const socket = client.connect();
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        const onStdin = (chunk) => filter.feed(chunk);
+        // A real Ctrl-C is forwarded to the remote pane as a raw byte (raw mode), so
+        // it never lands here — these fire only on an EXTERNAL kill (or a parent
+        // termination). Without restoring the tty first, the process would die with
+        // raw mode still on, leaving the user's shell with no echo (needs `reset`).
+        const onSignal = () => finish({ reason: "detached" });
+        const cleanup = () => {
+            stdin.off("data", onStdin);
+            process.off("SIGINT", onSignal);
+            process.off("SIGTERM", onSignal);
+            if (stdin.isTTY)
+                stdin.setRawMode(false);
+            stdin.pause();
+            try {
+                client.close();
+            }
+            catch {
+                /* socket already closing */
+            }
+        };
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(result);
+        };
+        process.once("SIGINT", onSignal);
+        process.once("SIGTERM", onSignal);
+        const filter = createDetachFilter({
+            onDetach: () => finish({ reason: "detached" }),
+            onInput: (data) => {
+                if (socket.readyState === socket.OPEN)
+                    client.write(data);
+            }
+        });
+        socket.onopen = () => {
+            if (stdin.isTTY)
+                stdin.setRawMode(true);
+            stdin.resume();
+            stdin.on("data", onStdin);
+        };
+        socket.onmessage = (event) => {
+            // After detach/exit, a still-buffered frame must not write stray bytes to
+            // the now-foreground shell.
+            if (settled)
+                return;
+            const raw = typeof event.data === "string" ? event.data : String(event.data);
+            const message = client.parse(raw);
+            if (message.type === "output") {
+                stdout.write(message.data);
+            }
+            else if (message.type === "exit") {
+                finish({ exitCode: message.exitCode, reason: "exited" });
+            }
+            else if (message.type === "error" || message.type === "input-rejected") {
+                stdout.write(`\r\n[attach] ${message.message}\r\n`);
+            }
+        };
+        socket.onclose = () => finish({ reason: "exited" });
+        socket.onerror = () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(new Error(`Could not attach to terminal ${opts.terminalId} at ${opts.baseUrl}.`));
+        };
+    });
+}

package/dist/client.d.ts

@@ -0,0 +1,53 @@
+export type TerminalUrlResolver = {
+    wsAuthQuery(): Record<string, string>;
+    wsBase(baseUrl: string): string;
+};
+export declare const directTerminalUrlResolver: TerminalUrlResolver;
+export type TerminalHelloMessage = {
+    type: "hello";
+    cols: number;
+    rows: number;
+};
+export type TerminalOutputMessage = {
+    type: "output";
+    data: string;
+};
+export type TerminalExitMessage = {
+    type: "exit";
+    exitCode: number;
+    signal?: number;
+};
+export type TerminalErrorMessage = {
+    type: "error";
+    message: string;
+};
+export type TerminalInputRejectedMessage = {
+    type: "input-rejected";
+    message: string;
+};
+export type TerminalMessage = TerminalHelloMessage | TerminalOutputMessage | TerminalExitMessage | TerminalErrorMessage | TerminalInputRejectedMessage;
+export type TerminalClientOptions = {
+    authToken?: () => string | undefined;
+    baseUrl: string;
+    cols?: number;
+    rows?: number;
+    terminalId: string;
+    urlResolver?: TerminalUrlResolver;
+};
+export declare class TerminalClient {
+    readonly cols: number | undefined;
+    readonly rows: number | undefined;
+    readonly terminalId: string;
+    private readonly authToken?;
+    private socket?;
+    private readonly baseUrl;
+    private readonly urls;
+    constructor({ authToken, baseUrl, cols, rows, terminalId, urlResolver }: TerminalClientOptions);
+    connect(): WebSocket;
+    write(data: string): void;
+    close(): void;
+    parse(raw: string): TerminalMessage;
+    private requireOpenSocket;
+    private url;
+}
+export declare function webSocketBaseUrl(baseUrl: string): string;

package/dist/client.js

@@ -0,0 +1,100 @@
+export const directTerminalUrlResolver = {
+    wsAuthQuery: () => ({}),
+    wsBase: (baseUrl) => webSocketBaseUrl(baseUrl)
+};
+export class TerminalClient {
+    cols;
+    rows;
+    terminalId;
+    authToken;
+    socket;
+    baseUrl;
+    urls;
+    constructor({ authToken, baseUrl, cols, rows, terminalId, urlResolver }) {
+        this.authToken = authToken;
+        this.baseUrl = baseUrl;
+        this.cols = cols;
+        this.rows = rows;
+        this.terminalId = terminalId;
+        this.urls = urlResolver ?? directTerminalUrlResolver;
+    }
+    connect() {
+        if (this.socket && this.socket.readyState !== WebSocket.CLOSED && this.socket.readyState !== WebSocket.CLOSING) {
+            return this.socket;
+        }
+        this.socket = new WebSocket(this.url());
+        return this.socket;
+    }
+    write(data) {
+        const socket = this.requireOpenSocket();
+        socket.send(JSON.stringify({ data, type: "input" }));
+    }
+    close() {
+        this.socket?.close();
+    }
+    parse(raw) {
+        const message = JSON.parse(raw);
+        if (message.type === "hello") {
+            const cols = message.cols;
+            const rows = message.rows;
+            if (cols === undefined || rows === undefined || !Number.isInteger(cols) || !Number.isInteger(rows)) {
+                throw new Error(`Hello message for ${this.terminalId} did not include cols and rows.`);
+            }
+            return { cols, rows, type: "hello" };
+        }
+        if (message.type === "output") {
+            if (typeof message.data !== "string") {
+                throw new Error(`Output message for ${this.terminalId} did not include data.`);
+            }
+            return { data: message.data, type: "output" };
+        }
+        if (message.type === "exit") {
+            const exitCode = message.exitCode;
+            if (exitCode === undefined || !Number.isInteger(exitCode)) {
+                throw new Error(`Exit message for ${this.terminalId} did not include an exit code.`);
+            }
+            return { exitCode, signal: message.signal, type: "exit" };
+        }
+        if (message.type === "error") {
+            return { message: message.message ?? `WebSocket error for ${this.terminalId}.`, type: "error" };
+        }
+        if (message.type === "input-rejected") {
+            return { message: message.message ?? `Input rejected for ${this.terminalId}.`, type: "input-rejected" };
+        }
+        throw new Error(`Unsupported message type: ${String(message.type)}`);
+    }
+    requireOpenSocket() {
+        const socket = this.socket;
+        if (!socket || socket.readyState !== WebSocket.OPEN) {
+            throw new Error(`Terminal socket for ${this.terminalId} is not open.`);
+        }
+        return socket;
+    }
+    url() {
+        const url = new URL(`${this.urls.wsBase(this.baseUrl)}/ws`);
+        url.searchParams.set("terminalId", this.terminalId);
+        // Only send a size when the caller actually specified one (see
+        // TerminalClientOptions.cols/rows) — an omitted cols/rows must reach the
+        // gateway as an ABSENT query param, never "undefined" as a string, so its
+        // own `value === null` fallback to the pane's live size still fires.
+        if (this.cols !== undefined) {
+            url.searchParams.set("cols", String(this.cols));
+        }
+        if (this.rows !== undefined) {
+            url.searchParams.set("rows", String(this.rows));
+        }
+        const token = this.authToken?.();
+        if (token) {
+            url.searchParams.set("token", token);
+        }
+        for (const [name, value] of Object.entries(this.urls.wsAuthQuery())) {
+            url.searchParams.set(name, value);
+        }
+        return url.href;
+    }
+}
+export function webSocketBaseUrl(baseUrl) {
+    const url = new URL(baseUrl);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    return url.origin;
+}

package/dist/internal/exec.d.ts

@@ -0,0 +1,15 @@
+export type RunOptions = {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    inheritEnv?: boolean;
+    timeoutMs?: number;
+};
+export declare function commandExists(command: string): boolean;
+export declare function requireCommand(command: string, installHint?: string): void;
+export declare function ensureSystemToolsOnPath(): void;
+export declare function run(command: string, args: string[], options?: RunOptions): string;
+export declare function runBuffer(command: string, args: string[], options?: RunOptions): Buffer;
+export declare function runWithInput(command: string, args: string[], input: Buffer, options?: RunOptions): Buffer;
+export declare function runAsync(command: string, args: string[], options?: RunOptions): Promise<string>;
+export declare function runWithInputAsync(command: string, args: string[], input: Buffer | string, options?: RunOptions): Promise<string>;
+export declare function spawnInherited(command: string, args: string[]): void;

package/dist/internal/exec.js

@@ -0,0 +1,192 @@
+import { spawn, spawnSync } from "node:child_process";
+function runEnvironment(options) {
+    if (options.inheritEnv === false) {
+        return options.env ?? {};
+    }
+    return options.env ? { ...process.env, ...options.env } : process.env;
+}
+// Memoized by command name: PATH is finalized once at process startup
+// (ensureSystemToolsOnPath, called before any subprocess runs) and never changes
+// for the rest of the process's life in this codebase's usage, so re-spawning
+// `command -v <name>` on every call is pure repeated cost. This matters because
+// requireCommand/assertTmux-style guards run on hot per-request paths (e.g.
+// captureTerminal calling assertTmux on every capture) — a synchronous spawnSync
+// there would otherwise reintroduce a small blocking cost on every single call,
+// undermining the whole point of an async capture path (see CLAUDE.md's
+// event-loop invariant).
+const commandExistsCache = new Map();
+export function commandExists(command) {
+    const cached = commandExistsCache.get(command);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const result = spawnSync("command", ["-v", command], {
+        encoding: "utf8",
+        shell: true
+    });
+    const exists = result.status === 0;
+    commandExistsCache.set(command, exists);
+    return exists;
+}
+export function requireCommand(command, installHint) {
+    if (!commandExists(command)) {
+        const hint = installHint ? ` ${installHint}` : "";
+        throw new Error(`${command} is required but was not found on PATH.${hint}`);
+    }
+}
+// The standard system tool directories. Appended (never reordered) to PATH at
+// process startup so `run`/`execFile` of ps, tmux, and coreutils resolve even when
+// the process was launched from a stripped-PATH context — cron, launchd, a GUI
+// app, or a nested agent shell whose PATH was degraded. A provider booted that way
+// otherwise silently loses its lifecycle observation (`spawn ps ENOENT`) while
+// healthz still answers. Non-existent dirs (e.g. /opt/homebrew on Intel/Linux) are
+// harmless — the OS skips them during lookup.
+const systemToolDirs = ["/usr/bin", "/bin", "/usr/sbin", "/sbin", "/usr/local/bin", "/opt/homebrew/bin"];
+// Guarantee the system tool dirs are on PATH without disturbing the caller's own
+// order or entries: only the missing ones are appended. Call once at entrypoint
+// startup, before any subprocess runs. Idempotent.
+export function ensureSystemToolsOnPath() {
+    const current = (process.env.PATH ?? "").split(":").filter(Boolean);
+    const have = new Set(current);
+    const missing = systemToolDirs.filter((dir) => !have.has(dir));
+    if (missing.length > 0) {
+        process.env.PATH = [...current, ...missing].join(":");
+    }
+}
+export function run(command, args, options = {}) {
+    const result = spawnSync(command, args, {
+        cwd: options.cwd,
+        encoding: "utf8",
+        env: runEnvironment(options),
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: options.timeoutMs
+    });
+    if (result.error) {
+        const message = result.error.name === "Error" && "code" in result.error && result.error.code === "ETIMEDOUT"
+            ? `${command} ${args.join(" ")} timed out after ${options.timeoutMs}ms.`
+            : result.error.message;
+        const detail = runOutputDetail(result.stdout, result.stderr);
+        if (detail) {
+            throw new Error(`${message}\n${detail}`);
+        }
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        const output = runOutputDetail(result.stdout, result.stderr);
+        const detail = output ? `\n${output}` : "";
+        throw new Error(`${command} ${args.join(" ")} failed with exit ${result.status}.${detail}`);
+    }
+    return result.stdout;
+}
+function runOutputDetail(stdout, stderr) {
+    const stderrText = outputText(stderr);
+    const stdoutText = outputText(stdout);
+    if (stderrText && stdoutText) {
+        return `stderr:\n${stderrText}\nstdout:\n${stdoutText}`;
+    }
+    if (stderrText) {
+        return `stderr:\n${stderrText}`;
+    }
+    if (stdoutText) {
+        return `stdout:\n${stdoutText}`;
+    }
+    return "";
+}
+function outputText(value) {
+    if (Buffer.isBuffer(value)) {
+        return value.toString("utf8").trim();
+    }
+    return String(value ?? "").trim();
+}
+export function runBuffer(command, args, options = {}) {
+    const result = spawnSync(command, args, {
+        cwd: options.cwd,
+        env: runEnvironment(options),
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        const stderr = Buffer.isBuffer(result.stderr) ? result.stderr.toString("utf8").trim() : String(result.stderr ?? "").trim();
+        const detail = stderr ? `\n${stderr}` : "";
+        throw new Error(`${command} ${args.join(" ")} failed with exit ${result.status}.${detail}`);
+    }
+    return Buffer.isBuffer(result.stdout) ? result.stdout : Buffer.from(result.stdout ?? "");
+}
+export function runWithInput(command, args, input, options = {}) {
+    const result = spawnSync(command, args, {
+        cwd: options.cwd,
+        env: runEnvironment(options),
+        input,
+        stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        const stderr = Buffer.isBuffer(result.stderr) ? result.stderr.toString("utf8").trim() : String(result.stderr ?? "").trim();
+        const detail = stderr ? `\n${stderr}` : "";
+        throw new Error(`${command} ${args.join(" ")} failed with exit ${result.status}.${detail}`);
+    }
+    return Buffer.isBuffer(result.stdout) ? result.stdout : Buffer.from(result.stdout ?? "");
+}
+export async function runAsync(command, args, options = {}) {
+    return await spawnAsync(command, args, options);
+}
+export async function runWithInputAsync(command, args, input, options = {}) {
+    return await spawnAsync(command, args, options, input);
+}
+async function spawnAsync(command, args, options, input) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd: options.cwd,
+            env: runEnvironment(options),
+            stdio: [input === undefined ? "ignore" : "pipe", "pipe", "pipe"]
+        });
+        const stdout = [];
+        const stderr = [];
+        // Honor timeoutMs without blocking the loop (the sync `run` relied on
+        // spawnSync's timeout): SIGKILL the child and reject if it overruns.
+        const timer = options.timeoutMs === undefined
+            ? undefined
+            : setTimeout(() => {
+                child.kill("SIGKILL");
+                reject(new Error(`${command} ${args.join(" ")} timed out after ${options.timeoutMs}ms.`));
+            }, options.timeoutMs);
+        timer?.unref?.();
+        const clear = () => {
+            if (timer)
+                clearTimeout(timer);
+        };
+        child.stdout?.on("data", (chunk) => stdout.push(chunk));
+        child.stderr?.on("data", (chunk) => stderr.push(chunk));
+        child.on("error", (error) => {
+            clear();
+            reject(error);
+        });
+        child.on("close", (code) => {
+            clear();
+            if (code !== 0) {
+                const detail = Buffer.concat(stderr).toString("utf8").trim();
+                reject(new Error(`${command} ${args.join(" ")} failed with exit ${code}.${detail ? `\n${detail}` : ""}`));
+                return;
+            }
+            resolve(Buffer.concat(stdout).toString("utf8"));
+        });
+        if (input !== undefined && child.stdin) {
+            child.stdin.on("error", reject);
+            child.stdin.end(input);
+        }
+    });
+}
+export function spawnInherited(command, args) {
+    const child = spawn(command, args, { stdio: "inherit" });
+    child.on("exit", (code, signal) => {
+        if (signal) {
+            process.kill(process.pid, signal);
+            return;
+        }
+        process.exit(code ?? 1);
+    });
+}

package/dist/internal/process-tree.d.ts

@@ -0,0 +1 @@
+export declare function snapshotDescendantPids(rootPids: number[]): number[];

package/dist/internal/process-tree.js

@@ -0,0 +1,41 @@
+import { execFileSync } from "node:child_process";
+const PROCESS_SNAPSHOT_MAX_BUFFER = 16 * 1024 * 1024;
+// Return only each requested root and its descendants. This is the safe input
+// to the tmux session cleanup sweep: the tmux server is a parent and therefore
+// can never be selected, while helpers detached below a pane remain reachable.
+export function snapshotDescendantPids(rootPids) {
+    if (rootPids.length === 0)
+        return [];
+    const stdout = execFileSync("ps", ["-axo", "pid=,ppid="], {
+        encoding: "utf8",
+        maxBuffer: PROCESS_SNAPSHOT_MAX_BUFFER,
+        timeout: 5000
+    });
+    const children = new Map();
+    const processIds = new Set();
+    for (const line of stdout.split("\n")) {
+        const match = line.trim().match(/^(\d+)\s+(\d+)$/);
+        if (!match)
+            continue;
+        const pid = Number(match[1]);
+        const parent = Number(match[2]);
+        if (!Number.isInteger(pid) || pid < 1 || !Number.isInteger(parent) || parent < 0)
+            continue;
+        processIds.add(pid);
+        const siblings = children.get(parent) ?? [];
+        siblings.push(pid);
+        children.set(parent, siblings);
+    }
+    const result = [];
+    const pending = [...new Set(rootPids.filter((pid) => processIds.has(pid)))];
+    const seen = new Set();
+    while (pending.length > 0) {
+        const pid = pending.pop();
+        if (pid === undefined || seen.has(pid))
+            continue;
+        seen.add(pid);
+        result.push(pid);
+        pending.push(...(children.get(pid) ?? []));
+    }
+    return result.sort((a, b) => a - b);
+}

package/dist/tmux-stream.d.ts

@@ -0,0 +1,31 @@
+import type { WebSocket } from "ws";
+import pty from "@homebridge/node-pty-prebuilt-multiarch";
+export type TerminalAttachment = {
+    dispose(): void;
+};
+export declare class TmuxTerminalAttachError extends Error {
+    readonly phase: "resolve" | "spawn";
+    constructor(phase: "resolve" | "spawn", cause: unknown);
+}
+export type TmuxTerminalSocketOptions<TAuthorization = void> = {
+    authorizeInput?: () => Promise<TAuthorization> | TAuthorization;
+    cols?: number;
+    cwd?: string;
+    errorLabel?: string;
+    onInput?: (data: string, authorization: TAuthorization | undefined) => Promise<void> | void;
+    rows?: number;
+    socket: WebSocket;
+    terminalId: string;
+    tmuxSocket?: string;
+    window?: number;
+};
+export declare function attachTmuxTerminalSocket<TAuthorization = void>(options: TmuxTerminalSocketOptions<TAuthorization>): TerminalAttachment;
+type ReconciledPty = {
+    child: ReturnType<typeof pty.spawn>;
+    orphanPtmxFds: number[];
+};
+export declare function spawnReconciledPty(file: string, args: string[], options: Parameters<typeof pty.spawn>[2]): ReconciledPty;
+export declare function releasePtyMaster(child: {
+    destroy(): void;
+}, orphanPtmxFds?: number[]): void;
+export {};