ai-remote 0.4.7 → 0.4.8

package/dist/protocols/rdp/rail.d.ts

@@ -0,0 +1,119 @@
+import { Reader } from './buffer';
+export declare const RAIL_ORDER: {
+    EXEC: number;
+    ACTIVATE: number;
+    SYSPARAM: number;
+    SYSCOMMAND: number;
+    HANDSHAKE: number;
+    WINDOW_MOVE: number;
+    CLIENT_STATUS: number;
+    EXEC_RESULT: number;
+    HANDSHAKE_EX: number;
+};
+export declare const RAIL_EXEC_RESULT: {
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+    5: string;
+    6: string;
+    7: string;
+};
+/** WM_SYSCOMMAND values a RAIL client may ask the host to apply to a window. */
+export declare const SYS_COMMAND: {
+    MINIMIZE: number;
+    MAXIMIZE: number;
+    CLOSE: number;
+    RESTORE: number;
+};
+/** SW_* show states reported by a window order's ShowState field. */
+export declare const SHOW_STATE: {
+    HIDDEN: number;
+    MINIMIZED: number;
+    MAXIMIZED: number;
+    NORMAL: number;
+};
+export declare const WINDOW_ORDER: {
+    TYPE_WINDOW: number;
+    STATE_NEW: number;
+    STATE_DELETED: number;
+    ICON: number;
+    CACHED_ICON: number;
+};
+export declare function railHandshake(buildNumber?: number): Uint8Array<ArrayBufferLike>;
+export declare function railClientStatus(flags?: number): Uint8Array<ArrayBufferLike>;
+/**
+ * SPI_SETWORKAREA. This is how a RAIL client tells the host how much room it
+ * has, and the host maximizes remote windows into it. Sending it again during
+ * the session is what keeps a maximized window matched to the browser window.
+ */
+export declare function railWorkArea(width: number, height: number): Uint8Array<ArrayBufferLike>;
+export declare function railSystemParameters(width: number, height: number): Uint8Array<ArrayBufferLike>[];
+/** TS_RAIL_ORDER_ACTIVATE: give (or take) input focus for one remote window. */
+export declare function railActivate(windowId: number, enabled?: boolean): Uint8Array<ArrayBufferLike>;
+/** TS_RAIL_ORDER_SYSCOMMAND: minimize, maximize, restore or close a window. */
+export declare function railSysCommand(windowId: number, command: string): Uint8Array<ArrayBufferLike>;
+/**
+ * TS_RAIL_ORDER_WINDOWMOVE. A client that draws remote windows itself sends
+ * this when the user finishes moving or resizing one; the host then applies
+ * the rectangle to the real window. It is the only way to give a remote window
+ * an exact size, which is what fitting one to the browser viewport needs.
+ */
+export declare function railWindowMove(windowId: number, { left, top, right, bottom }: {
+    bottom: any;
+    left: any;
+    right: any;
+    top: any;
+}): Uint8Array<ArrayBufferLike>;
+/** Build TS_RAIL_ORDER_EXEC. Strings are UTF-16LE and are not terminated. */
+export declare function railExecute({ program, workingDir, arguments: args }: {
+    arguments?: string;
+    program: any;
+    workingDir?: string;
+}): Uint8Array<ArrayBufferLike>;
+/**
+ * True for a window the session exists to show: not a child, not a tool
+ * window, and not one of the never-activated popups a Chromium or Electron
+ * application creates for menus, tooltips and drag images.
+ */
+export declare function isPrimaryWindow(candidate: any): boolean;
+/**
+ * Parse the window lifecycle subset of TS_UPDATE_ORDERS_PDU_DATA.
+ *
+ * RemoteApp window orders are Alternate Secondary orders and, unlike ordinary
+ * drawing orders, carry their total size in every header. That lets the parser
+ * read the fields it understands and then seek to the next order, rather than
+ * having to understand every icon, notification and desktop order to stay in
+ * sync with the stream.
+ */
+export declare function parseRemoteAppWindowOrders(reader: Reader): any[];
+/** Parse one or more complete RAIL PDUs delivered in a channel message. */
+export declare function parseRailPdus(bytes: Uint8Array): any[];
+/**
+ * Minimal RAIL endpoint for the browser client. It deliberately suppresses
+ * icon orders because the browser currently presents the RemoteApp session in
+ * one canvas rather than creating a local OS window per remote window.
+ */
+export declare class RailChannel {
+    private readonly application;
+    private width;
+    private height;
+    private readonly send;
+    private readonly onReady;
+    private readonly onResult;
+    private started;
+    constructor({ application, width, height, send, onReady, onResult }: {
+        application: any;
+        height: any;
+        onReady: any;
+        onResult: any;
+        send: any;
+        width: any;
+    });
+    receive(bytes: Uint8Array): void;
+    /** Republish the client's work area, which is what maximize resizes into. */
+    setWorkArea(width: number, height: number): boolean;
+    activate(windowId: number): boolean;
+    sysCommand(windowId: number, command: string): boolean;
+    moveWindow(windowId: number, rectangle: any): boolean;
+}

