ai-remote 0.4.0 → 0.4.2

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

@@ -0,0 +1,50 @@
+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;
+    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/messages.js

@@ -52,4 +52,3 @@ export {
   EXTENDED_DATA_STDERR,
   MSG
 };
-//# sourceMappingURL=messages.js.map

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

@@ -0,0 +1,66 @@
+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 {'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/session.js

@@ -606,4 +606,3 @@ export {
   SshSession,
   frameCommand
 };
-//# sourceMappingURL=session.js.map

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;
+}

package/dist/protocols/ssh/terminal.js

@@ -188,4 +188,3 @@ class SshTerminal {
 export {
   SshTerminal
 };
-//# sourceMappingURL=terminal.js.map

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/transport.js

@@ -610,4 +610,3 @@ export {
   negotiate,
   parseKexInit
 };
-//# sourceMappingURL=transport.js.map

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/ssh/wire.js

@@ -186,4 +186,3 @@ export {
   toBase64,
   toBase64Url
 };
-//# sourceMappingURL=wire.js.map

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/types.js

@@ -1 +0,0 @@
-//# sourceMappingURL=types.js.map

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/input.js

@@ -13,4 +13,3 @@ function vncWheelMasks(delta) {
 export {
   vncWheelMasks
 };
-//# sourceMappingURL=input.js.map

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;

package/dist/protocols/vnc/session.js

@@ -256,4 +256,3 @@ const vncDriver = {
 export {
   vncDriver
 };
-//# sourceMappingURL=session.js.map

package/dist/shared/connection.d.ts

@@ -0,0 +1,81 @@
+/**
+ * One connection, described once.
+ *
+ * Every way of starting a session -- a saved card on the welcome screen, an
+ * address typed by hand, a RemoteApp launcher, a reconnect after a drop --
+ * produces exactly this shape and hands it to exactly one dialog. That is the
+ * whole point of the type: before it existed, a saved card could only ask for a
+ * username and a password, so its port, security layer, domain and picture
+ * quality were unreachable once the card had been made.
+ */
+import { type RdpSecurity, type RemoteProtocol } from './protocol';
+/** A published Windows application launched instead of the full desktop. */
+export interface RemoteAppLaunch {
+    /** Alias (`||notepad`) or an executable path. */
+    program: string;
+    workingDir?: string;
+    arguments?: string;
+}
+/** The companion terminal offered beside a desktop. */
+export interface SshCompanion {
+    enabled: boolean;
+    port: number;
+    username: string;
+}
+/** Picture and input options. VNC negotiates them; RDP and SSH ignore what does not apply. */
+export 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.
+ */
+export 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;
+}
+export 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.
+ */
+export declare function connectionId(input: Pick<ConnectionSettings, 'protocol' | 'host' | 'port'> & {
+    remoteApp?: RemoteAppLaunch | null;
+}): string;
+/** A blank connection, ready for the dialog to fill in. */
+export declare function emptyConnection(protocol?: RemoteProtocol): ConnectionSettings;
+export 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.
+ */
+export declare function normalizeConnection(input: Partial<ConnectionSettings> & Record<string, unknown>): ConnectionSettings;
+/** What a connection is worth remembering by -- never the password. */
+export type PersistedConnection = Omit<ConnectionSettings, 'password'>;
+export declare function withoutPassword(settings: ConnectionSettings): PersistedConnection;
+/** A one-line description for the dialog's summary row and the status bar. */
+export declare function describeConnection(settings: ConnectionSettings): string;

package/dist/shared/connection.js

@@ -111,4 +111,3 @@ export {
   normalizeDisplaySettings,
   withoutPassword
 };
-//# sourceMappingURL=connection.js.map

package/dist/shared/device.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A machine as the gateway remembers it, shared by the Durable Object that
+ * stores the record and the welcome screen that draws it.
+ *
+ * Passwords and account names are deliberately absent: the gateway has no need
+ * of them and every reason not to hold them. They live in the browser, next to
+ * the rest of the connection's settings.
+ */
+import type { RdpSecurity, RemoteProtocol } from './protocol';
+export interface SavedDevice {
+    id: string;
+    label: string;
+    host: string;
+    port: number;
+    protocol: RemoteProtocol;
+    domain?: string;
+    security?: RdpSecurity;
+    /** RemoteApp alias (`||notepad`) when this card launches an app, not a desktop. */
+    program?: string;
+    favorite?: boolean;
+    /** Milliseconds since the epoch; drives the "recent" ordering. */
+    lastUsed?: number;
+    createdAt?: number;
+    /** Set when a thumbnail exists, so the client can cache-bust its <img>. */
+    thumbnailAt?: number;
+}

package/dist/shared/device.js

@@ -1 +0,0 @@
-//# sourceMappingURL=device.js.map

package/dist/shared/hosts.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The gateway's own roster of machines, and the networks it is allowed to dial.
+ *
+ * Parsing lives here, with no reference to the Worker environment, so the same
+ * code shapes the list in `VNC_HOSTS`/`RDP_HOSTS` and the list the browser
+ * receives from `/api/hosts`. Reading those variables is the Worker's job --
+ * see `src/worker/config/hosts.ts`.
+ */
+import type { RemoteAppLaunch } from './connection';
+import { type RdpSecurity, type RemoteProtocol } from './protocol';
+/** Optional SSH access to the same machine, which publishes a terminal for it. */
+export interface HostSshAccess {
+    port: number;
+    username?: string;
+}
+/** One machine as the gateway's configuration describes it. */
+export interface RemoteHostTarget {
+    id: string;
+    name: string;
+    host: string;
+    port: number;
+    protocol: RemoteProtocol;
+    /** Windows domain or computer name pre-filled in the connect dialog. */
+    domain?: string;
+    security?: RdpSecurity;
+    remoteApp?: RemoteAppLaunch;
+    ssh?: HostSshAccess;
+}
+/**
+ * Build the target list offered in the connect dialog. `VNC_HOSTS` and
+ * `RDP_HOSTS` are merged into one list; each entry may override its protocol,
+ * so a single list can carry both kinds of target.
+ */
+export declare function parseConfiguredHosts(options: {
+    vncHostsJson?: string;
+    rdpHostsJson?: string;
+    defaultHost?: string;
+    defaultPort?: string;
+    defaultRdpHost?: string;
+    defaultRdpPort?: string;
+}): RemoteHostTarget[];
+/** One allowed network, as a base address and a mask. */
+export interface Subnet {
+    base: number;
+    mask: number;
+}
+/** Dotted-quad to a 32-bit number, or null for anything that is not one. */
+export declare function ipv4ToInt(value: string): number | null;
+/**
+ * The networks this gateway may dial, beyond the machines named in the host
+ * lists. Written as `ALLOWED_SUBNETS`, comma-separated:
+ *
+ *   192.168.8.0/24    a CIDR block
+ *   192.168.8.*       the same thing, written the way people say it
+ *   192.168.8.67      a single address
+ *
+ * This is what lets a terminal open on a machine that was never listed. Keep it
+ * to networks you own: anything inside one can be reached on any port by anyone
+ * who gets past the gateway's login.
+ */
+export declare function parseAllowedSubnets(value?: string): Subnet[];
+/** Whether a dotted-quad address falls inside one of the allowed networks. */
+export declare function hostInAllowedSubnets(host: string, value?: string): boolean;

package/dist/shared/hosts.js

@@ -130,4 +130,3 @@ export {
   parseAllowedSubnets,
   parseConfiguredHosts
 };
-//# sourceMappingURL=hosts.js.map