ai-remote 0.4.8 → 0.4.10

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

@@ -1,28 +0,0 @@
-/** 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

@@ -1,40 +0,0 @@
-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

@@ -1,39 +0,0 @@
-/**
- * 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

@@ -1,97 +0,0 @@
-/** 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

@@ -1,52 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

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

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

@@ -1,62 +0,0 @@
-export declare const CLIENT_VERSION = "SSH-2.0-CloudflareGateway_1.0";
-/** Pick the first client preference the host also offered (RFC 4253 7.1). */
-export declare function negotiate(clientNames: any, serverNames: any): any;
-export declare class SshTransport extends EventTarget {
-    #private;
-    url: string;
-    verifyHost: (info: any) => Promise<boolean> | boolean;
-    log: (...args: any[]) => void;
-    socket: WebSocket | null;
-    openTransport: ((url: string) => any) | null;
-    closed: boolean;
-    buffer: Uint8Array;
-    serverVersion: string;
-    greeting: string[];
-    sendSequence: number;
-    receiveSequence: number;
-    outgoing: any;
-    incoming: any;
-    sessionId: Uint8Array | null;
-    kex: any;
-    kexQueue: Uint8Array[];
-    keepaliveTimer: any;
-    bytesSent: number;
-    bytesReceived: number;
-    encryptChain?: Promise<void>;
-    newKeysBarrier?: Promise<void> | null;
-    releaseNewKeys?: (() => void) | null;
-    pendingServerKexInit?: Uint8Array | null;
-    established?: boolean;
-    /**
-     * @param {string} url gateway WebSocket URL
-     * @param {object} options
-     * @param {(info: object) => Promise<boolean>} options.verifyHost decides
-     *   whether an unknown or changed host key may be used.
-     */
-    constructor(url: string, { verifyHost, log, openTransport }?: {
-        verifyHost?: (info: any) => Promise<boolean> | boolean;
-        log?: (...args: any[]) => void;
-        /** Returns a WebSocket-shaped transport for `url`; default is a real one. */
-        openTransport?: ((url: string) => any) | null;
-    });
-    connect(): void;
-    disconnect(message?: string): void;
-    fail(error: unknown): void;
-    /** Application packets wait while a key exchange is in flight (RFC 4253 7.1). */
-    send(payload: Uint8Array): boolean;
-}
-/** Padding for a GCM packet: only the encrypted part is block aligned. */
-export declare function gcmPaddingLength(payloadLength: any): number;
-/** A packet before any keys exist: the whole thing is block aligned. */
-export declare function framePlain(payload: Uint8Array): Uint8Array<ArrayBufferLike>;
-export declare function buildKexInit(offer: any): Uint8Array<ArrayBufferLike>;
-export declare function parseKexInit(payload: Uint8Array): {
-    kex: string[];
-    hostKey: string[];
-    cipherClientToServer: string[];
-    cipherServerToClient: string[];
-    macClientToServer: string[];
-    macServerToClient: string[];
-    compressionClientToServer: string[];
-    compressionServerToClient: string[];
-};

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

@@ -1,52 +0,0 @@
-export declare function encodeUtf8(text: string): Uint8Array;
-export declare function decodeUtf8(bytes: Uint8Array): string;
-export declare function concatBytes(...parts: readonly Uint8Array[]): Uint8Array;
-/** Constant-time-ish equality. Used for authentication tags and fingerprints. */
-export declare function bytesEqual(a: Uint8Array, b: Uint8Array): boolean;
-export declare function toBase64(bytes: Uint8Array): string;
-export declare function fromBase64(text: string): Uint8Array;
-/** Base64url without padding, which is what a JSON Web Key wants. */
-export declare function toBase64Url(bytes: Uint8Array): string;
-export declare class SshWriter {
-    #private;
-    private bytes;
-    private view;
-    private offset;
-    constructor(capacity?: number);
-    u8(value: number): this;
-    boolean(value: boolean): this;
-    u32(value: number): this;
-    raw(bytes: Uint8Array): this;
-    /** A length-prefixed string. Text is encoded as UTF-8. */
-    string(value: string | Uint8Array): this;
-    nameList(names: readonly string[]): this;
-    /**
-     * An mpint: two's complement, big endian, with no leading zero bytes except
-     * the one that keeps a positive number from looking negative.
-     */
-    mpint(bytes: Uint8Array): this;
-    get length(): number;
-    take(): Uint8Array;
-}
-export declare class SshReader {
-    #private;
-    private readonly bytes;
-    private readonly view;
-    offset: number;
-    constructor(bytes: Uint8Array, offset?: number);
-    get remaining(): number;
-    u8(): number;
-    boolean(): boolean;
-    u32(): number;
-    raw(count: number): Uint8Array;
-    /** The bytes of a length-prefixed string. */
-    stringBytes(): Uint8Array;
-    string(): string;
-    nameList(): string[];
-    /** An mpint's magnitude, with the sign byte removed. */
-    mpint(): Uint8Array;
-    skip(count: number): this;
-    rest(): Uint8Array;
-}
-/** Pad a magnitude out to a fixed width, which raw curve points need. */
-export declare function padStart(bytes: Uint8Array, width: number): Uint8Array;