package/dist/protocols/rdp/rle.d.ts

@@ -0,0 +1,13 @@
+export declare function rleDecompress(src: Uint8Array, width: number, height: number, bytesPerPixel: number): Uint32Array<ArrayBuffer>;
+/**
+ * Reverse the row order of a decoded rectangle. RDP stores bitmaps bottom-up
+ * and a canvas expects top-down, so without this every rectangle is painted
+ * upside down.
+ */
+export declare function flipRows(pixels: Uint8Array, width: number): Uint32Array<ArrayBuffer> | Uint8Array<ArrayBufferLike>;
+/** Read uncompressed bitmap data, which RDP stores bottom-up. */
+export declare function readUncompressed(src: Uint8Array, width: number, height: number, bytesPerPixel: number): Uint32Array<ArrayBuffer>;
+/** Expand raw pixel values into RGBA for putImageData. */
+export declare function pixelsToRgba(pixels: Uint8Array, bitsPerPixel: number, palette: Uint32Array): Uint8ClampedArray<ArrayBuffer>;
+/** Decode one TS_BITMAP_DATA rectangle to RGBA. */
+export declare function decodeBitmapRect(rect: BitmapRect, palette: Uint32Array): Uint8ClampedArray<ArrayBuffer>;

package/dist/protocols/rdp/sec.d.ts

@@ -0,0 +1,59 @@
+import { concatBytes } from './buffer';
+export declare const SEC_FLAG: {
+    EXCHANGE_PKT: number;
+    TRANSPORT_REQ: number;
+    ENCRYPT: number;
+    RESET_SEQNO: number;
+    IGNORE_SEQNO: number;
+    INFO_PKT: number;
+    LICENSE_PKT: number;
+    LICENSE_ENCRYPT_CS: number;
+    REDIRECTION_PKT: number;
+    SECURE_CHECKSUM: number;
+    AUTODETECT_REQ: number;
+    AUTODETECT_RSP: number;
+    HEARTBEAT: number;
+};
+export declare class SecurityLayer {
+    #private;
+    private encryptionMethod;
+    private encryptionLevel;
+    private keys;
+    private encryptState;
+    private decryptState;
+    private encryptedPdus;
+    private decryptedPdus;
+    constructor();
+    /** True when data PDUs carry a basic security header at all. */
+    get headerPresent(): boolean;
+    get encryptionEnabled(): boolean;
+    configure(encryptionMethod: number, encryptionLevel: number, clientRandom: Uint8Array, serverRandom: Uint8Array): void;
+    /**
+     * Prefix a payload with the basic security header, signing and encrypting it
+     * when the negotiated level asks for that.
+     *
+     * `flags` carries the PDU-kind bits (SEC_INFO_PKT and friends). A payload with
+     * no flags and no encryption needs no header at all.
+     */
+    wrap(payload: Uint8Array, flags?: number): Uint8Array<ArrayBufferLike>;
+    /**
+     * Strip (and if needed decrypt) the basic security header from a host PDU.
+     * `headerMandatory` forces the header to be read even when the host reported
+     * no encryption, which licensing PDUs require.
+     */
+    unwrap(bytes: Uint8Array, headerMandatory?: boolean): {
+        flags: number;
+        payload: Uint8Array<ArrayBufferLike>;
+    };
+    /**
+     * Fast-path output carries the same signature and RC4 stream as a slow-path
+     * PDU, but without the basic security header in front of it.
+     */
+    decryptFastPath(payload: Uint8Array): Uint8Array<ArrayBufferLike>;
+    /**
+     * Security Exchange PDU (MS-RDPBCGR 2.2.1.10): the client random encrypted
+     * with the host public key, followed by eight bytes of padding.
+     */
+    static securityExchange(encryptedClientRandom: any): Uint8Array<ArrayBufferLike>;
+}
+export { concatBytes };

