ai-remote 0.4.2 → 0.4.3

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

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

package/dist/protocols/rdp/sec.js

@@ -1,155 +0,0 @@
-import { Reader, Writer, concatBytes } from "./buffer.js";
-import {
-  ENCRYPTION_METHOD,
-  deriveSessionKeys,
-  macSignature,
-  rc4Crypt,
-  rc4Init,
-  updateSessionKey
-} from "./crypto.js";
-import { ENCRYPTION_LEVEL } from "./gcc.js";
-const SEC_FLAG = {
-  EXCHANGE_PKT: 1,
-  TRANSPORT_REQ: 2,
-  ENCRYPT: 8,
-  RESET_SEQNO: 16,
-  IGNORE_SEQNO: 32,
-  INFO_PKT: 64,
-  LICENSE_PKT: 128,
-  LICENSE_ENCRYPT_CS: 512,
-  REDIRECTION_PKT: 1024,
-  SECURE_CHECKSUM: 2048,
-  AUTODETECT_REQ: 4096,
-  AUTODETECT_RSP: 8192,
-  HEARTBEAT: 16384
-};
-const KEY_ROTATION_INTERVAL = 4096;
-class SecurityLayer {
-  encryptionMethod;
-  encryptionLevel;
-  keys;
-  encryptState;
-  decryptState;
-  encryptedPdus;
-  decryptedPdus;
-  constructor() {
-    this.encryptionMethod = ENCRYPTION_METHOD.NONE;
-    this.encryptionLevel = ENCRYPTION_LEVEL.NONE;
-    this.keys = null;
-    this.encryptState = null;
-    this.decryptState = null;
-    this.encryptedPdus = 0;
-    this.decryptedPdus = 0;
-  }
-  /** True when data PDUs carry a basic security header at all. */
-  get headerPresent() {
-    return this.encryptionLevel !== ENCRYPTION_LEVEL.NONE || this.encryptionMethod !== ENCRYPTION_METHOD.NONE;
-  }
-  get encryptionEnabled() {
-    return this.encryptionMethod !== ENCRYPTION_METHOD.NONE && this.keys !== null;
-  }
-  configure(encryptionMethod, encryptionLevel, clientRandom, serverRandom) {
-    this.encryptionMethod = encryptionMethod;
-    this.encryptionLevel = encryptionLevel;
-    if (encryptionMethod === ENCRYPTION_METHOD.NONE) return;
-    if (encryptionMethod & ENCRYPTION_METHOD.FIPS) {
-      throw new Error("RDP: this host requires FIPS encryption, which this client does not implement");
-    }
-    this.keys = deriveSessionKeys(clientRandom, serverRandom, encryptionMethod);
-    this.encryptState = rc4Init(this.keys.encryptKey);
-    this.decryptState = rc4Init(this.keys.decryptKey);
-  }
-  #rotateEncryptKey() {
-    this.keys.encryptKey = updateSessionKey(
-      this.keys.initialEncryptKey,
-      this.keys.encryptKey,
-      this.keys.keyLength,
-      this.keys.is40Bit
-    );
-    this.encryptState = rc4Init(this.keys.encryptKey);
-    this.encryptedPdus = 0;
-  }
-  #rotateDecryptKey() {
-    this.keys.decryptKey = updateSessionKey(
-      this.keys.initialDecryptKey,
-      this.keys.decryptKey,
-      this.keys.keyLength,
-      this.keys.is40Bit
-    );
-    this.decryptState = rc4Init(this.keys.decryptKey);
-    this.decryptedPdus = 0;
-  }
-  /**
-   * Prefix a payload with the basic security header, signing and encrypting it
-   * when the negotiated level asks for that.
-   *
-   * `flags` carries the PDU-kind bits (SEC_INFO_PKT and friends). A payload with
-   * no flags and no encryption needs no header at all.
-   */
-  wrap(payload, flags = 0) {
-    const encrypt = this.encryptionEnabled;
-    if (!encrypt && flags === 0 && !this.headerPresent) return payload;
-    const writer = new Writer(payload.length + 16);
-    writer.u16le(flags | (encrypt ? SEC_FLAG.ENCRYPT : 0));
-    writer.u16le(0);
-    if (!encrypt) {
-      writer.raw(payload);
-      return writer.take();
-    }
-    writer.raw(macSignature(this.keys.macKey, payload));
-    writer.raw(rc4Crypt(this.encryptState, payload));
-    if (++this.encryptedPdus === KEY_ROTATION_INTERVAL) this.#rotateEncryptKey();
-    return writer.take();
-  }
-  /**
-   * Strip (and if needed decrypt) the basic security header from a host PDU.
-   * `headerMandatory` forces the header to be read even when the host reported
-   * no encryption, which licensing PDUs require.
-   */
-  unwrap(bytes, headerMandatory = false) {
-    if (!this.headerPresent && !headerMandatory) return { flags: 0, payload: bytes };
-    if (bytes.length < 4) return { flags: 0, payload: bytes };
-    const reader = new Reader(bytes);
-    const flags = reader.u16le();
-    reader.u16le();
-    if (!(flags & SEC_FLAG.ENCRYPT)) {
-      return { flags, payload: reader.rest() };
-    }
-    if (!this.encryptionEnabled) {
-      throw new Error("RDP: the host encrypted a PDU before the session keys existed");
-    }
-    reader.skip(8);
-    const payload = rc4Crypt(this.decryptState, reader.rest());
-    if (++this.decryptedPdus === KEY_ROTATION_INTERVAL) this.#rotateDecryptKey();
-    return { flags, payload };
-  }
-  /**
-   * Fast-path output carries the same signature and RC4 stream as a slow-path
-   * PDU, but without the basic security header in front of it.
-   */
-  decryptFastPath(payload) {
-    if (!this.encryptionEnabled) return payload;
-    if (payload.length <= 8) return payload;
-    const decrypted = rc4Crypt(this.decryptState, payload.subarray(8));
-    if (++this.decryptedPdus === KEY_ROTATION_INTERVAL) this.#rotateDecryptKey();
-    return decrypted;
-  }
-  /**
-   * Security Exchange PDU (MS-RDPBCGR 2.2.1.10): the client random encrypted
-   * with the host public key, followed by eight bytes of padding.
-   */
-  static securityExchange(encryptedClientRandom) {
-    const writer = new Writer(encryptedClientRandom.length + 16);
-    writer.u16le(SEC_FLAG.EXCHANGE_PKT);
-    writer.u16le(0);
-    writer.u32le(encryptedClientRandom.length + 8);
-    writer.raw(encryptedClientRandom);
-    writer.zeros(8);
-    return writer.take();
-  }
-}
-export {
-  SEC_FLAG,
-  SecurityLayer,
-  concatBytes
-};

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

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

