ai-remote 0.4.0 → 0.4.2

package/src/cli/daemon.ts

@@ -1,306 +0,0 @@
-/**
- * A session that outlives the command that started it.
- *
- * An RDP handshake costs a second or two and everything after it is stateful:
- * a click, then a screenshot of what the click did, are two halves of one
- * observation. A tool that reconnects between them can never see the result of
- * its own action, so the session lives here and commands attach to it.
- *
- * The viewer attaches the same way, and so does the terminal. None of them own
- * the session; it outlives all of them and ends when it is told to.
- */
-
-import net from 'node:net';
-import { unlinkSync, writeFileSync, existsSync } from 'node:fs';
-import { RdpSession, type SessionOptions } from './session';
-import { bareUsername, Shell } from './shell';
-import { downscale, encodePng } from './png';
-import { startViewer, type Viewer } from './viewer';
-import { readMessages, writeMessage, type Request } from './ipc';
-import { ensureRunDir, metaPath, socketPath } from './paths';
-
-export interface DaemonOptions extends SessionOptions {
-  name: string;
-  view: boolean;
-  launchBrowser: boolean;
-  viewPort: number;
-  /** Account for the terminal, when one is wanted. Blank leaves SSH unopened. */
-  sshUsername: string;
-  /** Open in the default browser rather than a window of its own. */
-  tab: boolean;
-  /** Start the window already filling the display. */
-  fullscreen: boolean;
-  sshPort: number;
-  idleMs: number;
-}
-
-export async function runDaemon(options: DaemonOptions): Promise<void> {
-  ensureRunDir();
-
-  const session = new RdpSession(options);
-  const size = await session.connect();
-
-  let shell: Shell | null = null;
-  let shellStarting: Promise<Shell> | null = null;
-
-  /**
-   * The terminal is opened on first use rather than at connect time. Most
-   * sessions never ask for one, and a second sign-in that nobody wanted is a
-   * second chance to lock an account out.
-   *
-   * It signs in as the desktop's own account and password by default. Needing a
-   * separate flag to get a terminal on the machine you are already looking at
-   * is a question with an obvious answer, so it is not asked.
-   */
-  function openShell(): Promise<Shell> {
-    if (shell) return Promise.resolve(shell);
-    if (shellStarting) return shellStarting;
-
-    shellStarting = (async () => {
-      const started = new Shell({
-        host: options.host,
-        port: options.sshPort,
-        username: options.sshUsername || bareUsername(options.username),
-        password: options.password,
-      });
-      await started.connect();
-      shell = started;
-      return started;
-    })();
-
-    shellStarting.catch(() => { shellStarting = null; });
-    return shellStarting;
-  }
-
-  const startedAt = new Date().toISOString();
-
-  /**
-   * What `ai-remote list` reads. Rewritten whenever the viewer comes or goes,
-   * so the listing never advertises a window that is not there.
-   */
-  function writeMeta(): void {
-    writeFileSync(metaPath(options.name), JSON.stringify({
-      name: options.name,
-      host: options.host,
-      port: options.port,
-      pid: process.pid,
-      viewer: viewer?.url ?? null,
-      width: session.framebuffer.width || size.width,
-      height: session.framebuffer.height || size.height,
-      startedAt,
-    }, null, 2));
-  }
-
-  /**
-   * The viewer is not part of the session; it attaches to one.
-   *
-   * So it can be opened and closed while the session keeps running, and a
-   * session with no viewer is not a lesser session -- the framebuffer is the
-   * authority either way.
-   */
-  // Annotated rather than inferred: every assignment happens inside a closure,
-  // which control-flow analysis cannot follow, so it would otherwise narrow to
-  // `null` and then to `never` at the first use.
-  let viewer: Viewer | null = null as Viewer | null;
-
-  async function openViewer(launch: boolean): Promise<Viewer> {
-    if (viewer) {
-      if (launch) viewer.launch();
-      return viewer;
-    }
-    viewer = await startViewer(session, options.viewPort, {
-      launch,
-      openShell,
-      tab: options.tab,
-      fullscreen: options.fullscreen,
-    });
-    writeMeta();
-    return viewer;
-  }
-
-  function closeViewer(): boolean {
-    if (!viewer) return false;
-    viewer.close();
-    viewer = null;
-    writeMeta();
-    return true;
-  }
-
-  if (options.view) await openViewer(options.launchBrowser);
-
-  const path = socketPath(options.name);
-  if (existsSync(path)) unlinkSync(path);
-
-  let lastUsed = Date.now();
-  const touch = () => { lastUsed = Date.now(); };
-
-  const server = net.createServer((socket) => {
-    readMessages(socket, async (message: Request) => {
-      touch();
-      try {
-        const result = await handle(message);
-        writeMessage(socket, { id: message.id, ok: true, result });
-      } catch (error) {
-        writeMessage(socket, {
-          id: message.id,
-          ok: false,
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
-    });
-  });
-
-  async function handle(message: Request): Promise<unknown> {
-    const args = (message.args ?? {}) as Record<string, any>;
-
-    switch (message.op) {
-      case 'view-open': {
-        const opened = await openViewer(args.launch !== false);
-        return { viewer: opened.url, window: opened.window?.kind ?? null };
-      }
-
-      case 'view-close':
-        return { closed: closeViewer() };
-
-      case 'status':
-        return {
-          host: options.host,
-          port: options.port,
-          name: options.name,
-          width: session.framebuffer.width,
-          height: session.framebuffer.height,
-          connected: session.connected,
-          viewer: viewer?.url ?? null,
-          window: viewer?.window?.kind ?? null,
-          viewers: viewer?.viewers ?? 0,
-          shell: shell ? 'open' : shellStarting ? 'opening' : 'closed',
-          pid: process.pid,
-        };
-
-      case 'shot': {
-        await session.settle({ quietMs: 250, timeoutMs: 3000 });
-        const shot = session.framebuffer.snapshot();
-        const scaled = args.maxEdge ? downscale(shot.rgba, shot.width, shot.height, args.maxEdge) : shot;
-        const png = encodePng(scaled.rgba, scaled.width, scaled.height);
-        if (args.file) {
-          writeFileSync(args.file, png);
-          return { file: args.file, width: scaled.width, height: scaled.height };
-        }
-        return { base64: Buffer.from(png).toString('base64'), width: scaled.width, height: scaled.height };
-      }
-
-      case 'script':
-        return { steps: await runScript(session, String(args.script ?? '')) };
-
-      case 'exec': {
-        const live = await openShell();
-        const result = await live.runCommand(String(args.command ?? ''));
-        return result;
-      }
-
-      case 'shell-open':
-        await openShell();
-        return { shell: 'open' };
-
-      case 'refresh':
-        session.requestFullRepaint();
-        return {};
-
-      case 'close':
-        setTimeout(() => shutdown('asked to close'), 50);
-        return { closing: true };
-
-      default:
-        throw new Error(`Unknown operation "${message.op}".`);
-    }
-  }
-
-  await new Promise<void>((resolve) => server.listen(path, resolve));
-
-  writeMeta();
-
-  // A session whose host went away is not worth keeping a socket open for.
-  session.client.addEventListener('close', () => shutdown('the host closed the connection'));
-
-  const idleTimer = options.idleMs > 0
-    ? setInterval(() => {
-      if (Date.now() - lastUsed > options.idleMs) shutdown('idle');
-    }, 30_000)
-    : null;
-
-  let shuttingDown = false;
-  function shutdown(why: string): void {
-    if (shuttingDown) return;
-    shuttingDown = true;
-    console.log(`[session] closing: ${why}`);
-
-    if (idleTimer) clearInterval(idleTimer);
-    viewer?.close();
-    shell?.disconnect();
-    session.disconnect();
-    server.close();
-    for (const file of [path, metaPath(options.name)]) {
-      try { unlinkSync(file); } catch { /* already gone */ }
-    }
-    setTimeout(() => process.exit(0), 100);
-  }
-
-  for (const signal of ['SIGINT', 'SIGTERM'] as const) {
-    process.on(signal, () => shutdown(signal));
-  }
-
-  console.log(`[session] ${options.name} ready at ${size.width}x${size.height}`);
-  if (viewer) console.log(`[session] viewer ${viewer.url}`);
-}
-
-/**
- * Run several steps against one live session.
- *
- * Shared by the `do` command and the daemon, because they mean the same thing:
- * a sequence that keeps its own state between steps.
- */
-export async function runScript(session: RdpSession, script: string): Promise<string[]> {
-  const done: string[] = [];
-
-  for (const raw of script.split(';')) {
-    const step = raw.trim();
-    if (!step) continue;
-
-    const [verb, ...rest] = step.split(/\s+/);
-    const argument = rest.join(' ');
-    const numbers = () => argument.split(',').map(Number);
-
-    switch (verb) {
-      case 'move': { const [x, y] = numbers(); session.movePointer(x, y); break; }
-      case 'click': {
-        const [x, y] = numbers();
-        const named = argument.split(',')[2]?.trim();
-        session.click(x, y, { right: 2, middle: 1 }[named ?? ''] ?? 0);
-        break;
-      }
-      case 'dblclick': { const [x, y] = numbers(); session.click(x, y, 0); session.click(x, y, 0); break; }
-      case 'scroll': { const [x, y, dx, dy] = numbers(); session.scroll(x, y, dx || 0, dy || 0); break; }
-      case 'type': session.typeText(argument); break;
-      case 'key': {
-        const codes = argument.split('+').map((code) => code.trim()).filter(Boolean);
-        for (const code of codes) session.sendKeyCode(code, true);
-        for (const code of [...codes].reverse()) session.sendKeyCode(code, false);
-        break;
-      }
-      case 'cad': session.sendCtrlAltDel(); break;
-      case 'wait': await new Promise((resolve) => setTimeout(resolve, Number(argument) || 500)); break;
-      case 'shot': {
-        await session.settle({ quietMs: 350, timeoutMs: 4000 });
-        const shot = session.framebuffer.snapshot();
-        writeFileSync(argument || 'screen.png', encodePng(shot.rgba, shot.width, shot.height));
-        break;
-      }
-      default:
-        throw new Error(`Unknown step "${verb}" in the script.`);
-    }
-
-    done.push(step);
-  }
-
-  return done;
-}

package/src/cli/framebuffer.ts

@@ -1,115 +0,0 @@
-/**
- * The desktop as pixels, held in memory.
- *
- * In a browser the canvas is both the surface the protocol paints into and the
- * thing a person looks at. Headless, those come apart: this holds the pixels so
- * a screenshot can be taken at any moment, and the viewer -- when there is one
- * -- is a separate attachment fed the same rectangles.
- *
- * Which is what makes the viewer optional. The framebuffer is the authority,
- * so a session with nobody watching is not a degraded session.
- */
-
-import { decodeBitmapRect } from '../protocols/rdp/rle';
-
-export interface PaintedRect {
-  left: number;
-  top: number;
-  width: number;
-  height: number;
-  rgba: Uint8Array;
-}
-
-/** Palettes only exist for 8bpp updates; anything else ignores this. */
-const NO_PALETTE = new Uint32Array(256);
-
-export class Framebuffer {
-  width = 0;
-  height = 0;
-  /** RGBA, row-major, `width * height * 4` bytes. */
-  pixels = new Uint8Array(0);
-  /**
-   * Bumped on anything that changes what a viewer should be showing, including
-   * a resize.
-   */
-  generation = 0;
-  /**
-   * Rectangles painted. Kept apart from `generation` because "the desktop has
-   * been sized" and "the desktop has sent pixels" are different questions, and
-   * a screenshot taken on the strength of the first one is a black image.
-   */
-  paints = 0;
-
-  palette: Uint32Array | null = null;
-
-  resize(width: number, height: number): void {
-    if (width === this.width && height === this.height) return;
-    this.width = width;
-    this.height = height;
-    this.pixels = new Uint8Array(width * height * 4);
-    // Opaque black, so an unpainted desktop reads as a screen rather than as
-    // transparency that a PNG viewer will render as a checkerboard.
-    for (let i = 3; i < this.pixels.length; i += 4) this.pixels[i] = 255;
-    this.generation++;
-  }
-
-  /**
-   * Decode and blit one update. Returns what was painted, so a viewer can be
-   * sent the same rectangles without decoding them a second time.
-   */
-  draw(rects: readonly any[], palette: Uint32Array | null): PaintedRect[] {
-    if (palette) this.palette = palette;
-    const painted: PaintedRect[] = [];
-
-    for (const rect of rects) {
-      if (!rect.width || !rect.height) continue;
-      let rgba: Uint8Array;
-      try {
-        // decodeBitmapRect hands back a Uint8ClampedArray, which is the right
-        // thing for a canvas and the wrong thing for everything else here; the
-        // view costs nothing and shares the same bytes.
-        const decoded = decodeBitmapRect(rect, this.palette ?? NO_PALETTE);
-        rgba = new Uint8Array(decoded.buffer, decoded.byteOffset, decoded.byteLength);
-      } catch (error) {
-        // One malformed rectangle must not end a session; the next full update
-        // repaints the area anyway. Same rule the canvas renderer follows.
-        console.warn('[rdp] dropped an undecodable rectangle', {
-          geometry: `${rect.width}x${rect.height}+${rect.left}+${rect.top}`,
-          error: error instanceof Error ? error.message : String(error),
-        });
-        continue;
-      }
-
-      this.blit(rect.left, rect.top, rect.width, rect.height, rgba);
-      painted.push({ left: rect.left, top: rect.top, width: rect.width, height: rect.height, rgba });
-    }
-
-    if (painted.length) {
-      this.generation++;
-      this.paints += painted.length;
-    }
-    return painted;
-  }
-
-  /** Copy one RGBA rectangle in, clipped to the framebuffer. */
-  blit(left: number, top: number, width: number, height: number, rgba: Uint8Array): void {
-    for (let row = 0; row < height; row++) {
-      const y = top + row;
-      if (y < 0 || y >= this.height) continue;
-
-      const from = row * width * 4;
-      const columns = Math.min(width, this.width - left);
-      if (columns <= 0) continue;
-
-      this.pixels.set(
-        rgba.subarray(from, from + columns * 4),
-        (y * this.width + left) * 4
-      );
-    }
-  }
-
-  /** A copy, so a caller holding a screenshot is not looking at live memory. */
-  snapshot(): { rgba: Uint8Array; width: number; height: number } {
-    return { rgba: this.pixels.slice(), width: this.width, height: this.height };
-  }
-}