package/dist/protocols/rdp/session.d.ts

@@ -0,0 +1,62 @@
+import type { ProtocolDriver } from '../types';
+export declare class RdpSession extends EventTarget {
+    #private;
+    readonly protocol: 'rdp';
+    constructor(container: any, url: string, options?: {});
+    /**
+     * Ask the host to size the remote application's window to the room this
+     * session has on the page. Full-desktop sessions have nothing to do here:
+     * their size is fixed when the connection is negotiated.
+     */
+    fitToViewport(): any;
+    get connected(): boolean;
+    get canvas(): HTMLCanvasElement | null;
+    /** The workspace instruments this socket for byte counters and keepalives. */
+    get socket(): WebSocket | null;
+    get _sock(): {
+        _websocket: any;
+    };
+    get scaleViewport(): any;
+    set scaleViewport(enabled: any);
+    get viewOnly(): any;
+    set viewOnly(enabled: any);
+    /**
+     * The on-screen keyboard and the special-keys dialog call this with an X11
+     * keysym and a DOM code. RDP wants a scancode, so the code decides; the
+     * keysym is only a fallback for characters with no key of their own.
+     */
+    sendKey(keysym: any, code: number, pressed: boolean): void;
+    sendCtrlAltDel(): void;
+    /** Desktop pixels. Returns false when the session cannot accept input. */
+    movePointer(x: number, y: number): boolean;
+    clickPointer(x: number, y: number, button?: number): boolean;
+    pointerButton(x: number, y: number, button?: number, pressed?: boolean): boolean;
+    scrollPointer(x: number, y: number, delta: {
+        x: number;
+        y: number;
+    }): boolean;
+    /** Type a run of characters, which RDP carries as Unicode rather than keys. */
+    typeText(text: string): boolean;
+    /** What the canvas is showing, for a screen capture or a coordinate check. */
+    get screenGeometry(): {
+        width: any;
+        height: any;
+        viewport: any;
+    };
+    /**
+     * Hand text to the host's clipboard, falling back to typing it when the host
+     * declined the clipboard channel -- xrdp builds often do.
+     */
+    clipboardPasteFrom(text: string): void;
+    /**
+     * Deliver text into the session, which is what the clipboard drawer's button
+     * has always visibly done. `clipboardPasteFrom` only loads the clipboard, the
+     * way noVNC's method of that name does.
+     */
+    pasteText(text: string): any;
+    releaseKeyboard(): void;
+    /** True once the host has agreed to share its clipboard. */
+    get clipboardShared(): any;
+    disconnect(): void;
+}
+export declare const rdpDriver: ProtocolDriver;

package/dist/protocols/rdp/tls.d.ts

@@ -0,0 +1,18 @@
+export declare class Tls12Client {
+    #private;
+    /**
+     * @param {(bytes: Uint8Array) => void} send        write raw bytes to the transport
+     * @param {(bytes: Uint8Array) => void} onData      decrypted application data
+     * @param {(error: Error) => void} onError          fatal protocol failure
+     */
+    constructor({ send, onData, onError }: {
+        onData: any;
+        onError: any;
+        send: any;
+    });
+    start(): Promise<any>;
+    /** Feed transport bytes. Calls are serialized, so order is preserved. */
+    receive(bytes: Uint8Array): any;
+    /** Send application data once the handshake has completed. */
+    write(plaintext: Uint8Array): any;
+}

