ai-remote 0.3.1 → 0.4.1

package/src/cli/viewer.ts

@@ -1,272 +0,0 @@
-/**
- * The window a human watches the session through.
- *
- * The session already exists and already holds the pixels; this is an
- * attachment to it. Viewers may come and go, and there may be none at all --
- * a viewer that could end a session would make supervision a dependency
- * rather than a feature.
- *
- * A viewer that has just attached needs the whole desktop, not a delta, which
- * is exactly what the framebuffer is for: it sends one keyframe on connect and
- * painted rectangles after that.
- */
-
-import { createServer } from 'node:http';
-import type net from 'node:net';
-import { randomBytes } from 'node:crypto';
-import { spawn } from 'node:child_process';
-import { deflateSync } from 'node:zlib';
-import type { RdpSession } from './session';
-import type { Shell } from './shell';
-import { accept, type WebSocketPeer } from './wsserver';
-import { PAGE } from './viewer-page';
-
-export interface Viewer {
-  url: string;
-  /** Resolves when a browser has actually attached. */
-  opened: Promise<void>;
-  /** Pop the window again, for a viewer that was closed by hand. */
-  launch(): void;
-  close(): void;
-}
-
-/**
- * Frame layout, little-endian:
- *   u8  kind   1 = keyframe, 2 = rectangle
- *   u16 left, u16 top, u16 width, u16 height
- *   deflated RGBA
- */
-function encodeRect(kind: number, left: number, top: number, width: number, height: number, rgba: Uint8Array): Buffer {
-  const header = Buffer.alloc(9);
-  header.writeUInt8(kind, 0);
-  header.writeUInt16LE(left, 1);
-  header.writeUInt16LE(top, 3);
-  header.writeUInt16LE(width, 5);
-  header.writeUInt16LE(height, 7);
-  return Buffer.concat([header, deflateSync(rgba, { level: 1 })]);
-}
-
-export async function startViewer(
-  session: RdpSession,
-  port: number,
-  { launch = true, openShell }: { launch?: boolean; openShell?: () => Promise<Shell> } = {}
-): Promise<Viewer> {
-  const token = randomBytes(16).toString('hex');
-  const peers = new Set<WebSocketPeer>();
-
-  /**
-   * Which viewers may send input.
-   *
-   * The gate lives here rather than in the page, because a gate in the page is
-   * not a gate: anything that can open a socket can skip it. A viewer attaches
-   * as an observer and has to ask for control, which is also the right default
-   * when the session was opened by an agent -- the human watches first.
-   */
-  const drivers = new WeakSet<WebSocketPeer>();
-
-  /** Undoes each viewer's subscription to shell output when it goes away. */
-  const detachShell = new Map<WebSocketPeer, () => void>();
-
-  /**
-   * Attach a viewer to the terminal, opening it if this is the first ask.
-   *
-   * The scrollback goes out first, so a viewer that opens the terminal ten
-   * minutes into a session sees what has already been run rather than an empty
-   * pane that looks broken.
-   */
-  async function attachShell(peer: WebSocketPeer): Promise<void> {
-    if (!openShell) {
-      peer.send(JSON.stringify({
-        type: 'shell-error',
-        message: 'This session has no terminal available.',
-      }));
-      return;
-    }
-    if (detachShell.has(peer)) return;
-
-    peer.send(JSON.stringify({ type: 'shell-status', state: 'opening' }));
-    let shell: Shell;
-    try {
-      shell = await openShell();
-    } catch (error) {
-      peer.send(JSON.stringify({
-        type: 'shell-error',
-        message: error instanceof Error ? error.message : String(error),
-      }));
-      return;
-    }
-
-    const history = shell.scrollback;
-    if (history.length) {
-      peer.send(JSON.stringify({ type: 'shell-data', base64: Buffer.from(history).toString('base64') }));
-    }
-    peer.send(JSON.stringify({ type: 'shell-status', state: 'open' }));
-
-    detachShell.set(peer, shell.onData((bytes) => {
-      peer.send(JSON.stringify({ type: 'shell-data', base64: Buffer.from(bytes).toString('base64') }));
-    }));
-
-    shellFor.set(peer, shell);
-  }
-
-  const shellFor = new Map<WebSocketPeer, Shell>();
-
-  let resolveOpened: () => void;
-  const opened = new Promise<void>((resolve) => { resolveOpened = resolve; });
-
-  const server = createServer((request, response) => {
-    const url = new URL(request.url ?? '/', 'http://127.0.0.1');
-    if (url.pathname === '/' && url.searchParams.get('t') === token) {
-      response.writeHead(200, {
-        'Content-Type': 'text/html; charset=utf-8',
-        'Cache-Control': 'no-store',
-      });
-      response.end(PAGE);
-      return;
-    }
-    response.writeHead(404, { 'Content-Type': 'text/plain' });
-    response.end('Not found');
-  });
-
-  server.on('upgrade', (request, socket) => {
-    const url = new URL(request.url ?? '/', 'http://127.0.0.1');
-    if (url.searchParams.get('t') !== token) { socket.destroy(); return; }
-
-    // Node types an upgrade socket as Duplex; every runtime it has is a
-    // net.Socket, which is what lets the peer turn Nagle off.
-    const peer = accept(request, socket as net.Socket);
-    if (!peer) return;
-    peers.add(peer);
-    resolveOpened();
-
-    const { width, height } = session.framebuffer;
-    peer.send(JSON.stringify({ type: 'hello', width, height, host: session.options.host }));
-    if (width && height) {
-      peer.send(encodeRect(1, 0, 0, width, height, session.framebuffer.pixels));
-    }
-
-    peer.addEventListener('message', (event: Event) => {
-      const raw = (event as MessageEvent).data as string;
-      if (process.env.REMOTECTL_DEBUG) console.log('[viewer] <-', raw);
-      try {
-        const message = JSON.parse(raw);
-
-        if (message.type === 'control') {
-          if (message.on) drivers.add(peer); else drivers.delete(peer);
-          peer.send(JSON.stringify({ type: 'control', on: Boolean(message.on) }));
-          return;
-        }
-
-        if (message.type === 'shell-attach') { void attachShell(peer); return; }
-
-        if (!drivers.has(peer)) return;
-
-        if (message.type === 'shell-input') {
-          shellFor.get(peer)?.write(String(message.text ?? ''));
-          return;
-        }
-        if (message.type === 'shell-resize') {
-          shellFor.get(peer)?.resize(Number(message.columns) || 120, Number(message.rows) || 30);
-          return;
-        }
-
-        applyInput(session, message);
-      } catch (error) {
-        // A malformed frame from a viewer must never take the session down.
-        console.warn('[viewer] dropped an unreadable message', error);
-      }
-    });
-    peer.addEventListener('close', () => {
-      peers.delete(peer);
-      detachShell.get(peer)?.();
-      detachShell.delete(peer);
-    });
-  });
-
-  /**
-   * Loopback only. The viewer carries a live desktop and takes input for it.
-   *
-   * A busy port is not a reason to fail: a second session, or a stale process
-   * holding the default, would otherwise take the whole connection down. The
-   * chosen port is reported back, so nothing has to guess which one it got.
-   */
-  const bound = await new Promise<number>((resolve, reject) => {
-    const listen = (candidate: number, retry: boolean) => {
-      server.once('error', (error: NodeJS.ErrnoException) => {
-        if (retry && error.code === 'EADDRINUSE') { listen(0, false); return; }
-        reject(error);
-      });
-      server.listen(candidate, '127.0.0.1', () => {
-        const address = server.address();
-        resolve(typeof address === 'object' && address ? address.port : candidate);
-      });
-    };
-    listen(port, true);
-  });
-
-  session.onResize((width, height) => {
-    for (const peer of peers) {
-      peer.send(JSON.stringify({ type: 'resize', width, height }));
-      peer.send(encodeRect(1, 0, 0, width, height, session.framebuffer.pixels));
-    }
-  });
-
-  session.onPaint((rects) => {
-    if (!peers.size) return;
-    for (const rect of rects) {
-      const payload = encodeRect(2, rect.left, rect.top, rect.width, rect.height, rect.rgba);
-      for (const peer of peers) peer.send(payload);
-    }
-  });
-
-  const url = `http://127.0.0.1:${bound}/?t=${token}`;
-  if (launch) open(url);
-
-  return {
-    url,
-    opened,
-    launch() { open(url); },
-    close() {
-      for (const peer of peers) peer.close();
-      server.close();
-    },
-  };
-}
-
-function applyInput(session: RdpSession, message: any): void {
-  switch (message.type) {
-    case 'move':
-      session.movePointer(message.x, message.y);
-      break;
-    case 'button':
-      session.pointerButton(message.x, message.y, message.button ?? 0, Boolean(message.pressed));
-      break;
-    case 'scroll':
-      session.scroll(message.x, message.y, message.dx ?? 0, message.dy ?? 0);
-      break;
-    case 'key':
-      session.sendKeyCode(message.code, Boolean(message.pressed));
-      break;
-    case 'text':
-      session.typeText(String(message.text ?? ''));
-      break;
-    case 'cad':
-      session.sendCtrlAltDel();
-      break;
-    default:
-      break;
-  }
-}
-
-/** Pop the window. A failure here is not a failure of the session. */
-function open(url: string): void {
-  const command = process.platform === 'darwin' ? 'open'
-    : process.platform === 'win32' ? 'cmd'
-    : 'xdg-open';
-  const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
-  try {
-    spawn(command, args, { stdio: 'ignore', detached: true }).unref();
-  } catch {
-    // Headless, or no browser. The URL was printed; that is enough.
-  }
-}

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