package/dist/protocols/rdp/session.js

@@ -1,306 +0,0 @@
-import { RdpClient } from "./client.js";
-import { RdpDisplay } from "./display.js";
-import { DEFAULT_PORTS } from "../../shared/protocol.js";
-const DIALOG = {
-  usernameLabel: "Username",
-  usernamePlaceholder: "Windows username",
-  usernameHelp: "Use the Windows account name for this computer.",
-  passwordLabel: "Password",
-  passwordPlaceholder: "Windows password",
-  passwordHelp: "Use the Windows account password. It may be left empty when the host presents its own sign-in screen.",
-  // Credentials may be left empty and typed on the remote sign-in screen.
-  requiresPassword: false
-};
-function buildUrl(origin, settings) {
-  const query = new URLSearchParams({
-    host: settings.host,
-    port: String(settings.port),
-    security: settings.security
-  });
-  return `${origin}/rdp-ws?${query}`;
-}
-function describeDisconnect({ code, reason, suffix }) {
-  if (/hybrid_required|requires network level|authenticates before/i.test(reason)) {
-    return `The RDP host signs in before showing a desktop${suffix}. Enter the Windows username and password and connect again.`;
-  }
-  if (code === 1011 || /cannot connect|unreachable|tcp error|tcp write/i.test(reason)) {
-    return `The Worker could not keep a TCP connection to the RDP host${suffix}. Check that Remote Desktop is enabled and listening on this address and port.`;
-  }
-  return null;
-}
-class RdpSession extends EventTarget {
-  protocol = "rdp";
-  constructor(container, url, options = {}) {
-    super();
-    this.url = url;
-    this.options = options;
-    this.display = new RdpDisplay(container);
-    this.display.viewOnly = Boolean(options.viewOnly);
-    this._rfbConnectionState = "connecting";
-    this._scaleViewport = options.scaleViewport !== false;
-    this.display.scaleViewport = this._scaleViewport;
-    this.lastErrorMessage = "";
-    this.hostLabel = options.hostLabel || "Remote Desktop";
-    this.#createClient(options.security || "auto");
-    this.remoteAppLayoutObserver = options.remoteApp?.program && typeof ResizeObserver === "function" ? new ResizeObserver(() => this.fitToViewport()) : null;
-    this.remoteAppLayoutObserver?.observe(this.display.scrollHost);
-  }
-  #createClient(security) {
-    this.security = security;
-    this.client = new RdpClient(this.url, {
-      width: this.options.width,
-      height: this.options.height,
-      username: this.options.credentials?.username || "",
-      password: this.options.credentials?.password || "",
-      domain: this.options.domain || "",
-      security,
-      keyboardLayout: this.options.keyboardLayout || 1033,
-      clientName: this.options.clientName || "cf-gateway",
-      remoteApp: this.options.remoteApp || null
-    });
-    this.client.addEventListener("ready", (event) => {
-      const { width, height } = event.detail;
-      this.display.resize(width, height);
-      this.display.attachInput(this.client);
-      this.display.focus();
-      this.fitToViewport();
-      this._rfbConnectionState = "connected";
-      this.dispatchEvent(new CustomEvent("connect"));
-      this.dispatchEvent(new CustomEvent("desktopname", {
-        detail: { name: `${this.hostLabel} (${width}x${height})` }
-      }));
-    });
-    this.client.addEventListener("resize", (event) => {
-      const { width, height } = event.detail;
-      this.display.resize(width, height);
-      this.dispatchEvent(new CustomEvent("desktopname", {
-        detail: { name: `${this.hostLabel} (${width}x${height})` }
-      }));
-      this.fitToViewport();
-    });
-    this.client.addEventListener("remoteappviewport", (event) => {
-      this.display.setViewport(event.detail);
-    });
-    this.client.addEventListener("bitmap", (event) => {
-      this.display.drawRects(event.detail.rects, event.detail.palette);
-      this.dispatchEvent(new CustomEvent("frame", {
-        detail: { rects: event.detail.rects }
-      }));
-    });
-    this.client.addEventListener("palette", (event) => {
-      this.display.palette = event.detail;
-    });
-    this.client.addEventListener("pointer", (event) => {
-      this.display.applyPointer(event.detail);
-    });
-    this.client.addEventListener("clipboard", (event) => {
-      this.dispatchEvent(new CustomEvent("clipboard", { detail: { text: event.detail.text } }));
-    });
-    this.client.addEventListener("remoteappresult", (event) => {
-      this.dispatchEvent(new CustomEvent("remoteappresult", { detail: event.detail }));
-    });
-    this.client.addEventListener("remoteappwindow", (event) => {
-      this.dispatchEvent(new CustomEvent("remoteappwindow", { detail: event.detail }));
-    });
-    this.client.addEventListener("remoteappclosed", (event) => {
-      this.dispatchEvent(new CustomEvent("remoteappclosed", { detail: event.detail }));
-    });
-    this.client.addEventListener("error", (event) => {
-      this.lastErrorMessage = event.detail.message;
-    });
-    this.client.addEventListener("close", (event) => {
-      this._rfbConnectionState = "disconnected";
-      this.remoteAppLayoutObserver?.disconnect();
-      this.display.destroy();
-      this.dispatchEvent(new CustomEvent("disconnect", {
-        detail: {
-          clean: Boolean(event.detail.clean),
-          message: this.lastErrorMessage || event.detail.message || "",
-          code: event.detail.code,
-          phase: event.detail.phase
-        }
-      }));
-    });
-  }
-  /**
-   * Ask the host to size the remote application's window to the room this
-   * session has on the page. Full-desktop sessions have nothing to do here:
-   * their size is fixed when the connection is negotiated.
-   */
-  fitToViewport() {
-    if (!this.options.remoteApp?.program) return false;
-    const bounds = this.display.container.getBoundingClientRect();
-    const width = Math.floor(bounds.width || this.options.width || 0);
-    const height = Math.floor(bounds.height || this.options.height || 0);
-    if (width <= 0 || height <= 0) return false;
-    return this.client.fitRemoteApp(width, height);
-  }
-  get connected() {
-    return this._rfbConnectionState === "connected";
-  }
-  get canvas() {
-    return this.display?.canvas ?? null;
-  }
-  /** The workspace instruments this socket for byte counters and keepalives. */
-  get socket() {
-    return this.client.socket ?? null;
-  }
-  get _sock() {
-    return { _websocket: this.client.socket };
-  }
-  get scaleViewport() {
-    return this._scaleViewport;
-  }
-  set scaleViewport(enabled) {
-    this._scaleViewport = Boolean(enabled);
-    this.display.setScaleViewport(this._scaleViewport);
-  }
-  get viewOnly() {
-    return this.display.viewOnly;
-  }
-  set viewOnly(enabled) {
-    this.display.viewOnly = Boolean(enabled);
-    if (enabled) this.display.releaseAllKeys();
-  }
-  /**
-   * The on-screen keyboard and the special-keys dialog call this with an X11
-   * keysym and a DOM code. RDP wants a scancode, so the code decides; the
-   * keysym is only a fallback for characters with no key of their own.
-   */
-  sendKey(keysym, code, pressed) {
-    if (code && this.client.sendKeyByCode(code, pressed)) return;
-    if (!pressed || !keysym) return;
-    if (keysym >= 32 && keysym <= 1114111) {
-      this.client.sendUnicode(String.fromCodePoint(keysym));
-    }
-  }
-  sendCtrlAltDel() {
-    this.client.sendCtrlAltDel();
-  }
-  // --- pointer, for the AI pane's screen-control tool ----------------------
-  //
-  // The display already turns browser events into these calls; exposing them
-  // lets something other than a mouse drive the same path.
-  /** Desktop pixels. Returns false when the session cannot accept input. */
-  movePointer(x, y) {
-    if (!this.client?.connected || this.display.viewOnly) return false;
-    this.client.sendMouseMove(...this.#clampToDesktop(x, y));
-    return true;
-  }
-  clickPointer(x, y, button = 0) {
-    if (!this.client?.connected || this.display.viewOnly) return false;
-    const [px, py] = this.#clampToDesktop(x, y);
-    this.client.sendMouseMove(px, py);
-    this.pointerButton(px, py, button, true);
-    this.pointerButton(px, py, button, false);
-    return true;
-  }
-  pointerButton(x, y, button = 0, pressed = true) {
-    if (!this.client?.connected || this.display.viewOnly) return false;
-    const [px, py] = this.#clampToDesktop(x, y);
-    this.client.sendMouseButton(button, pressed, px, py);
-    return true;
-  }
-  scrollPointer(x, y, delta) {
-    if (!this.client?.connected || this.display.viewOnly) return false;
-    const [px, py] = this.#clampToDesktop(x, y);
-    for (let i = 0; i < Math.min(20, Math.abs(delta.y)); i++) {
-      this.client.sendWheel(Math.sign(delta.y), px, py, false);
-    }
-    for (let i = 0; i < Math.min(20, Math.abs(delta.x)); i++) {
-      this.client.sendWheel(Math.sign(delta.x), px, py, true);
-    }
-    return true;
-  }
-  /** Type a run of characters, which RDP carries as Unicode rather than keys. */
-  typeText(text) {
-    if (!this.client?.connected || this.display.viewOnly || !text) return false;
-    let printable = "";
-    const flushPrintable = () => {
-      if (!printable) return;
-      this.client.sendUnicode(printable);
-      printable = "";
-    };
-    for (const character of text) {
-      if (character === "\n" || character === "\r") {
-        flushPrintable();
-        this.client.sendKeyByCode("Enter", true);
-        this.client.sendKeyByCode("Enter", false);
-      } else if (character === "	") {
-        flushPrintable();
-        this.client.sendKeyByCode("Tab", true);
-        this.client.sendKeyByCode("Tab", false);
-      } else {
-        printable += character;
-      }
-    }
-    flushPrintable();
-    return true;
-  }
-  #clampToDesktop(x, y) {
-    return [
-      Math.max(0, Math.min((this.display.width || 1) - 1, Math.round(x))),
-      Math.max(0, Math.min((this.display.height || 1) - 1, Math.round(y)))
-    ];
-  }
-  /** What the canvas is showing, for a screen capture or a coordinate check. */
-  get screenGeometry() {
-    return {
-      width: this.display.width,
-      height: this.display.height,
-      viewport: { ...this.display.viewport }
-    };
-  }
-  /**
-   * Hand text to the host's clipboard, falling back to typing it when the host
-   * declined the clipboard channel -- xrdp builds often do.
-   */
-  clipboardPasteFrom(text) {
-    if (!text) return;
-    const shared = this.client.setClipboardText(text);
-    if (!shared || typeof shared.then !== "function") {
-      this.client.sendUnicode(text);
-      return;
-    }
-    shared.then((acknowledged) => {
-      if (!acknowledged) this.client.sendUnicode(text);
-    });
-  }
-  /**
-   * Deliver text into the session, which is what the clipboard drawer's button
-   * has always visibly done. `clipboardPasteFrom` only loads the clipboard, the
-   * way noVNC's method of that name does.
-   */
-  pasteText(text) {
-    return text ? this.client.pasteToHost(text) : false;
-  }
-  releaseKeyboard() {
-    this.display.releaseAllKeys();
-    this.display.blur();
-  }
-  /** True once the host has agreed to share its clipboard. */
-  get clipboardShared() {
-    return this.client.clipboardShared;
-  }
-  disconnect() {
-    this.remoteAppLayoutObserver?.disconnect();
-    this.client.disconnect();
-    this.display.destroy();
-    this._rfbConnectionState = "disconnected";
-  }
-}
-const rdpDriver = {
-  protocol: "rdp",
-  label: "RDP Client",
-  defaultPort: DEFAULT_PORTS.rdp,
-  dialog: DIALOG,
-  buildUrl,
-  createSession: (container, url, options) => new RdpSession(container, url, options),
-  // The RDP client logs its own progress, so there is nothing to add here.
-  describeState: () => ({}),
-  describeDisconnect
-};
-export {
-  RdpSession,
-  rdpDriver
-};

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

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