package/dist/protocols/rdp/vchannel.d.ts

@@ -0,0 +1,28 @@
+/** Channel option bits used when the channel is declared in Client Network Data. */
+export declare const CHANNEL_OPTION: {
+    INITIALIZED: number;
+    ENCRYPT_RDP: number;
+    COMPRESS_RDP: number;
+    SHOW_PROTOCOL: number;
+};
+export declare const CHANNEL_FLAG_SHOW_PROTOCOL = 16;
+/** What RDP itself uses; a host may accept more, but never needs to. */
+export declare const CHANNEL_CHUNK_LENGTH = 1600;
+/**
+ * Split one logical channel message into wire chunks, each already carrying its
+ * CHANNEL_PDU_HEADER. An empty message still produces one chunk, because the
+ * header is what tells the host anything happened at all.
+ */
+export declare function chunkChannelData(data: Uint8Array, chunkSize?: number, extraFlags?: number): any[];
+/**
+ * Reassemble inbound chunks into whole messages. A chunk that arrives without a
+ * preceding FIRST is treated as its own message rather than dropped: some hosts
+ * send small PDUs with both flags set and others with neither.
+ */
+export declare class ChannelReassembler {
+    private parts;
+    private expectedLength;
+    constructor();
+    /** Returns the completed message, or null while more chunks are pending. */
+    push(bytes: Uint8Array): Uint8Array<ArrayBufferLike>;
+}

package/dist/protocols/rdp/x224.d.ts

@@ -0,0 +1,40 @@
+export declare const TPKT_VERSION = 3;
+export declare const TPKT_HEADER_LENGTH = 4;
+export declare const NEG_FAILURE: {
+    SSL_REQUIRED: number;
+    SSL_NOT_ALLOWED: number;
+    SSL_CERT_NOT_ON_SERVER: number;
+    INCONSISTENT_FLAGS: number;
+    HYBRID_REQUIRED: number;
+    SSL_WITH_USER_AUTH_REQUIRED: number;
+};
+export declare const NEG_PROTOCOL: {
+    RDP: number;
+    SSL: number;
+    HYBRID: number;
+    RDSTLS: number;
+    HYBRID_EX: number;
+};
+/** X.224 Connection Request, carrying the protocols this client will accept. */
+export declare function connectionRequest(requestedProtocols: number): Uint8Array<ArrayBufferLike>;
+/**
+ * Read the X.224 Connection Confirm. Throws with the host's own explanation
+ * when it refuses the requested protocol.
+ */
+export declare function parseConnectionConfirm(frame: Uint8Array): {
+    selectedProtocol: number;
+    negotiated: boolean;
+};
+/** Wrap a payload in TPKT + X.224 Data. */
+export declare function dataFrame(payload: Uint8Array): Uint8Array<ArrayBufferLike>;
+/** Strip TPKT + X.224 Data headers from a complete frame. */
+export declare function dataPayload(frame: Uint8Array): Uint8Array<ArrayBufferLike>;
+/**
+ * Split a byte stream into whole frames. RDP interleaves two framings on one
+ * connection: TPKT (first byte 0x03) and fast-path output (any other value),
+ * each with its own length encoding.
+ */
+export declare function splitFrames(buffer: Uint8Array): {
+    frames: any[];
+    rest: Uint8Array<ArrayBufferLike>;
+};

