ai-remote 0.4.0 → 0.4.2

package/src/cli/wsserver.ts

@@ -1,144 +0,0 @@
-/**
- * Just enough WebSocket to talk to a browser tab.
- *
- * Node has no WebSocket server, and pulling one in would cost `npx remotectl`
- * its single-download start. What the viewer needs is small: an upgrade
- * handshake, binary frames out, text frames in.
- */
-
-import { createHash } from 'node:crypto';
-import type { IncomingMessage } from 'node:http';
-import type net from 'node:net';
-
-const GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
-
-export class WebSocketPeer extends EventTarget {
-  #socket: net.Socket;
-  #buffer = Buffer.alloc(0);
-  /** Stop writing. Set as soon as closing begins, from either end. */
-  #closed = false;
-  /**
-   * Whether the close event has gone out.
-   *
-   * Kept apart from #closed on purpose: one flag doing both jobs meant a peer
-   * that closed itself -- which is what a browser tab does when it goes away --
-   * swallowed its own close event, and the session went on sending frames to a
-   * viewer that had left.
-   */
-  #reported = false;
-
-  constructor(socket: net.Socket) {
-    super();
-    this.#socket = socket;
-    socket.on('data', (chunk: Buffer) => this.#onData(chunk));
-    socket.on('close', () => this.#onClose());
-    socket.on('error', () => this.#onClose());
-  }
-
-  get closed(): boolean { return this.#closed; }
-
-  send(data: string | Uint8Array): void {
-    if (this.#closed) return;
-    const isText = typeof data === 'string';
-    const payload = isText ? Buffer.from(data, 'utf8') : Buffer.from(data);
-    this.#socket.write(frame(isText ? 0x1 : 0x2, payload));
-  }
-
-  close(): void {
-    if (!this.#closed) {
-      this.#closed = true;
-      try { this.#socket.end(frame(0x8, Buffer.alloc(0))); } catch { /* already gone */ }
-    }
-    this.#onClose();
-  }
-
-  #onClose(): void {
-    this.#closed = true;
-    if (this.#reported) return;
-    this.#reported = true;
-    this.dispatchEvent(new Event('close'));
-  }
-
-  #onData(chunk: Buffer): void {
-    if (process.env.REMOTECTL_DEBUG) console.log('[ws] data', chunk.length, 'bytes');
-    this.#buffer = Buffer.concat([this.#buffer, chunk]);
-
-    for (;;) {
-      const parsed = readFrame(this.#buffer);
-      if (!parsed) return;
-      this.#buffer = parsed.rest;
-
-      if (parsed.opcode === 0x8) { this.close(); return; }
-      if (parsed.opcode === 0x9) { this.#socket.write(frame(0xa, parsed.payload)); continue; }
-      if (parsed.opcode === 0x1) {
-        this.dispatchEvent(new MessageEvent('message', { data: parsed.payload.toString('utf8') }));
-      }
-    }
-  }
-}
-
-/** Server frames are never masked, and the viewer sends nothing large. */
-function frame(opcode: number, payload: Buffer): Buffer {
-  const length = payload.length;
-  let header: Buffer;
-
-  if (length < 126) {
-    header = Buffer.from([0x80 | opcode, length]);
-  } else if (length < 65536) {
-    header = Buffer.alloc(4);
-    header[0] = 0x80 | opcode;
-    header[1] = 126;
-    header.writeUInt16BE(length, 2);
-  } else {
-    header = Buffer.alloc(10);
-    header[0] = 0x80 | opcode;
-    header[1] = 127;
-    header.writeBigUInt64BE(BigInt(length), 2);
-  }
-
-  return Buffer.concat([header, payload]);
-}
-
-function readFrame(buffer: Buffer) {
-  if (buffer.length < 2) return null;
-
-  const opcode = buffer[0] & 0x0f;
-  const masked = (buffer[1] & 0x80) !== 0;
-  let length = buffer[1] & 0x7f;
-  let offset = 2;
-
-  if (length === 126) {
-    if (buffer.length < 4) return null;
-    length = buffer.readUInt16BE(2);
-    offset = 4;
-  } else if (length === 127) {
-    if (buffer.length < 10) return null;
-    length = Number(buffer.readBigUInt64BE(2));
-    offset = 10;
-  }
-
-  const maskKey = masked ? buffer.subarray(offset, offset + 4) : null;
-  if (masked) offset += 4;
-  if (buffer.length < offset + length) return null;
-
-  const payload = Buffer.from(buffer.subarray(offset, offset + length));
-  if (maskKey) for (let i = 0; i < payload.length; i++) payload[i] ^= maskKey[i % 4];
-
-  return { opcode, payload, rest: buffer.subarray(offset + length) };
-}
-
-/** Complete the HTTP upgrade a browser sends, and hand back the peer. */
-export function accept(request: IncomingMessage, socket: net.Socket): WebSocketPeer | null {
-  const key = request.headers['sec-websocket-key'];
-  if (typeof key !== 'string') { socket.destroy(); return null; }
-
-  const acceptKey = createHash('sha1').update(key + GUID).digest('base64');
-  socket.write(
-    'HTTP/1.1 101 Switching Protocols\r\n'
-    + 'Upgrade: websocket\r\n'
-    + 'Connection: Upgrade\r\n'
-    + `Sec-WebSocket-Accept: ${acceptKey}\r\n\r\n`
-  );
-  socket.setNoDelay(true);
-  return new WebSocketPeer(socket);
-}

package/src/protocols/index.ts

@@ -1,72 +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 { rdpDriver } from './rdp/session';
-import { vncDriver } from './vnc/session';
-import type { DisconnectContext, ProtocolDriver } from './types';
-import type { RemoteProtocol } from '../shared/protocol';
-
-export type { ProtocolDriver, RemoteSession, SessionOptions, ScreenGeometry } from './types';
-
-export const DRIVERS: Record<RemoteProtocol, ProtocolDriver> = {
-  vnc: vncDriver,
-  rdp: rdpDriver,
-};
-
-/** Unknown names fall back to VNC, which is what the dialog opens on. */
-export function driverFor(protocol: string | undefined): ProtocolDriver {
-  return DRIVERS[protocol as RemoteProtocol] ?? DRIVERS.vnc;
-}
-
-/** 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 function explainDisconnect(
-  diagnostic: DisconnectDiagnostic,
-  clean: boolean,
-  protocolMessage: string
-): string {
-  // A client that reports its own failure states it in the protocol's terms,
-  // which is always more specific than anything the transport can say.
-  if (protocolMessage) return protocolMessage;
-
-  const code = diagnostic.close?.code;
-  const reason = diagnostic.close?.reason.trim() ?? '';
-  const suffix = code ? ` (WebSocket ${code}${reason ? `: ${reason}` : ''})` : '';
-  const context: DisconnectContext = { ...(code === undefined ? {} : { code }), reason, suffix };
-
-  const driver = driverFor(diagnostic.protocol);
-  const specific = driver.describeDisconnect(context);
-  if (specific) return specific;
-
-  const name = driver.protocol.toUpperCase();
-  if (/tcp (reached )?eof/i.test(reason)) {
-    return `The ${name} host accepted the connection and then closed it${suffix}. `
-      + 'Check its remote-access permissions and the account name.';
-  }
-  if (code === 1006) {
-    return 'The connection was interrupted before a close reason arrived (WebSocket 1006). '
-      + 'This can happen during a deployment or a brief network change. Automatic reconnect '
-      + 'did not restore the session; reconnect once, then check Worker live logs if it repeats.';
-  }
-  if (reason) return `The remote session ended${suffix}.`;
-  if (clean) return `The remote server closed the session cleanly${suffix || ' (no reason supplied)'}.`;
-  return `The ${name} negotiation failed${suffix || ' before the server supplied a close reason'}.`;
-}

package/src/protocols/rdp/buffer.ts

@@ -1,204 +0,0 @@
-// Binary reader/writer used by every RDP layer. RDP mixes endianness freely --
-// TPKT and MCS are big endian, everything above them is little endian -- so the
-// byte order is part of each call rather than a mode on the object.
-
-/**
- * Plain `Uint8Array` throughout. Pinning the buffer type parameter would be
- * more precise, but every layer above this one passes byte slices around and
- * the variance between `ArrayBuffer` and `ArrayBufferLike` then has to be
- * restated at each boundary for no benefit the protocol code can use.
- */
-function allocate(length: number): Uint8Array {
-  return new Uint8Array(length);
-}
-
-export class Writer {
-  private bytes: Uint8Array;
-  private view: DataView;
-  private offset = 0;
-
-  constructor(capacity = 512) {
-    this.bytes = allocate(capacity);
-    this.view = new DataView(this.bytes.buffer);
-  }
-
-  #ensure(extra: number): void {
-    if (this.offset + extra <= this.bytes.length) return;
-    let capacity = this.bytes.length * 2;
-    while (capacity < this.offset + extra) capacity *= 2;
-    const grown = allocate(capacity);
-    grown.set(this.bytes.subarray(0, this.offset));
-    this.bytes = grown;
-    this.view = new DataView(grown.buffer);
-  }
-
-  u8(value: number): this {
-    this.#ensure(1);
-    this.view.setUint8(this.offset, value);
-    this.offset += 1;
-    return this;
-  }
-
-  u16le(value: number): this {
-    this.#ensure(2);
-    this.view.setUint16(this.offset, value, true);
-    this.offset += 2;
-    return this;
-  }
-
-  u16be(value: number): this {
-    this.#ensure(2);
-    this.view.setUint16(this.offset, value, false);
-    this.offset += 2;
-    return this;
-  }
-
-  u32le(value: number): this {
-    this.#ensure(4);
-    this.view.setUint32(this.offset, value >>> 0, true);
-    this.offset += 4;
-    return this;
-  }
-
-  u32be(value: number): this {
-    this.#ensure(4);
-    this.view.setUint32(this.offset, value >>> 0, false);
-    this.offset += 4;
-    return this;
-  }
-
-  raw(bytes: Uint8Array): this {
-    this.#ensure(bytes.length);
-    this.bytes.set(bytes, this.offset);
-    this.offset += bytes.length;
-    return this;
-  }
-
-  zeros(count: number): this {
-    this.#ensure(count);
-    this.offset += count;
-    return this;
-  }
-
-  /** UTF-16LE, optionally padded or truncated to a fixed byte width. */
-  utf16le(text: string, fixedBytes?: number): this {
-    const start = this.offset;
-    for (const unit of text) {
-      const code = unit.codePointAt(0) ?? 0;
-      // Fixed-width fields must keep room for the terminating NUL.
-      if (fixedBytes !== undefined && this.offset - start >= fixedBytes - 2) break;
-      if (code > 0xffff) {
-        // Surrogate pair: both halves are already what UTF-16 needs.
-        for (let i = 0; i < unit.length; i++) this.u16le(unit.charCodeAt(i));
-      } else {
-        this.u16le(code);
-      }
-    }
-    if (fixedBytes !== undefined) {
-      this.zeros(fixedBytes - (this.offset - start));
-    }
-    return this;
-  }
-
-  /** Overwrite an earlier 16-bit slot, for length fields known only later. */
-  patchU16le(position: number, value: number): this {
-    this.view.setUint16(position, value, true);
-    return this;
-  }
-
-  patchU16be(position: number, value: number): this {
-    this.view.setUint16(position, value, false);
-    return this;
-  }
-
-  get length(): number {
-    return this.offset;
-  }
-
-  take(): Uint8Array {
-    return this.bytes.slice(0, this.offset);
-  }
-}
-
-export class Reader {
-  private readonly bytes: Uint8Array;
-  private readonly view: DataView;
-  offset: number;
-
-  constructor(bytes: Uint8Array, offset = 0) {
-    this.bytes = bytes;
-    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    this.offset = offset;
-  }
-
-  get remaining(): number {
-    return this.bytes.length - this.offset;
-  }
-
-  #need(count: number): void {
-    if (this.remaining < count) {
-      throw new Error(`RDP: truncated frame (needed ${count} bytes, ${this.remaining} left)`);
-    }
-  }
-
-  u8(): number {
-    this.#need(1);
-    return this.view.getUint8(this.offset++);
-  }
-
-  u16le(): number {
-    this.#need(2);
-    const value = this.view.getUint16(this.offset, true);
-    this.offset += 2;
-    return value;
-  }
-
-  u16be(): number {
-    this.#need(2);
-    const value = this.view.getUint16(this.offset, false);
-    this.offset += 2;
-    return value;
-  }
-
-  u32le(): number {
-    this.#need(4);
-    const value = this.view.getUint32(this.offset, true);
-    this.offset += 4;
-    return value;
-  }
-
-  u32be(): number {
-    this.#need(4);
-    const value = this.view.getUint32(this.offset, false);
-    this.offset += 4;
-    return value;
-  }
-
-  raw(count: number): Uint8Array {
-    this.#need(count);
-    const slice = this.bytes.subarray(this.offset, this.offset + count);
-    this.offset += count;
-    return slice;
-  }
-
-  skip(count: number): this {
-    this.#need(count);
-    this.offset += count;
-    return this;
-  }
-
-  rest(): Uint8Array {
-    return this.bytes.subarray(this.offset);
-  }
-}
-
-export function concatBytes(...parts: readonly Uint8Array[]): Uint8Array {
-  const total = parts.reduce((sum, part) => sum + part.length, 0);
-  const out = allocate(total);
-  let offset = 0;
-  for (const part of parts) {
-    out.set(part, offset);
-    offset += part.length;
-  }
-  return out;
-}