ai-remote 0.4.8 → 0.4.10

package/dist/protocols.d.ts

@@ -0,0 +1,349 @@
+/**
+ * The vocabulary both halves of the gateway share.
+ *
+ * The Worker and the browser have to agree on what a "protocol" is, what ports
+ * they default to and how an RDP security layer is named, so those live here
+ * rather than being re-declared on each side and drifting apart.
+ */
+/** A remote-desktop protocol the session workspace can display. */
+declare const REMOTE_PROTOCOLS: readonly ['vnc', 'rdp'];
+type RemoteProtocol = (typeof REMOTE_PROTOCOLS)[number];
+/** Every protocol the gateway relays, including the terminal side panel. */
+declare const TRANSPORT_PROTOCOLS: readonly ['vnc', 'rdp', 'ssh'];
+type TransportProtocol = (typeof TRANSPORT_PROTOCOLS)[number];
+/**
+ * The RDP security layer. `auto` negotiates with the host, which is right for
+ * anything that answers honestly; the rest are for hosts that do not.
+ */
+declare const RDP_SECURITY_MODES: readonly ['auto', 'nla', 'tls', 'rdp'];
+type RdpSecurity = (typeof RDP_SECURITY_MODES)[number];
+declare const DEFAULT_PORTS: Record<TransportProtocol, number>;
+declare const DEFAULT_SSH_PORT: number;
+/**
+ * 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;
+/** Max idle silence allowed during command execution. */
+export declare const COMMAND_IDLE_MS: number;
+declare function isRemoteProtocol(value: unknown): value is RemoteProtocol;
+declare function isRdpSecurity(value: unknown): value is RdpSecurity;
+/** Coerce anything to a protocol, falling back to what the caller opens on. */
+declare function toRemoteProtocol(value: unknown, fallback?: RemoteProtocol): RemoteProtocol;
+declare function toRdpSecurity(value: unknown, fallback?: RdpSecurity): RdpSecurity;
+/** A port number, or the protocol's default when the value is not one. */
+declare function toPort(value: unknown, fallback: number): number;
+/** A published Windows application launched instead of the full desktop. */
+interface RemoteAppLaunch {
+    /** Alias (`||notepad`) or an executable path. */
+    program: string;
+    workingDir?: string;
+    arguments?: string;
+}
+/** The companion terminal offered beside a desktop. */
+interface SshCompanion {
+    enabled: boolean;
+    port: number;
+    username: string;
+}
+/** Picture and input options. VNC negotiates them; RDP and SSH ignore what does not apply. */
+interface DisplaySettings {
+    /** RFB quality level, 1 (smallest) to 9 (sharpest). */
+    quality: number;
+    /** RFB compression level, 0 (fastest) to 9 (smallest). */
+    compression: number;
+    /** Fit the remote desktop to the pane rather than scrolling it. */
+    scaling: boolean;
+    /** Watch without sending keyboard or pointer input. */
+    viewOnly: boolean;
+}
+/**
+ * Everything a session needs. `password` is the only field never persisted
+ * anywhere -- not in the device library on the gateway, not in localStorage.
+ */
+interface ConnectionSettings {
+    /** Stable identity: protocol, address, port and program. See {@link connectionId}. */
+    id: string;
+    label: string;
+    protocol: RemoteProtocol;
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+    /** Windows domain or computer name. RDP only. */
+    domain: string;
+    security: RdpSecurity;
+    remoteApp: RemoteAppLaunch | null;
+    display: DisplaySettings;
+    ssh: SshCompanion;
+    /** Open the terminal panel as soon as the desktop appears. */
+    openSshOnConnect: boolean;
+}
+declare const DEFAULT_DISPLAY_SETTINGS: DisplaySettings;
+/**
+ * A connection's identity is what it points at, not when it was made. Editing
+ * the address therefore makes a different connection rather than silently
+ * repointing an existing card, which is the behaviour people expect from a
+ * list of machines.
+ */
+declare function connectionId(input: Pick<ConnectionSettings, 'protocol' | 'host' | 'port'> & {
+    remoteApp?: RemoteAppLaunch | null;
+}): string;
+/** A blank connection, ready for the dialog to fill in. */
+declare function emptyConnection(protocol?: RemoteProtocol): ConnectionSettings;
+declare function normalizeDisplaySettings(value: unknown): DisplaySettings;
+/**
+ * Build a complete, valid connection out of whatever a caller happens to have.
+ * Partial input from a saved card, a host list entry, a URL or localStorage all
+ * arrive here, so the dialog never has to reason about missing fields.
+ */
+declare function normalizeConnection(input: Partial<ConnectionSettings> & Record<string, unknown>): ConnectionSettings;
+/** What a connection is worth remembering by -- never the password. */
+type PersistedConnection = Omit<ConnectionSettings, 'password'>;
+declare function withoutPassword(settings: ConnectionSettings): PersistedConnection;
+/** A one-line description for the dialog's summary row and the status bar. */
+declare function describeConnection(settings: ConnectionSettings): string;
+/** 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. */
+type PointerButton = 0 | 1 | 2;
+/** Wheel movement in discrete remote-protocol notches. Positive is right/down. */
+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. */
+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. */
+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;
+}
+export declare const DEFAULT_PORT = 22;
+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;
+}
+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;
+}
+export declare const DRIVERS: Record<RemoteProtocol, ProtocolDriver>;
+/** Unknown names fall back to VNC, which is what the dialog opens on. */
+export declare function driverFor(protocol: string | undefined): ProtocolDriver;
+/** What the workspace knows about a session that has just ended. */
+export interface DisconnectDiagnostic {
+    protocol: RemoteProtocol;
+    /** The transport close, when one arrived. A 1006 means it did not. */
+    close: {
+        code: number;
+        reason: string;
+    } | null;
+    /** True once the session had reached the desktop. */
+    established: boolean;
+}
+/**
+ * Explain a disconnect in terms someone can act on. The protocol gets first
+ * say, then the close codes that mean the same thing either way.
+ */
+export declare function explainDisconnect(diagnostic: DisconnectDiagnostic, clean: boolean, protocolMessage: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-remote",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "description": "RDP, VNC and SSH protocol engines that run in Node, a Worker or a browser -- plus `npx ai-remote`, a CLI that drives a machine and shows you what it is doing",
   "type": "module",
   "bin": {
@@ -54,12 +54,12 @@
       "default": "./dist/apple-dh.js"
     },
     "./protocols": {
-      "types": "./dist/protocols/index.d.ts",
+      "types": "./dist/protocols.d.ts",
       "import": "./dist/protocols.js",
       "default": "./dist/protocols.js"
     },
     "./protocols/*": {
-      "types": "./dist/protocols/index.d.ts",
+      "types": "./dist/protocols.d.ts",
       "import": "./dist/protocols.js",
       "default": "./dist/protocols.js"
     }

package/dist/protocols/index.d.ts

@@ -1,33 +0,0 @@
-/**
- * The protocol registry the workspace talks to.
- *
- * The UI owns the toolbar, the dialogs, the stats rail and the on-screen
- * keyboard, none of which care whether a session is VNC or RDP. Everything that
- * does differ -- the endpoint, how a client is constructed, the wording of a
- * failure, the labels in the connect dialog -- is looked up here instead of
- * branching at each site.
- */
-import type { ProtocolDriver } from './types';
-import type { RemoteProtocol } from '../shared/protocol';
-export type { ProtocolDriver, RemoteSession, SessionOptions, ScreenGeometry } from './types';
-export * from './ssh/session';
-export * from './ssh/terminal';
-export declare const DRIVERS: Record<RemoteProtocol, ProtocolDriver>;
-/** Unknown names fall back to VNC, which is what the dialog opens on. */
-export declare function driverFor(protocol: string | undefined): ProtocolDriver;
-/** What the workspace knows about a session that has just ended. */
-export interface DisconnectDiagnostic {
-    protocol: RemoteProtocol;
-    /** The transport close, when one arrived. A 1006 means it did not. */
-    close: {
-        code: number;
-        reason: string;
-    } | null;
-    /** True once the session had reached the desktop. */
-    established: boolean;
-}
-/**
- * Explain a disconnect in terms someone can act on. The protocol gets first
- * say, then the close codes that mean the same thing either way.
- */
-export declare function explainDisconnect(diagnostic: DisconnectDiagnostic, clean: boolean, protocolMessage: string): string;

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

@@ -1,38 +0,0 @@
-export declare class Writer {
-    #private;
-    private bytes;
-    private view;
-    private offset;
-    constructor(capacity?: number);
-    u8(value: number): this;
-    u16le(value: number): this;
-    u16be(value: number): this;
-    u32le(value: number): this;
-    u32be(value: number): this;
-    raw(bytes: Uint8Array): this;
-    zeros(count: number): this;
-    /** UTF-16LE, optionally padded or truncated to a fixed byte width. */
-    utf16le(text: string, fixedBytes?: number): this;
-    /** Overwrite an earlier 16-bit slot, for length fields known only later. */
-    patchU16le(position: number, value: number): this;
-    patchU16be(position: number, value: number): this;
-    get length(): number;
-    take(): Uint8Array;
-}
-export declare class Reader {
-    #private;
-    private readonly bytes;
-    private readonly view;
-    offset: number;
-    constructor(bytes: Uint8Array, offset?: number);
-    get remaining(): number;
-    u8(): number;
-    u16le(): number;
-    u16be(): number;
-    u32le(): number;
-    u32be(): number;
-    raw(count: number): Uint8Array;
-    skip(count: number): this;
-    rest(): Uint8Array;
-}
-export declare function concatBytes(...parts: readonly Uint8Array[]): Uint8Array;

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

@@ -1,49 +0,0 @@
-export declare const CAPSET: {
-    GENERAL: number;
-    BITMAP: number;
-    ORDER: number;
-    BITMAPCACHE: number;
-    CONTROL: number;
-    ACTIVATION: number;
-    POINTER: number;
-    SHARE: number;
-    COLORCACHE: number;
-    SOUND: number;
-    INPUT: number;
-    FONT: number;
-    BRUSH: number;
-    GLYPHCACHE: number;
-    OFFSCREENCACHE: number;
-    VIRTUALCHANNEL: number;
-    RAIL: number;
-    WINDOW: number;
-    MULTIFRAGMENTUPDATE: number;
-    LARGE_POINTER: number;
-    SURFACE_COMMANDS: number;
-    BITMAP_CODECS: number;
-};
-export declare function buildClientCapabilities({ width, height, keyboardLayout, remoteApp, remoteAppCaps }: {
-    height: any;
-    keyboardLayout: any;
-    remoteApp?: boolean;
-    remoteAppCaps?: any;
-    width: any;
-}): {
-    bytes: Uint8Array<ArrayBufferLike>;
-    count: number;
-};
-/**
- * Read the host's Demand Active capabilities. The desktop size it reports wins
- * over anything the client asked for.
- */
-export declare function parseServerCapabilities(bytes: Uint8Array): {
-    desktopWidth: number;
-    desktopHeight: number;
-    preferredBitsPerPixel: number;
-    refreshRectSupport: boolean;
-    railSupportLevel: number;
-    windowSupportLevel: number;
-    numIconCaches: number;
-    numIconCacheEntries: number;
-    types: any[];
-};

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

@@ -1,18 +0,0 @@
-/**
- * Pull the RSA public key out of a DER X.509 certificate, for the TLS layer.
- *
- * CredSSP needs the exact bytes of the certificate's subjectPublicKey BIT
- * STRING contents -- the DER RSAPublicKey -- because that is what both ends
- * hash to bind the authentication to this TLS channel (MS-CSSP 3.1.5).
- */
-export declare function parseX509PublicKey(der: Uint8Array): {
-    modulus: Uint8Array<ArrayBufferLike>;
-    exponent: Uint8Array<ArrayBufferLike>;
-    subjectPublicKey: any;
-};
-/** Parse a server certificate blob into an RSA public key. */
-export declare function parseServerCertificate(certificateBytes: Uint8Array): {
-    modulus: Uint8Array<ArrayBuffer>;
-    exponent: Uint8Array<ArrayBuffer>;
-    source: string;
-};

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

@@ -1,56 +0,0 @@
-/**
- * A single RDP connection. Emits:
- *   'ready'    { width, height }      -- the desktop size is known
- *   'bitmap'   { rects }              -- decoded rectangles to paint
- *   'palette'  Uint8Array             -- 8bpp palette update
- *   'pointer'  pointer update         -- shape, position or visibility
- *   'error'    { message }            -- fatal, always followed by 'close'
- *   'close'    { clean, message }
- */
-export declare class RdpClient extends EventTarget {
-    #private;
-    constructor(url: string, options?: {});
-    disconnect(): void;
-    /**
-     * The window the session exists to show: the largest top-level application
-     * window. Menus, tooltips and drag images are RAIL windows too, and fitting
-     * one of those to the browser instead of the application would be worse than
-     * doing nothing.
-     */
-    get remoteAppPrimaryWindow(): any;
-    /**
-     * Size the remote application's window to the room the browser has for it.
-     *
-     * The RDP desktop is fixed for the life of a connection -- resizing it needs
-     * the dynamic virtual channel this client does not speak -- so the desktop is
-     * negotiated large at connect time and the application window is moved and
-     * resized inside it instead. The canvas then shows only that window.
-     */
-    fitRemoteApp(width: number, height: number): boolean;
-    /**
-     * Hand the host our clipboard text. Resolves once the host has acknowledged
-     * owning it, which is what makes it safe to send a paste keystroke next.
-     */
-    setClipboardText(text: string): any;
-    get clipboardShared(): boolean;
-    /**
-     * Deliver text into the session the way a person would: put it on the host's
-     * clipboard, wait for the host to acknowledge owning it, then press the paste
-     * shortcut. Waiting is what stops the keystroke from pasting the previous
-     * contents. A host with no clipboard channel gets the text typed instead.
-     */
-    pasteToHost(text: string): any;
-    get connected(): boolean;
-    sendKeyByCode(code: number, pressed: boolean): boolean;
-    sendUnicode(text: string): void;
-    sendCtrlAltDel(): void;
-    sendMouseMove(x: number, y: number): void;
-    sendMouseButton(button: number, pressed: boolean, x: number, y: number): void;
-    sendWheel(delta: number, x: number, y: number, horizontal?: boolean): void;
-    /** Tell the host which lock keys are already on, so they do not drift. */
-    sendKeyboardSync(toggleFlags: number): void;
-    /** Ask the host to resend a region, used after the canvas is re-created. */
-    refresh(rect: any): void;
-    /** Pause or resume host output, e.g. while the tab is hidden. */
-    setOutputEnabled(enabled: boolean): void;
-}

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

@@ -1,27 +0,0 @@
-/**
- * One clipboard channel. Emits:
- *   'text' { text } -- the host's clipboard now holds this text
- */
-export declare class ClipboardChannel extends EventTarget {
-    #private;
-    private readonly send;
-    private readonly log;
-    private ready;
-    private longFormatNames;
-    private localText;
-    private pendingAck;
-    /**
-     * @param {(bytes: Uint8Array) => void} send  delivers one complete channel message
-     * @param {(step: string, detail?: unknown) => void} [log]
-     */
-    constructor({ send, log }: {
-        log: any;
-        send: any;
-    });
-    /**
-     * Announce that this side now owns the clipboard and holds `text`. Resolves
-     * once the host has acknowledged, so a paste keystroke can safely follow.
-     */
-    setLocalText(text: string): Promise<unknown>;
-    receive(bytes: Uint8Array): void;
-}

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

@@ -1,34 +0,0 @@
-export declare class CredSspClient {
-    #private;
-    private readonly username;
-    private readonly domain;
-    private readonly password;
-    private readonly serverPublicKey;
-    private readonly send;
-    private readonly log;
-    private inbound;
-    private waiters;
-    constructor({ username, domain, password, serverPublicKey, send, log }: {
-        domain: any;
-        log: any;
-        password: any;
-        send: any;
-        serverPublicKey: any;
-        username: any;
-    });
-    /** Feed decrypted TLS application data. */
-    receive(bytes: Uint8Array): void;
-    authenticate(): Promise<{
-        authenticated: boolean;
-        reachedChallenge: boolean;
-        hostVersion: any;
-        targetName: string;
-        note: string;
-    } | {
-        reachedChallenge?: undefined;
-        note?: undefined;
-        authenticated: boolean;
-        hostVersion: any;
-        targetName: string;
-    }>;
-}