package/dist/protocols/ssh/identity.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Signing in with a key instead of a password.
+ *
+ * An identity is a public key blob, the algorithm name that goes with it, and
+ * something that can sign. What does the signing is deliberately behind a
+ * function: a key read off disk signs with Web Crypto, and a key held by
+ * ssh-agent signs by asking the agent -- the session cannot tell the two apart
+ * and does not need to.
+ *
+ * The parser here reads the format `ssh-keygen` writes by default, which no
+ * runtime can parse on its own: OpenSSH's own container rather than PKCS#8.
+ * Only unencrypted keys are read. A key with a passphrase would need bcrypt
+ * and a prompt, and the answer to a passphrase is ssh-agent, which is already
+ * holding the decrypted key.
+ */
+/** One key that can sign for a user, however it happens to be held. */
+export interface SshIdentity {
+    /** The public key type, e.g. `ssh-ed25519`. */
+    readonly keyType: string;
+    /** The public key, in the wire format the host expects. */
+    readonly keyBlob: Uint8Array;
+    /** Where it came from, for logs and error messages. */
+    readonly comment: string;
+    /**
+     * Signature algorithms to offer, best first. RSA keys sign under several,
+     * and a host will say which of them it is willing to take.
+     */
+    readonly algorithms: readonly string[];
+    /** The full signature blob (algorithm name and signature) over `data`. */
+    sign(data: Uint8Array, algorithm: string): Promise<Uint8Array>;
+}
+/**
+ * Read a private key file.
+ *
+ * Returns one identity, or throws with the reason a human can act on -- which
+ * for the common failure is "this key has a passphrase, so let ssh-agent hold
+ * it" rather than a decoder error.
+ */
+export declare function parsePrivateKey(text: string, comment?: string): Promise<SshIdentity>;

package/dist/protocols/ssh/kex.d.ts

@@ -0,0 +1,97 @@
+/** Key exchange methods, best first. All of them hash with SHA-256. */
+export declare const KEX_ALGORITHMS: {
+    'curve25519-sha256': {
+        type: string;
+        hash: string;
+    };
+    'curve25519-sha256@libssh.org': {
+        type: string;
+        hash: string;
+    };
+    'ecdh-sha2-nistp256': {
+        type: string;
+        curve: string;
+        hash: string;
+    };
+};
+/**
+ * Host key signature algorithms. `keyType` is what appears inside the key blob;
+ * a modern RSA key is signed with SHA-256 or SHA-512 but still calls itself
+ * ssh-rsa, so the two names differ there.
+ */
+export declare const HOST_KEY_ALGORITHMS: {
+    'ssh-ed25519': {
+        keyType: string;
+        kind: string;
+    };
+    'rsa-sha2-512': {
+        keyType: string;
+        kind: string;
+        hash: string;
+    };
+    'rsa-sha2-256': {
+        keyType: string;
+        kind: string;
+        hash: string;
+    };
+    'ecdsa-sha2-nistp256': {
+        keyType: string;
+        kind: string;
+        curve: string;
+        hash: string;
+    };
+};
+/**
+ * What this browser can actually do. X25519 and Ed25519 are recent additions to
+ * Web Crypto, so they are probed rather than assumed; the NIST curve and RSA
+ * have been there all along and always keep the session possible.
+ */
+export declare function negotiableAlgorithms(): Promise<any>;
+/** The client half of one key exchange. */
+export declare function createKexClient(algorithmName: string): Promise<{
+    hash: any;
+    publicKey: Uint8Array<ArrayBuffer>;
+    sharedSecret(serverPublicKey: any): Promise<Uint8Array<ArrayBuffer>>;
+}>;
+/** The key type named inside a host key blob, which the algorithm must match. */
+export declare function hostKeyType(keyBlob: Uint8Array): string;
+/** The SHA256:… fingerprint OpenSSH prints, so a user can compare it. */
+export declare function hostKeyFingerprint(keyBlob: Uint8Array): Promise<string>;
+/**
+ * Check that the host owns the key it presented, by verifying its signature
+ * over the exchange hash. A failure here is fatal: it is what stands between
+ * the session and a machine in the middle of it.
+ */
+export declare function verifyHostKeySignature({ algorithm, keyBlob, signatureBlob, exchangeHash }: {
+    algorithm: any;
+    exchangeHash: any;
+    keyBlob: any;
+    signatureBlob: any;
+}): Promise<boolean>;
+/**
+ * The exchange hash H (RFC 4253 section 8), which both sides compute from the
+ * same inputs and the host signs.
+ */
+export declare function exchangeHash({ hash, clientVersion, serverVersion, clientKexInit, serverKexInit, hostKeyBlob, clientPublicKey, serverPublicKey, sharedSecret, }: {
+    clientKexInit: any;
+    clientPublicKey: any;
+    clientVersion: any;
+    hash: any;
+    hostKeyBlob: any;
+    serverKexInit: any;
+    serverPublicKey: any;
+    serverVersion: any;
+    sharedSecret: any;
+}): Promise<Uint8Array<ArrayBuffer>>;
+/**
+ * Derive one key from the exchange (RFC 4253 section 7.2), extending it with
+ * further hash rounds when the cipher wants more bytes than one digest.
+ */
+export declare function deriveKey({ hash, sharedSecret, exchangeHash: h, letter, sessionId, length }: {
+    exchangeHash: any;
+    hash: any;
+    length: any;
+    letter: any;
+    sessionId: any;
+    sharedSecret: any;
+}): Promise<Uint8Array<ArrayBuffer>>;

