ai-remote 0.1.0 → 0.3.0

package/src/cli/daemon.ts

@@ -0,0 +1,291 @@
+/**
+ * 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 { 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;
+  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.
+   */
+  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 || 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 });
+    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 };
+      }
+
+      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,
+          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

@@ -0,0 +1,115 @@
+/**
+ * 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 };
+  }
+}