ai-remote 0.4.0 → 0.4.2

package/src/cli/shell.ts

@@ -1,184 +0,0 @@
-/**
- * An SSH shell on the same machine the desktop is showing.
- *
- * RDP has no shell channel, so a terminal beside the desktop is a second
- * connection to the same host. The engine is the browser's, unchanged: the key
- * exchange, the session keys and the password exist only in this process.
- */
-
-import { SshSession } from '../protocols/ssh/session';
-import { TcpTransport } from './transport';
-
-/**
- * The account name on its own.
- *
- * An RDP username may carry the machine or domain with it -- `DESKTOP-01\\owner`
- * or `owner@corp` -- and SSH wants neither. The terminal defaults to the same
- * account as the desktop, so this is what makes that default work rather than
- * fail on a name that was perfectly good for RDP.
- */
-export function bareUsername(username: string): string {
-  const withoutDomain = username.includes('\\') ? username.split('\\').pop()! : username;
-  return withoutDomain.split('@')[0].trim();
-}
-
-export interface ShellOptions {
-  host: string;
-  port: number;
-  username: string;
-  password: string;
-  columns?: number;
-  rows?: number;
-}
-
-export interface CommandResult {
-  output: string;
-  exitStatus: number | null;
-  timedOut: boolean;
-  durationMs: number | null;
-}
-
-export class Shell {
-  readonly options: ShellOptions;
-  session: any;
-  ready = false;
-  lastError = '';
-
-  #sinks = new Set<(bytes: Uint8Array) => void>();
-  /** What the shell has printed, so a viewer attaching late sees the scrollback. */
-  #scrollback: Uint8Array[] = [];
-  #scrollbackBytes = 0;
-
-  constructor(options: ShellOptions) {
-    this.options = options;
-
-    this.session = new SshSession(`tcp://${options.host}:${options.port}`, {
-      username: options.username,
-      password: options.password,
-      columns: options.columns ?? 120,
-      rows: options.rows ?? 30,
-      // Every host this reaches was named by the person running the command,
-      // on their own network. There is no stored known_hosts to compare with
-      // yet, so nothing useful can be decided here.
-      verifyHost: async () => true,
-      openTransport: () => new TcpTransport(options.host, options.port),
-    });
-
-    this.session.addEventListener('data', (event: any) => {
-      // `display` is what the terminal should show: the same stream with the
-      // framing `runCommand` wraps around a command filtered back out. `bytes`
-      // is the unfiltered original, which would leak those markers on screen.
-      const bytes: Uint8Array = event.detail.display ?? event.detail.bytes;
-      if (!bytes?.length) return;
-      this.#remember(bytes);
-      for (const sink of this.#sinks) sink(bytes);
-    });
-
-    this.session.addEventListener('ready', () => { this.ready = true; });
-    this.session.addEventListener('error', (event: any) => {
-      this.lastError = event.detail?.message || '';
-    });
-    this.session.addEventListener('close', () => { this.ready = false; });
-  }
-
-  /** Everything printed so far, capped so a long-running shell cannot grow forever. */
-  get scrollback(): Uint8Array {
-    const total = this.#scrollback.reduce((sum, chunk) => sum + chunk.length, 0);
-    const out = new Uint8Array(total);
-    let offset = 0;
-    for (const chunk of this.#scrollback) { out.set(chunk, offset); offset += chunk.length; }
-    return out;
-  }
-
-  onData(sink: (bytes: Uint8Array) => void): () => void {
-    this.#sinks.add(sink);
-    return () => this.#sinks.delete(sink);
-  }
-
-  connect(timeoutMs = 30_000): Promise<void> {
-    return new Promise((resolve, reject) => {
-      let settled = false;
-      const finish = (error?: Error) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        if (error) reject(error); else resolve();
-      };
-
-      const timer = setTimeout(
-        () => finish(new Error(`The SSH host did not open a shell within ${Math.round(timeoutMs / 1000)}s.`)),
-        timeoutMs
-      );
-
-      this.session.addEventListener('ready', () => finish());
-      this.session.addEventListener('close', (event: any) => {
-        finish(new Error(this.lastError || event.detail?.message || 'The SSH connection closed during sign-in.'));
-      });
-
-      this.session.connect();
-    });
-  }
-
-  /**
-   * Run one command and wait for its output and exit status.
-   *
-   * The first command against a Windows host usually fails: the engine frames
-   * commands POSIX-style to find where the output starts and ends, cmd.exe
-   * rejects that, and the engine notes the shell family and asks to be called
-   * again. That is a detail of how the shell was discovered, not something a
-   * caller did wrong, so the retry happens here instead of reaching them.
-   */
-  async runCommand(command: string): Promise<CommandResult> {
-    let result;
-    try {
-      result = await this.session.runCommand(command);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (!/run the command again|not a POSIX shell/i.test(message)) throw error;
-
-      // Discovering the shell family restarts it, so the retry has to wait for
-      // the prompt to come back rather than firing straight into a shell that
-      // is still opening.
-      await this.#waitForPrompt();
-      result = await this.session.runCommand(command);
-    }
-    return {
-      output: result.output ?? '',
-      exitStatus: result.exitStatus ?? null,
-      timedOut: Boolean(result.timedOut),
-      durationMs: result.durationMs ?? null,
-    };
-  }
-
-  /** Wait until the shell will accept a framed command again. */
-  async #waitForPrompt(timeoutMs = 15_000): Promise<void> {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-      if (this.session.shellOpen && this.session.readySignaled !== false) return;
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    throw new Error('The SSH shell did not come back after its family was discovered.');
-  }
-
-  /** Raw keystrokes, for an interactive terminal. */
-  write(text: string): void {
-    this.session.write(text);
-  }
-
-  resize(columns: number, rows: number): void {
-    this.session.resize?.(columns, rows);
-  }
-
-  disconnect(): void {
-    try { this.session.disconnect(); } catch { /* already gone */ }
-  }
-
-  #remember(bytes: Uint8Array): void {
-    const CAP = 256 * 1024;
-    this.#scrollback.push(bytes);
-    this.#scrollbackBytes += bytes.length;
-    while (this.#scrollbackBytes > CAP && this.#scrollback.length > 1) {
-      this.#scrollbackBytes -= this.#scrollback.shift()!.length;
-    }
-  }
-}