package/dist/protocols/ssh/messages.d.ts

@@ -0,0 +1,52 @@
+export declare const MSG: {
+    DISCONNECT: number;
+    IGNORE: number;
+    UNIMPLEMENTED: number;
+    DEBUG: number;
+    SERVICE_REQUEST: number;
+    SERVICE_ACCEPT: number;
+    EXT_INFO: number;
+    KEXINIT: number;
+    NEWKEYS: number;
+    KEX_ECDH_INIT: number;
+    KEX_ECDH_REPLY: number;
+    USERAUTH_REQUEST: number;
+    USERAUTH_FAILURE: number;
+    USERAUTH_SUCCESS: number;
+    USERAUTH_BANNER: number;
+    USERAUTH_INFO_REQUEST: number;
+    /** The same number, in a publickey exchange: "that key would be accepted". */
+    USERAUTH_PK_OK: number;
+    USERAUTH_INFO_RESPONSE: number;
+    GLOBAL_REQUEST: number;
+    REQUEST_SUCCESS: number;
+    REQUEST_FAILURE: number;
+    CHANNEL_OPEN: number;
+    CHANNEL_OPEN_CONFIRMATION: number;
+    CHANNEL_OPEN_FAILURE: number;
+    CHANNEL_WINDOW_ADJUST: number;
+    CHANNEL_DATA: number;
+    CHANNEL_EXTENDED_DATA: number;
+    CHANNEL_EOF: number;
+    CHANNEL_CLOSE: number;
+    CHANNEL_REQUEST: number;
+    CHANNEL_SUCCESS: number;
+    CHANNEL_FAILURE: number;
+};
+/** SSH_EXTENDED_DATA_STDERR. */
+export declare const EXTENDED_DATA_STDERR = 1;
+export declare const DISCONNECT_REASON: {
+    1: string;
+    2: string;
+    3: string;
+    5: string;
+    6: string;
+    7: string;
+    8: string;
+    9: string;
+    10: string;
+    11: string;
+    12: string;
+    14: string;
+    15: string;
+};

package/dist/protocols/ssh/session.d.ts