package/dist/protocols/types.d.ts

@@ -1,127 +0,0 @@
-/**
- * The interface every remote-desktop protocol presents to the UI.
- *
- * The workspace -- toolbar, stats rail, on-screen keyboard, reconnects -- does
- * not care whether a session is VNC or RDP. Everything that does differ is
- * reached through this interface instead of branching at each call site.
- */
-import type { ConnectionSettings, RemoteAppLaunch } from '../shared/connection';
-import type { RdpSecurity, RemoteProtocol } from '../shared/protocol';
-/** Where the pointer may go, in framebuffer pixels. */
-export interface ScreenGeometry {
-    width: number;
-    height: number;
-    viewport: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-}
-/** Mouse buttons, as the UI names them. */
-export type PointerButton = 0 | 1 | 2;
-/** Wheel movement in discrete remote-protocol notches. Positive is right/down. */
-export interface ScrollDelta {
-    x: number;
-    y: number;
-}
-/**
- * A live session. Both drivers expose this, so the AI pane's screen tool and
- * the toolbar never have to ask which protocol they are driving.
- */
-export interface RemoteSession extends EventTarget {
-    readonly protocol: RemoteProtocol;
-    disconnect(): void;
-    /** True once the desktop has been reached. */
-    readonly connected: boolean;
-    /** Fit the remote desktop to the pane rather than scrolling it. */
-    scaleViewport: boolean;
-    /** Watch without sending keyboard or pointer input. */
-    viewOnly: boolean;
-    /** RFB quality level. RDP ignores it. */
-    qualityLevel?: number;
-    /** RFB compression level. RDP ignores it. */
-    compressionLevel?: number;
-    /** The transport the metrics rail instruments. Can appear a tick after construction. */
-    readonly socket?: WebSocket | null;
-    readonly screenGeometry: ScreenGeometry;
-    movePointer(x: number, y: number): boolean;
-    clickPointer(x: number, y: number, button?: PointerButton): boolean;
-    pointerButton(x: number, y: number, button?: PointerButton, pressed?: boolean): boolean;
-    scrollPointer(x: number, y: number, delta: ScrollDelta): boolean;
-    typeText(text: string): boolean;
-    /** Prefer the protocol clipboard for longer text when it can paste reliably. */
-    pasteText?(text: string): boolean | Promise<boolean>;
-    /** Press or release one key by keysym. */
-    sendKey(keysym: number, code: string | null, down?: boolean): void;
-    /** Send text to the host's clipboard, when the protocol carries one. */
-    sendClipboard?(text: string): void;
-    /**
-     * Stop taking keystrokes: the workspace has given the keyboard to something
-     * local, such as the terminal or the assistant's message box.
-     *
-     * Both protocols listen on the element they paint into, so a key only leaves
-     * for the host while that element holds focus. Handing focus back is the
-     * whole mechanism -- plus, for RDP, letting go of anything still held down,
-     * which would otherwise stay down on the far side.
-     */
-    releaseKeyboard?(): void;
-    /** Ask the host for a different desktop size, when the protocol allows it. */
-    requestDesktopSize?(width: number, height: number): void;
-    /** The canvas the session paints into, for screenshots and thumbnails. */
-    readonly canvas?: HTMLCanvasElement | null;
-}
-/** What the workspace hands a driver to open a session. */
-export interface SessionOptions {
-    credentials: {
-        username: string;
-        password: string;
-    };
-    domain: string;
-    security: RdpSecurity;
-    remoteApp: RemoteAppLaunch | null;
-    /** Desktop size to ask the host for. */
-    width: number;
-    height: number;
-    /** False on a phone, where resizing the host would make a portrait strip of it. */
-    allowRemoteResize: boolean;
-    scaleViewport: boolean;
-    viewOnly: boolean;
-    quality: number;
-    compression: number;
-    /** Shown in this driver's own log lines. */
-    hostLabel: string;
-}
-/** Wording for the one connect dialog, which is shared markup across protocols. */
-export interface DialogCopy {
-    usernameLabel: string;
-    usernamePlaceholder: string;
-    usernameHelp: string;
-    passwordLabel: string;
-    passwordPlaceholder: string;
-    passwordHelp: string;
-    /** A VNC session needs some secret; RDP can sign in on the host's own screen. */
-    requiresPassword: boolean;
-}
-/** Everything the UI knows about a close, before anyone tries to explain it. */
-export interface DisconnectContext {
-    code?: number;
-    reason: string;
-    /** Pre-rendered ` (WebSocket 1006: ...)` tail, so wording stays consistent. */
-    suffix: string;
-}
-/** One protocol implementation. */
-export interface ProtocolDriver {
-    readonly protocol: RemoteProtocol;
-    /** Used as the prefix of this driver's console lines. */
-    readonly label: string;
-    readonly defaultPort: number;
-    readonly dialog: DialogCopy;
-    /** The gateway endpoint for this connection, including any query it needs. */
-    buildUrl(origin: string, settings: ConnectionSettings): string;
-    createSession(container: HTMLElement, url: string, options: SessionOptions): RemoteSession;
-    /** Extra detail worth logging once the first server frame has been parsed. */
-    describeState(session: RemoteSession): Record<string, unknown>;
-    /** Protocol-specific wording for a close, or null to fall back to the shared text. */
-    describeDisconnect(context: DisconnectContext): string | null;
-}