package/src/cli/transport.ts

@@ -1,86 +0,0 @@
-/**
- * A TCP socket wearing the shape of a WebSocket.
- *
- * The protocol engines were written against a browser WebSocket pointed at the
- * gateway's relay. What they actually use of it is small -- open, message,
- * close, error, send, readyState, close() -- so a direct TCP connection can
- * present the same face and the engines never learn which one they were given.
- *
- * The one asymmetry is the gateway's own control frames. GATEWAY_READY and
- * GATEWAY_KEEPALIVE are a conversation between the browser and the relay, and
- * they are strings precisely so they can never be mistaken for protocol bytes.
- * There is no relay here, so they are dropped: forwarding them would push
- * `VNC_GATEWAY_READY_v1` into the middle of an X.224 negotiation.
- */
-
-import net from 'node:net';
-
-export class TcpTransport extends EventTarget {
-  static readonly CONNECTING = 0;
-  static readonly OPEN = 1;
-  static readonly CLOSING = 2;
-  static readonly CLOSED = 3;
-
-  readyState = 0;
-  /** Set by the engines; this transport always delivers ArrayBuffers. */
-  binaryType = 'arraybuffer';
-
-  #socket: net.Socket;
-  #closeSent = false;
-
-  constructor(host: string, port: number) {
-    super();
-
-    this.#socket = net.connect({ host, port, noDelay: true });
-
-    this.#socket.on('connect', () => {
-      this.readyState = 1;
-      this.dispatchEvent(new Event('open'));
-    });
-
-    this.#socket.on('data', (chunk: Buffer) => {
-      // A copy, because Node reuses its read buffer and the engines hold on to
-      // what they are handed until a frame is complete.
-      const bytes = new Uint8Array(chunk.byteLength);
-      bytes.set(chunk);
-      this.dispatchEvent(new MessageEvent('message', { data: bytes.buffer }));
-    });
-
-    this.#socket.on('error', (error: Error) => {
-      this.dispatchEvent(new Event('error'));
-      this.#reportClose(1006, error.message, false);
-    });
-
-    this.#socket.on('close', () => {
-      this.#reportClose(1006, 'The host closed the TCP connection.', false);
-    });
-  }
-
-  send(data: string | Uint8Array | ArrayBuffer): void {
-    // Gateway control frames. There is no gateway.
-    if (typeof data === 'string') return;
-    if (this.readyState !== 1) return;
-    this.#socket.write(data instanceof ArrayBuffer ? new Uint8Array(data) : data);
-  }
-
-  close(code = 1000, reason = ''): void {
-    if (this.readyState >= 2) return;
-    this.readyState = 2;
-    this.#socket.destroy();
-    this.#reportClose(code, reason, code === 1000);
-  }
-
-  #reportClose(code: number, reason: string, wasClean: boolean): void {
-    if (this.#closeSent) return;
-    this.#closeSent = true;
-    this.readyState = 3;
-
-    // CloseEvent is not a Node global. The engines read exactly these three
-    // fields, so a plain Event carrying them is indistinguishable to them.
-    const event = new Event('close') as Event & { code: number; reason: string; wasClean: boolean };
-    event.code = code;
-    event.reason = reason;
-    event.wasClean = wasClean;
-    this.dispatchEvent(event);
-  }
-}

