ai-remote 0.4.7 → 0.4.8

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

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

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

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

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

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

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

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

@@ -0,0 +1,64 @@
+/**
+ * An RFB client that needs no browser.
+ *
+ * The VNC path in this repository has always been noVNC in a tab with the
+ * gateway doing the handshake, which is fine for a tab and no use at all to a
+ * command line: `RFB` wants a DOM element to paint into, and the half of the
+ * handshake macOS requires lives in the Worker. This is the protocol on its
+ * own -- version, security, pixels and input -- speaking to an injected
+ * transport, so the CLI can hold a desktop the same way it holds an RDP one.
+ *
+ * The handshake reads as a straight line rather than a state machine, because
+ * that is what it is: each step waits for the bytes it needs. Everything after
+ * it is a message loop.
+ *
+ * Two pieces of the protocol need primitives no runtime offers portably --
+ * DES for the classic password challenge, MD5 and AES for Apple's key
+ * exchange -- so they arrive as an injected `crypto`, the same seam the
+ * transport uses.
+ */
+export interface RfbCrypto {
+    /** Security type 2: the 16-byte answer to the host's challenge. */
+    vncChallenge(password: string, challenge: Uint8Array): Uint8Array;
+    /** Security type 30: what macOS Screen Sharing asks for instead of a challenge. */
+    appleDh(params: Uint8Array, username: string, password: string): Uint8Array;
+}
+/** One painted area. `copyFrom` is a rectangle the host says is already on screen. */
+export interface RfbRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    /** RGBA, row-major. Absent for a copy. */
+    rgba?: Uint8Array;
+    copyFrom?: {
+        x: number;
+        y: number;
+    };
+}
+export interface RfbOptions {
+    username?: string;
+    password?: string;
+    /** Let other viewers stay connected. Always true here: a session is watched. */
+    shared?: boolean;
+    crypto: RfbCrypto;
+    openTransport: () => any;
+    log?: (step: string, detail?: unknown) => void;
+}
+export declare class RfbClient extends EventTarget {
+    #private;
+    readonly options: RfbOptions;
+    width: number;
+    height: number;
+    name: string;
+    connected: boolean;
+    constructor(options: RfbOptions);
+    connect(): void;
+    disconnect(): void;
+    /** `mask` is RFB's own numbering: 1 left, 2 middle, 4 right, 8/16 wheel. */
+    pointer(x: number, y: number, mask?: number): void;
+    key(keysym: number, pressed: boolean): void;
+    cutText(text: string): void;
+    /** Ask for the whole desktop again rather than what has changed. */
+    refresh(): void;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Everything VNC-specific, behind the driver interface the RDP side also
+ * implements. noVNC's RFB object does the protocol work; this module decides
+ * how it is addressed, constructed, controlled and explained.
+ *
+ * VNC splits the handshake differently from RDP: noVNC hands authentication to
+ * the Worker, because macOS Screen Sharing needs the Apple Diffie-Hellman
+ * (type 30) exchange that noVNC does not implement. That is why credentials
+ * travel in the URL here and never do for RDP.
+ */
+import type { ProtocolDriver } from '../types';
+export declare const vncDriver: ProtocolDriver;