package/dist/protocols/vnc/des.d.ts

@@ -1,25 +0,0 @@
-/**
- * DES, for the one thing VNC still needs it for.
- *
- * The classic VNC password challenge (security type 2) is a single-block DES
- * encryption, and there is no getting round it: it is what every host from
- * x11vnc to RealVNC expects. Node's own crypto cannot help -- OpenSSL 3 moved
- * DES to the legacy provider, which is off in most builds -- and Web Crypto
- * never had it. So it is here, in about a hundred lines of tables.
- *
- * Nothing else in this repository should use this. DES is broken, and the only
- * reason it is here is that a protocol from 1998 froze it into a handshake.
- * The implementation is the textbook one, bit by bit: two blocks per sign-in
- * makes speed irrelevant and clarity worth having.
- */
-/** One 8-byte block, encrypted under an 8-byte key. */
-export declare function desEncryptBlock(key: Uint8Array, block: Uint8Array): Uint8Array;
-/**
- * The key VNC makes out of a password.
- *
- * Eight bytes, padded with zeros, and every byte's bits reversed -- an accident
- * of the original implementation that every host has copied ever since.
- */
-export declare function vncKey(password: string): Uint8Array;
-/** The answer to a host's 16-byte challenge: both halves, encrypted. */
-export declare function vncChallengeResponse(password: string, challenge: Uint8Array): Uint8Array;

package/dist/protocols/vnc/input.d.ts

@@ -1,5 +0,0 @@
-/** RFB wheel buttons for a bounded two-axis scroll, in wire order. */
-export declare function vncWheelMasks(delta: {
-    x: number;
-    y: number;
-}): number[];

package/dist/protocols/vnc/keysyms.d.ts

@@ -1,16 +0,0 @@
-/**
- * DOM key codes as X11 keysyms, which is what RFB sends.
- *
- * RDP sends scancodes, so the keyboard map on that side is a hardware table.
- * VNC sends keysyms -- what the key *means* rather than where it sits -- and
- * the useful consequence is that a character needs no modifier bookkeeping:
- * asking for `A` asks for a capital A, and the host works out that its own
- * keyboard would need shift for that.
- *
- * Latin-1 characters are their own code point. Everything above that is the
- * Unicode escape from the X protocol: 0x01000000 plus the code point.
- */
-/** A character's keysym: itself in Latin-1, and escaped above it. */
-export declare function keysymForChar(character: string): number;
-/** A DOM `code`'s keysym, or 0 for a key this does not know. */
-export declare function keysymForCode(code: string): number;