@@ -0,0 +1,67 @@
+export declare const DEFAULT_PORT = 22;
+/**
+ * How patient `runCommand` is, in three different senses.
+ *
+ * A single deadline cannot tell "the shell ignored me" apart from "the
+ * installer is three minutes into a download", and a short one turns every
+ * real piece of work -- a package install, a build, a large copy -- into a
+ * false failure that also leaves the command running on the far side.
+ *
+ * So the wait is judged by what the shell is doing. It has START_MS to
+ * acknowledge the command at all; after that it may take as long as it likes
+ * as long as it keeps printing, and only silence longer than IDLE_MS, or a run
+ * longer than MAX_MS, is treated as stuck.
+ */
+export declare const COMMAND_START_MS = 20000;
+export declare const COMMAND_IDLE_MS: number;
+export declare const COMMAND_MAX_MS: number;
+/**
+ * The one line that runs `command` and marks where its output starts and ends.
+ *
+ * Each shell gets its own, because none of the three agree on how to print a
+ * string, run a command and read back its exit status.
+ */
+export declare function frameCommand(family: any, command: string, id: any): string;
+export declare class SshSession extends EventTarget {
+    #private;
+    /**
+     * @param {string} url          gateway WebSocket URL
+     * @param {object} options
+     * @param {string} options.username
+     * @param {string} [options.password]
+     * @param {SshIdentity[] | (() => Promise<SshIdentity[]>)} [options.identities]
+     * @param {'powershell'} [options.preferredShell]
+     * @param {(info: object) => Promise<boolean>} [options.verifyHost]
+     * @param {(prompt: object) => Promise<string>} [options.requestInput]
+     */
+    constructor(url: string, options?: {});
+    connect(): void;
+    disconnect(): void;
+    /** Send keystrokes, or anything else the terminal produces, to the shell. */
+    write(data: Uint8Array): void;
+    /**
+     * Run one command in this shell and return what it printed.
+     *
+     * Deliberately the *same* shell the user is looking at, not a second channel:
+     * a command the assistant runs inherits the working directory, the
+     * environment and the login the user already has, and it appears in their
+     * terminal as it happens. An agent acting on a machine invisibly is worse
+     * than an agent that is slower to read.
+     *
+     * The output is framed by markers rather than measured, because an
+     * interactive shell echoes its input and prints a prompt around it. The
+     * markers are assembled by the shell from two pieces, so the echoed command
+     * line -- which contains the pieces but not the joined marker -- never looks
+     * like the real boundary.
+     *
+     * A `command` event brackets the run so the terminal can label it, and the
+     * three deadlines above decide when a command is stuck rather than slow.
+     */
+    runCommand(command: string, { startMs, idleMs, maxMs, }?: {
+        idleMs?: number;
+        maxMs?: number;
+        startMs?: number;
+    }): Promise<unknown>;
+    /** Tell the shell its window changed, so full-screen programs redraw. */
+    resize(columns: number, rows: number): void;
+}

package/dist/protocols/ssh/terminal.d.ts

@@ -0,0 +1,46 @@
+export declare class SshTerminal {
+    constructor(container: any);
+    get columns(): any;
+    get rows(): any;
+    onData(handler: any): void;
+    onResize(handler: any): void;
+    write(data: Uint8Array): void;
+    /** Gateway-side notices, kept visually apart from what the host prints. */
+    notice(text: string, tone?: string): void;
+    clear(): void;
+    focus(): void;
+    /**
+     * Size the terminal to the panel, choosing the font so MIN_COLUMNS fit.
+     *
+     * The columns matter more than the type size here: the commands people run in
+     * a side panel -- `ls -l`, `top`, anything in PowerShell that prints a table
+     * -- are laid out for 80 columns, and a narrower grid wraps every row into an
+     * unreadable stack.
+     *
+     * `proposeDimensions()` reports the grid the current font size yields, and a
+     * monospace cell's width scales with its font size, so `fontSize * cols /
+     * MIN_COLUMNS` lands close to the size that gives MIN_COLUMNS. It is measured
+     * rather than assumed because the cell-width-to-font-size ratio belongs to
+     * whichever font the platform picked. A second pass settles the rounding.
+     * Changing the font resizes the element, which the ResizeObserver sees, so
+     * the guard keeps that from recursing.
+     */
+    fit(): void;
+    /** The grid the host is being told about, for a status line or a log. */
+    get geometry(): {
+        columns: any;
+        rows: any;
+        fontSize: any;
+    };
+    get selection(): any;
+    /**
+     * Read one line from the user, for a password or a one-time code the host
+     * asked for during authentication. The shell is not open yet, so the
+     * terminal is free to be a prompt.
+     */
+    readLine({ prompt, echo }?: {
+        echo?: boolean;
+        prompt?: string;
+    }): Promise<unknown>;
+    destroy(): void;
+}