package/src/cli/viewer-client/assets.d.ts

@@ -1,4 +0,0 @@
-// The viewer bundle imports xterm's stylesheet so the page carries it instead
-// of reaching for a CDN. esbuild turns it into CSS output; TypeScript only
-// needs to know the import is legal.
-declare module '*.css';

package/src/cli/viewer-client/main.ts

@@ -1,323 +0,0 @@
-/**
- * The viewer front end: the desktop, and a terminal beside it.
- *
- * This is a real bundle rather than a hand-written script in a string, for one
- * reason: a Windows console addresses the cursor absolutely -- conhost emits
- * `ESC[9;1H` between every line of output -- so anything less than a genuine
- * terminal emulator renders its output scrambled. xterm.js is that emulator,
- * and the web front end in this repository already uses it.
- */
-
-import { Terminal } from '@xterm/xterm';
-import { FitAddon } from '@xterm/addon-fit';
-import '@xterm/xterm/css/xterm.css';
-
-type Json = Record<string, any>;
-
-const $ = <T extends HTMLElement>(id: string) => document.getElementById(id) as T;
-
-const canvas = $<HTMLCanvasElement>('screen');
-const context = canvas.getContext('2d', { alpha: false })!;
-const stateEl = $('state');
-const sizeEl = $('size');
-const hostEl = $('host');
-const scaleBtn = $('scale');
-const ctlBtn = $('control');
-const termBtn = $('term');
-const fsBtn = $('full');
-
-/**
- * The toolbar has no room for a sentence, so a button's tooltip carries what a
- * status line used to say.
- */
-function tip(id: string, text: string): void {
-  const element = $(id);
-  element.title = text;
-  element.setAttribute('aria-label', text);
-}
-const termPane = $('terminal');
-const termHost = $('termHost');
-
-let control = false;
-let painted = 0;
-
-// The window hides its own titlebar on macOS and lets the page draw the bar,
-// which means leaving room for the traffic lights that float over it.
-if (/Mac|iPhone|iPad/.test(navigator.platform || navigator.userAgent)) {
-  document.body.classList.add('macos');
-}
-
-const socket = new WebSocket(location.href.replace(/^http/, 'ws'));
-socket.binaryType = 'arraybuffer';
-
-const send = (message: Json) => {
-  if (socket.readyState === WebSocket.OPEN) socket.send(JSON.stringify(message));
-};
-
-// --- terminal ---------------------------------------------------------------
-
-const terminal = new Terminal({
-  convertEol: false,
-  cursorBlink: true,
-  fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Consolas, monospace',
-  fontSize: 12,
-  scrollback: 5000,
-  theme: {
-    background: '#0d0f13',
-    foreground: '#d6dae3',
-    cursor: '#7ee2a8',
-    selectionBackground: '#2f4a7a',
-  },
-});
-const fitAddon = new FitAddon();
-terminal.loadAddon(fitAddon);
-
-let terminalOpened = false;
-let terminalAttached = false;
-
-function openTerminal(open: boolean): void {
-  termPane.classList.toggle('open', open);
-  termBtn.setAttribute('aria-pressed', String(open));
-  if (!open) return;
-
-  if (!terminalOpened) {
-    terminalOpened = true;
-    terminal.open(termHost);
-    // Keystrokes go straight to the shell, so the terminal behaves like a
-    // terminal: Ctrl-C interrupts, arrows reach the shell's own history.
-    terminal.onData((data) => {
-      if (!control) {
-        terminal.write('\r\n\x1b[33m[take control first — the terminal types on the remote machine]\x1b[m\r\n');
-        return;
-      }
-      send({ type: 'shell-input', text: data });
-    });
-  }
-
-  // Two frames, because the pane has only just been given a size and the
-  // first frame measures the layout it had before that. Fitting too early
-  // computes one column, and a shell told it has one column wraps every line
-  // of its output into a vertical ribbon.
-  requestAnimationFrame(() => requestAnimationFrame(() => {
-    fitAddon.fit();
-    reportSize();
-    if (!terminalAttached) {
-      terminalAttached = true;
-      send({ type: 'shell-attach' });
-    }
-    terminal.focus();
-  }));
-}
-
-/**
- * Tell the shell how wide its terminal is -- but never a size that cannot be
- * real. A bad measurement is worse than a stale one: the shell reflows its
- * output to whatever it is told.
- */
-function reportSize(): void {
-  if (terminal.cols < 20 || terminal.rows < 5) return;
-  send({ type: 'shell-resize', columns: terminal.cols, rows: terminal.rows });
-}
-
-new ResizeObserver(() => {
-  if (!terminalOpened || !termPane.classList.contains('open')) return;
-  fitAddon.fit();
-  reportSize();
-}).observe(termPane);
-
-termBtn.addEventListener('click', () => openTerminal(termBtn.getAttribute('aria-pressed') !== 'true'));
-
-// --- the desktop ------------------------------------------------------------
-
-socket.addEventListener('open', () => {
-  stateEl.className = 'dot live';
-  stateEl.title = 'connected';
-});
-
-socket.addEventListener('close', () => {
-  stateEl.className = 'dot dead';
-  stateEl.title = 'the session ended';
-  terminal.write('\r\n\x1b[31m[the session ended]\x1b[m\r\n');
-});
-
-socket.addEventListener('message', async (event) => {
-  if (typeof event.data !== 'string') {
-    await paint(new Uint8Array(event.data as ArrayBuffer));
-    return;
-  }
-
-  const message: Json = JSON.parse(event.data);
-  switch (message.type) {
-    case 'hello':
-    case 'resize':
-      resize(message);
-      if (message.host) hostEl.textContent = message.host;
-      break;
-    case 'control':
-      setControl(Boolean(message.on));
-      break;
-    case 'shell-data':
-      terminal.write(Uint8Array.from(atob(message.base64), (c) => c.charCodeAt(0)));
-      break;
-    case 'shell-status':
-      if (message.state === 'opening') terminal.write('\x1b[90m[opening a shell…]\x1b[m\r\n');
-      break;
-    case 'shell-error':
-      terminal.write(`\r\n\x1b[31m[${message.message}]\x1b[m\r\n`);
-      break;
-    default:
-      break;
-  }
-});
-
-function resize({ width, height }: Json): void {
-  if (!width || !height) return;
-  canvas.width = width;
-  canvas.height = height;
-  sizeEl.textContent = `${width}×${height}`;
-  document.title = `${hostEl.textContent} — ${width}×${height}`;
-}
-
-/** Inflate with the platform's own decompressor; no library involved. */
-async function inflate(bytes: Uint8Array): Promise<Uint8Array> {
-  const stream = new Blob([bytes as BlobPart]).stream()
-    .pipeThrough(new DecompressionStream('deflate'));
-  return new Uint8Array(await new Response(stream).arrayBuffer());
-}
-
-async function paint(frame: Uint8Array): Promise<void> {
-  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
-  const left = view.getUint16(1, true);
-  const top = view.getUint16(3, true);
-  const width = view.getUint16(5, true);
-  const height = view.getUint16(7, true);
-
-  const rgba = await inflate(frame.subarray(9));
-  if (rgba.length < width * height * 4) return;
-
-  // The buffer came from a DecompressionStream, so it is a plain ArrayBuffer;
-  // the cast is only needed because a Uint8Array may in general be backed by a
-  // SharedArrayBuffer, which ImageData does not accept.
-  const pixels = new Uint8ClampedArray(rgba.buffer as ArrayBuffer, 0, width * height * 4);
-  context.putImageData(new ImageData(pixels, width, height), left, top);
-
-  if (++painted === 1) canvas.focus();
-}
-
-// --- input ------------------------------------------------------------------
-//
-// Positions are in desktop pixels. The canvas may be scaled to fit, so every
-// pointer event is mapped back through the element's real size.
-
-function at(event: MouseEvent): { x: number; y: number } {
-  const box = canvas.getBoundingClientRect();
-  return {
-    x: Math.round((event.clientX - box.left) * (canvas.width / box.width)),
-    y: Math.round((event.clientY - box.top) * (canvas.height / box.height)),
-  };
-}
-
-const desktop = (message: Json) => { if (control) send(message); };
-
-canvas.addEventListener('mousemove', (e) => desktop({ type: 'move', ...at(e) }));
-canvas.addEventListener('mousedown', (e) => {
-  e.preventDefault();
-  canvas.focus();
-  desktop({ type: 'button', ...at(e), button: e.button, pressed: true });
-});
-canvas.addEventListener('mouseup', (e) => {
-  e.preventDefault();
-  desktop({ type: 'button', ...at(e), button: e.button, pressed: false });
-});
-canvas.addEventListener('contextmenu', (e) => e.preventDefault());
-canvas.addEventListener('wheel', (e) => {
-  e.preventDefault();
-  desktop({ type: 'scroll', ...at(e), dx: Math.sign(e.deltaX), dy: Math.sign(e.deltaY) });
-}, { passive: false });
-
-canvas.addEventListener('keydown', (e) => {
-  if (!control) return;
-  e.preventDefault();
-  desktop({ type: 'key', code: e.code, pressed: true });
-});
-canvas.addEventListener('keyup', (e) => {
-  if (!control) return;
-  e.preventDefault();
-  desktop({ type: 'key', code: e.code, pressed: false });
-});
-
-// --- fullscreen -------------------------------------------------------------
-//
-// What a remote-desktop client does with the key: the desktop takes the whole
-// display, the page chrome gets out of the way, and keystrokes go to the host
-// rather than to the browser. Fit is forced on while it lasts, because a 1:1
-// desktop larger than the screen would otherwise be a fullscreen scrollbar.
-
-let fitBeforeFullscreen = false;
-
-async function toggleFullscreen(): Promise<void> {
-  if (document.fullscreenElement) {
-    await document.exitFullscreen().catch(() => {});
-    return;
-  }
-  fitBeforeFullscreen = scaleBtn.getAttribute('aria-pressed') === 'true';
-  await document.documentElement.requestFullscreen({ navigationUI: 'hide' }).catch(() => {});
-}
-
-document.addEventListener('fullscreenchange', () => {
-  const on = Boolean(document.fullscreenElement);
-  document.body.classList.toggle('fullscreen', on);
-  fsBtn.setAttribute('aria-pressed', String(on));
-  setFit(on ? true : fitBeforeFullscreen);
-  if (!termPane.classList.contains('open')) canvas.focus();
-});
-
-fsBtn.addEventListener('click', () => void toggleFullscreen());
-
-/**
- * F11 belongs to the host once it has the keyboard, so fullscreen is on a
- * chord the remote desktop has no use for. Escape leaves, which is what every
- * fullscreen surface does anyway.
- */
-window.addEventListener('keydown', (event) => {
-  if (event.key === 'F11' && !control) { event.preventDefault(); void toggleFullscreen(); }
-  if (event.shiftKey && event.ctrlKey && event.code === 'KeyF') {
-    event.preventDefault();
-    void toggleFullscreen();
-  }
-}, true);
-
-// --- controls ---------------------------------------------------------------
-
-function setFit(on: boolean): void {
-  scaleBtn.setAttribute('aria-pressed', String(on));
-  canvas.classList.toggle('fit', on);
-  tip('scale', on ? 'Showing scaled to fit — click for 100%' : 'Showing at 100% — click to scale to fit');
-}
-
-scaleBtn.addEventListener('click', () => setFit(scaleBtn.getAttribute('aria-pressed') !== 'true'));
-
-// Ask; the server decides. The button reflects what came back, so it can never
-// claim control the session has not actually granted.
-ctlBtn.addEventListener('click', () => send({ type: 'control', on: !control }));
-
-function setControl(on: boolean): void {
-  control = on;
-  ctlBtn.setAttribute('aria-pressed', String(on));
-
-  tip('control', on
-    ? 'You have control — click to go back to watching'
-    : 'Watching. Click to send keyboard and pointer to the remote machine');
-  if (on && !termPane.classList.contains('open')) canvas.focus();
-}
-
-$('cad').addEventListener('click', () => {
-  if (!control) {
-    tip('cad', 'Take control first — Ctrl+Alt+Del is input like any other');
-    return;
-  }
-  send({ type: 'cad' });
-});
-
-// The desktop starts at 100%, and the window is sized to hold it.
-setFit(false);