replicas-computer 0.1.0 → 0.2.0

package/dist/index.js

@@ -4,21 +4,30 @@
 import { createConnection as createConnection2 } from "net";
 
 // src/daemon.ts
-import { spawnSync as spawnSync4 } from "child_process";
-import { chmodSync, existsSync as existsSync4, mkdirSync as mkdirSync4, rmSync as rmSync4 } from "fs";
+import { spawnSync as spawnSync5 } from "child_process";
+import { chmodSync, existsSync as existsSync5, mkdirSync as mkdirSync5, rmSync as rmSync4 } from "fs";
 import { createConnection, createServer } from "net";
-import { dirname as dirname4 } from "path";
+import { dirname as dirname5 } from "path";
 
 // src/commands/desktop.ts
 import { spawnSync } from "child_process";
 import { existsSync, mkdirSync, readFileSync } from "fs";
 import { dirname, isAbsolute, resolve } from "path";
-var DESKTOP_NOVNC_PORT = 6080;
+
+// ../shared/src/engine/environment.ts
+var DESKTOP_STREAM_PORT = 6080;
+function getDesktopViewerUrl(publicUrl) {
+  const url = new URL(`${publicUrl.replace(/\/$/, "")}/`);
+  url.searchParams.set("v", "14");
+  return url.toString();
+}
 var DESKTOP_VIEWER_WIDTH = 1920;
 var DESKTOP_VIEWER_HEIGHT = 1080;
+
+// src/commands/desktop.ts
 var STATE_DIR = process.env.REPLICAS_DESKTOP_STATE_DIR || "/tmp/replicas-computer";
 var DEFAULT_DISPLAY = process.env.REPLICAS_DESKTOP_DISPLAY || ":99";
-var NOVNC_PORT = process.env.REPLICAS_DESKTOP_NOVNC_PORT ? parseInt(process.env.REPLICAS_DESKTOP_NOVNC_PORT, 10) : DESKTOP_NOVNC_PORT;
+var STREAM_PORT = process.env.REPLICAS_DESKTOP_STREAM_PORT ? parseInt(process.env.REPLICAS_DESKTOP_STREAM_PORT, 10) : DESKTOP_STREAM_PORT;
 var SERVICES_SCRIPT = process.env.REPLICAS_COMPUTER_SERVICES_SCRIPT || "/usr/local/bin/replicas-start-desktop-services";
 var INPUT_LOCK_FILE = process.env.REPLICAS_DESKTOP_INPUT_LOCK_FILE || `${STATE_DIR}/input.lock`;
 var CHROME_WRAPPER = "/usr/local/bin/replicas-chrome";
@@ -28,11 +37,11 @@ var lastDesktopHealthAt = 0;
 var CHROME_DEBUG_PORT = (() => {
   const value = process.env.REPLICAS_DESKTOP_CHROME_DEBUG_PORT;
   if (!value) return 9222;
-  const port = parseInt(value, 10);
-  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+  const port2 = parseInt(value, 10);
+  if (!Number.isInteger(port2) || port2 <= 0 || port2 > 65535) {
     fail(`REPLICAS_DESKTOP_CHROME_DEBUG_PORT must be a valid TCP port, got ${JSON.stringify(value)}`);
   }
-  return port;
+  return port2;
 })();
 function fail(msg) {
   throw new Error(msg);
@@ -48,7 +57,7 @@ function getDesktopBridgeStatus() {
 }
 function desktopStackHealthy() {
   const pids = {};
-  for (const name of ["openbox", "tint2", "x11vnc", "novnc"]) {
+  for (const name of ["openbox", "tint2", "stream"]) {
     try {
       const pid = Number.parseInt(readFileSync(`${STATE_DIR}/${name}.pid`, "utf8").trim(), 10);
       if (!Number.isFinite(pid)) return false;
@@ -59,15 +68,16 @@ function desktopStackHealthy() {
     }
   }
   if (spawnSync("xdpyinfo", [], { env: withDisplay(), stdio: "ignore" }).status !== 0) return false;
+  if (spawnSync("pactl", ["info"], { stdio: "ignore" }).status !== 0) return false;
   const wm = spawnSync("xprop", ["-root", "_NET_SUPPORTING_WM_CHECK"], { env: withDisplay(), stdio: "pipe" });
   if (wm.status !== 0 || !wm.stdout?.toString().includes("window id")) return false;
   const bridge = getDesktopBridgeStatus();
-  return !!bridge?.x11vnc.listenerPids?.includes(pids.x11vnc) && !!bridge.websockify.listenerPids?.includes(pids.novnc);
+  return !!bridge?.stream.listenerPids?.includes(pids.stream) && !!bridge.stream.health;
 }
 function ensureServicesRunning() {
   if (!existsSync(SERVICES_SCRIPT)) {
     fail(
-      `Desktop services script missing at ${SERVICES_SCRIPT}. The workspace image is out of date \u2014 Xvfb / openbox / x11vnc / websockify must be installed and \`replicas-computer setup\` must install the desktop runtime.`
+      `Desktop services script missing at ${SERVICES_SCRIPT}. The workspace image is out of date \u2014 Xvfb / openbox / PulseAudio / ffmpeg must be installed and \`replicas-computer setup\` must install the desktop runtime.`
     );
   }
   if (Date.now() - lastDesktopHealthAt < 1e3) return;
@@ -156,37 +166,293 @@ function resolvePath(p) {
 }
 function configuredDesktopDimensions() {
   const resolution = process.env.REPLICAS_DESKTOP_RESOLUTION?.match(/^(\d+)x(\d+)$/);
-  const width = parseInt(resolution?.[1] || process.env.REPLICAS_DESKTOP_WIDTH || String(DESKTOP_VIEWER_WIDTH), 10);
-  const height = parseInt(resolution?.[2] || process.env.REPLICAS_DESKTOP_HEIGHT || String(DESKTOP_VIEWER_HEIGHT), 10);
-  if (!Number.isFinite(width) || width <= 0) fail(`REPLICAS_DESKTOP_WIDTH must be a positive integer`);
-  if (!Number.isFinite(height) || height <= 0) fail(`REPLICAS_DESKTOP_HEIGHT must be a positive integer`);
-  return { width, height };
+  const width2 = parseInt(resolution?.[1] || process.env.REPLICAS_DESKTOP_WIDTH || String(DESKTOP_VIEWER_WIDTH), 10);
+  const height2 = parseInt(resolution?.[2] || process.env.REPLICAS_DESKTOP_HEIGHT || String(DESKTOP_VIEWER_HEIGHT), 10);
+  if (!Number.isFinite(width2) || width2 <= 0) fail(`REPLICAS_DESKTOP_WIDTH must be a positive integer`);
+  if (!Number.isFinite(height2) || height2 <= 0) fail(`REPLICAS_DESKTOP_HEIGHT must be a positive integer`);
+  return { width: width2, height: height2 };
 }
 function clamp(n, min, max) {
   return Math.min(max, Math.max(min, n));
 }
-var sleep = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
+var sleep = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms));
 
 // src/program.ts
 import { format } from "util";
 import { Command, CommanderError } from "commander";
 
-// src/commands/index.ts
-import { spawn as spawn2, spawnSync as spawnSync3 } from "child_process";
+// src/commands/browser.ts
+import { spawn as spawn2 } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname4 } from "path";
+
+// src/commands/capture.ts
+import { spawnSync as spawnSync2 } from "child_process";
 import { createHash } from "crypto";
-import { closeSync, copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync3, readSync, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
-import { homedir } from "os";
-import { dirname as dirname3, join } from "path";
-import chalk from "chalk";
+import { closeSync, copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync2, readSync, rmSync, writeFileSync } from "fs";
+import { dirname as dirname2 } from "path";
+var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+function readPngDimensions(filePath) {
+  const fd = openSync(filePath, "r");
+  try {
+    const buf = Buffer.alloc(24);
+    const bytesRead = readSync(fd, buf, 0, 24, 0);
+    if (bytesRead < 24 || !buf.subarray(0, 8).equals(PNG_SIGNATURE)) {
+      fail(`${filePath} is not a valid PNG (read ${bytesRead}/24 bytes)`);
+    }
+    return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
+  } finally {
+    closeSync(fd);
+  }
+}
+function brandSvgPath() {
+  const dir = process.env.REPLICAS_DESKTOP_TEMPLATES || "/usr/local/share/replicas/desktop";
+  return `${dir}/brand-wallpaper.svg`;
+}
+function loadBrandSvg(canvasW, canvasH) {
+  const path = brandSvgPath();
+  if (!existsSync2(path)) {
+    fail(
+      `Brand wallpaper SVG missing at ${path}. The workspace image is out of date \u2014 \`replicas-computer setup\` must install brand-wallpaper.svg at $REPLICAS_DESKTOP_TEMPLATES.`
+    );
+  }
+  return readFileSync2(path, "utf8").replace(/(<svg[^>]*\s)width="\d+"/, `$1width="${canvasW}"`).replace(/(<svg[^>]*\s)height="\d+"/, `$1height="${canvasH}"`);
+}
+var BRAND_PAD_FRACTION = 0.06;
+var SCREENSHOT_CORNER_FRACTION = 0.022;
+var SHADOW_SIGMA_FRACTION = 0.022;
+var SHADOW_OFFSET_Y_FRACTION = 0.013;
+var SHADOW_ALPHA = 0.6;
+var SCREENSHOT_MASK_TEMPLATE = `<svg width="__W__" height="__H__" xmlns="http://www.w3.org/2000/svg"><rect width="__W__" height="__H__" rx="__R__" ry="__R__" fill="white"/></svg>`;
+var SHADOW_MASK_TEMPLATE = `<svg width="__SW__" height="__SH__" xmlns="http://www.w3.org/2000/svg"><rect x="__M__" y="__M__" width="__W__" height="__H__" rx="__R__" ry="__R__" fill="white"/></svg>`;
+function parseGridSize(value) {
+  if (value === void 0 || value === false) return null;
+  const size = value === true ? 100 : parseCoord(value, "--grid");
+  if (size < 25 || size > 500) fail("--grid must be between 25 and 500 pixels");
+  return size;
+}
+function buildGridSvg(width2, height2, size) {
+  const lines = [];
+  const labels = [];
+  for (let x = 0; x <= width2; x += size) {
+    const strokeWidth = x % (size * 5) === 0 ? 2 : 1;
+    lines.push(`<line x1="${x}" y1="0" x2="${x}" y2="${height2}" stroke="#00e5ff" stroke-opacity="0.42" stroke-width="${strokeWidth}"/>`);
+    if (x > 0 && x < width2) labels.push(`<text x="${x + 4}" y="18">${x}</text>`);
+  }
+  for (let y = 0; y <= height2; y += size) {
+    const strokeWidth = y % (size * 5) === 0 ? 2 : 1;
+    lines.push(`<line x1="0" y1="${y}" x2="${width2}" y2="${y}" stroke="#00e5ff" stroke-opacity="0.42" stroke-width="${strokeWidth}"/>`);
+    if (y > 0 && y < height2) labels.push(`<text x="4" y="${y - 4}">${y}</text>`);
+  }
+  return `<svg width="${width2}" height="${height2}" xmlns="http://www.w3.org/2000/svg">
+<style>text{font:16px monospace;fill:white;paint-order:stroke;stroke:black;stroke-width:4px;stroke-linejoin:round}</style>
+${lines.join("\n")}
+${labels.join("\n")}
+</svg>`;
+}
+function overlayGrid(rawPath, target, width2, height2, gridSize, gridPath) {
+  writeFileSync(gridPath, buildGridSvg(width2, height2, gridSize));
+  const r = spawnSync2(
+    "ffmpeg",
+    [
+      "-y",
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-i",
+      rawPath,
+      "-i",
+      gridPath,
+      "-filter_complex",
+      "[0:v][1:v]overlay=0:0:format=auto",
+      "-frames:v",
+      "1",
+      "-update",
+      "1",
+      target
+    ],
+    { stdio: "pipe" }
+  );
+  if (r.status !== 0) {
+    fail(`ffmpeg grid overlay failed: ${r.stderr?.toString().trim() || `exit ${r.status}`}`);
+  }
+}
+async function computerScreenshotCommand(path, options = {}) {
+  const target = resolvePath(path);
+  mkdirSync2(dirname2(target), { recursive: true });
+  const stamp = `${process.pid}-${Date.now()}`;
+  const rawPath = `/tmp/replicas-screenshot-${stamp}.raw.png`;
+  const svgPath = `/tmp/replicas-screenshot-${stamp}.brand.svg`;
+  const maskPath = `/tmp/replicas-screenshot-${stamp}.mask.svg`;
+  const shadowPath = `/tmp/replicas-screenshot-${stamp}.shadow.svg`;
+  const gridPath = `/tmp/replicas-screenshot-${stamp}.grid.svg`;
+  try {
+    runDisplayCmd("scrot", ["-o", rawPath]);
+    const { width: width2, height: height2 } = readPngDimensions(rawPath);
+    const gridSize = parseGridSize(options.grid);
+    if (options.raw && gridSize === null) {
+      copyFileSync(rawPath, target);
+      console.log(`${target} (${width2}x${height2}, raw 1:1 desktop pixels)`);
+      return;
+    }
+    if (gridSize !== null) {
+      overlayGrid(rawPath, target, width2, height2, gridSize, gridPath);
+      console.log(`${target} (${width2}x${height2}, raw 1:1 desktop pixels, ${gridSize}px grid)`);
+      return;
+    }
+    const padX = Math.round(width2 * BRAND_PAD_FRACTION);
+    const padY = Math.round(height2 * BRAND_PAD_FRACTION);
+    const canvasW = width2 + padX * 2;
+    const canvasH = height2 + padY * 2;
+    const minDim = Math.min(width2, height2);
+    const cornerR = Math.round(minDim * SCREENSHOT_CORNER_FRACTION);
+    const shadowSigma = Math.max(12, Math.round(minDim * SHADOW_SIGMA_FRACTION));
+    const shadowOffsetY = Math.round(minDim * SHADOW_OFFSET_Y_FRACTION);
+    const shadowMargin = shadowSigma * 3;
+    const shadowW = width2 + shadowMargin * 2;
+    const shadowH = height2 + shadowMargin * 2;
+    writeFileSync(svgPath, loadBrandSvg(canvasW, canvasH));
+    writeFileSync(
+      maskPath,
+      SCREENSHOT_MASK_TEMPLATE.replace(/__W__/g, String(width2)).replace(/__H__/g, String(height2)).replace(/__R__/g, String(cornerR))
+    );
+    writeFileSync(
+      shadowPath,
+      SHADOW_MASK_TEMPLATE.replace(/__SW__/g, String(shadowW)).replace(/__SH__/g, String(shadowH)).replace(/__M__/g, String(shadowMargin)).replace(/__W__/g, String(width2)).replace(/__H__/g, String(height2)).replace(/__R__/g, String(cornerR))
+    );
+    const r = spawnSync2(
+      "ffmpeg",
+      [
+        "-y",
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-i",
+        svgPath,
+        "-i",
+        rawPath,
+        "-i",
+        maskPath,
+        "-i",
+        shadowPath,
+        "-filter_complex",
+        `[2:v]format=rgba,alphaextract[mask];[3:v]format=rgba,colorchannelmixer=rr=0:gg=0:bb=0:aa=${SHADOW_ALPHA},gblur=sigma=${shadowSigma}[shadow];[1:v]format=rgba[scr];[scr][mask]alphamerge[rounded];[0:v]format=rgba[bg];[bg][shadow]overlay=${padX - shadowMargin}:${padY - shadowMargin + shadowOffsetY}:format=auto[bg_shadow];[bg_shadow][rounded]overlay=${padX}:${padY}:format=auto`,
+        "-frames:v",
+        "1",
+        "-update",
+        "1",
+        target
+      ],
+      { stdio: "pipe" }
+    );
+    if (r.status !== 0) {
+      fail(`ffmpeg branding failed: ${r.stderr?.toString().trim() || `exit ${r.status}`}`);
+    }
+  } finally {
+    rmSync(rawPath, { force: true });
+    rmSync(svgPath, { force: true });
+    rmSync(maskPath, { force: true });
+    rmSync(shadowPath, { force: true });
+    rmSync(gridPath, { force: true });
+  }
+  console.log(target);
+}
+function hashFile(path) {
+  return createHash("sha256").update(readFileSync2(path)).digest("hex");
+}
+async function captureStableRawScreenshot(target, options) {
+  const start = Date.now();
+  const framePath = `${target}.frame.png`;
+  let lastHash = null;
+  let lastChangeAt = start;
+  let frames = 0;
+  let changes = 0;
+  let width2 = 0;
+  let height2 = 0;
+  try {
+    while (Date.now() - start <= options.timeoutMs) {
+      runDisplayCmd("scrot", ["-o", framePath]);
+      frames++;
+      const dimensions = readPngDimensions(framePath);
+      width2 = dimensions.width;
+      height2 = dimensions.height;
+      const hash = hashFile(framePath);
+      const now = Date.now();
+      if (lastHash === null) {
+        lastChangeAt = now;
+      } else if (hash !== lastHash) {
+        changes++;
+        lastChangeAt = now;
+      }
+      lastHash = hash;
+      copyFileSync(framePath, target);
+      if (frames > 1 && now - lastChangeAt >= options.stableMs) {
+        return { width: width2, height: height2, stable: true, elapsedMs: now - start, frames, changes };
+      }
+      await sleep(options.pollMs);
+    }
+    return { width: width2, height: height2, stable: false, elapsedMs: Date.now() - start, frames, changes };
+  } finally {
+    rmSync(framePath, { force: true });
+  }
+}
+function getActiveWindowTitle() {
+  return tryDisplayCmd("xdotool", ["getactivewindow", "getwindowname"]);
+}
+function getVisibleWindowTitles() {
+  const out = tryDisplayCmd("xdotool", ["search", "--onlyvisible", "--name", ".", "getwindowname", "%@"]);
+  return out ? out.split("\n").filter(Boolean).slice(0, 20) : [];
+}
+async function computerObserveCommand(path, options = {}) {
+  const target = resolvePath(path);
+  mkdirSync2(dirname2(target), { recursive: true });
+  const timeoutMs = options.timeout ? parseCoord(options.timeout, "--timeout") : 3e3;
+  const stableMs = options.stableMs ? parseCoord(options.stableMs, "--stable-ms") : 600;
+  const pollMs = options.pollMs ? parseCoord(options.pollMs, "--poll-ms") : 200;
+  if (timeoutMs < 0) fail("--timeout must be >= 0");
+  if (stableMs < 0) fail("--stable-ms must be >= 0");
+  if (pollMs < 50 || pollMs > 2e3) fail("--poll-ms must be between 50 and 2000");
+  const stamp = `${process.pid}-${Date.now()}`;
+  const rawPath = `/tmp/replicas-observe-${stamp}.raw.png`;
+  const gridPath = `/tmp/replicas-observe-${stamp}.grid.svg`;
+  try {
+    ensureServicesRunning();
+    const capture = await captureStableRawScreenshot(rawPath, { timeoutMs, stableMs, pollMs });
+    const gridSize = options.raw ? null : parseGridSize(options.grid ?? true);
+    if (gridSize === null) {
+      copyFileSync(rawPath, target);
+    } else {
+      overlayGrid(rawPath, target, capture.width, capture.height, gridSize, gridPath);
+    }
+    console.log(JSON.stringify({
+      screenshot: target,
+      width: capture.width,
+      height: capture.height,
+      stable: capture.stable,
+      elapsedMs: capture.elapsedMs,
+      frames: capture.frames,
+      changes: capture.changes,
+      mouse: getMouseLocation(),
+      activeWindow: getActiveWindowTitle(),
+      visibleWindows: getVisibleWindowTitles(),
+      mode: gridSize === null ? "raw" : "grid",
+      gridSize
+    }, null, 2));
+  } finally {
+    rmSync(rawPath, { force: true });
+    rmSync(gridPath, { force: true });
+  }
+}
 
 // src/commands/recording.ts
 import { spawn } from "child_process";
-import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2 } from "path";
+import { appendFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, rmSync as rmSync3, statSync, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3 } from "path";
 
 // src/commands/recording/render.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import { copyFileSync, rmSync, writeFileSync } from "fs";
+import { spawnSync as spawnSync3 } from "child_process";
+import { copyFileSync as copyFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
 
 // src/commands/recording/config.ts
 var cameraMotion = {
@@ -500,7 +766,7 @@ function buildCursorOverlayFilter(actions, duration, size, assets, projectCursor
 
 // src/commands/recording/render.ts
 function videoDuration(path) {
-  const r = spawnSync2("ffprobe", [
+  const r = spawnSync3("ffprobe", [
     "-v",
     "error",
     "-show_entries",
@@ -578,20 +844,20 @@ function projectedCursorExpression(rawCursor, axis, segments, spans, size) {
   }
   return expression;
 }
-function renderRecording(rawPath, target, actions, fps, size) {
+function renderRecording(rawPath, target, actions, fps2, size) {
   if (actions.length === 0) {
-    copyFileSync(rawPath, target);
+    copyFileSync2(rawPath, target);
     return;
   }
   const duration = videoDuration(rawPath);
   const segments = buildRecordingSegments(actions, duration, size);
   if (segments.length === 0) {
-    copyFileSync(rawPath, target);
+    copyFileSync2(rawPath, target);
     return;
   }
   const stamp = `${process.pid}-${Date.now()}`;
   const cursor = cursorAssets(stamp);
-  writeFileSync(cursor.path, cursorSvg(cursor.size));
+  writeFileSync2(cursor.path, cursorSvg(cursor.size));
   const spans = renderedSegmentSpans(segments);
   const renderedDuration = spans.length ? spans[spans.length - 1].outputEnd : duration;
   const renderedActions = actionsOnRenderedTimeline(actions, spans);
@@ -614,9 +880,9 @@ function renderRecording(rawPath, target, actions, fps, size) {
   const concatInputs = segments.map((_, index) => `[v${index}]`).join("");
   const filter = `${screenSplitFilter};${filters.join(";")};${concatInputs}concat=n=${segments.length}:v=1:a=0[screen];${cursorFilter}`;
   const filterPath = `/tmp/replicas-recording-filter-${stamp}.ffgraph`;
-  writeFileSync(filterPath, filter);
+  writeFileSync2(filterPath, filter);
   try {
-    const r = spawnSync2("ffmpeg", [
+    const r = spawnSync3("ffmpeg", [
       "-y",
       "-hide_banner",
       "-loglevel",
@@ -632,7 +898,7 @@ function renderRecording(rawPath, target, actions, fps, size) {
       "-map",
       "[v]",
       "-r",
-      String(fps),
+      String(fps2),
       "-c:v",
       "libx264",
       "-preset",
@@ -649,8 +915,8 @@ function renderRecording(rawPath, target, actions, fps, size) {
       fail(`recording post-processing failed: ${r.error?.message || r.stderr?.toString().trim() || `exit ${r.status}`}`);
     }
   } finally {
-    rmSync(filterPath, { force: true });
-    rmSync(cursor.path, { force: true });
+    rmSync2(filterPath, { force: true });
+    rmSync2(cursor.path, { force: true });
   }
 }
 
@@ -672,11 +938,11 @@ var RECORD_STATE_FILES = [
   RECORD_ACTIONS_FILE
 ];
 function clearRecordingState() {
-  for (const file of RECORD_STATE_FILES) rmSync2(file, { force: true });
+  for (const file of RECORD_STATE_FILES) rmSync3(file, { force: true });
 }
 function recordingStartedAt() {
-  if (!existsSync2(RECORD_STARTED_AT_FILE)) return null;
-  const startedAt = Number.parseInt(readFileSync2(RECORD_STARTED_AT_FILE, "utf8").trim(), 10);
+  if (!existsSync3(RECORD_STARTED_AT_FILE)) return null;
+  const startedAt = Number.parseInt(readFileSync3(RECORD_STARTED_AT_FILE, "utf8").trim(), 10);
   return Number.isFinite(startedAt) ? startedAt : null;
 }
 function logRecordingAction(action) {
@@ -687,13 +953,13 @@ function logRecordingAction(action) {
 `);
 }
 function readRecordingDimensions() {
-  if (!existsSync2(RECORD_DIMENSIONS_FILE)) return configuredDesktopDimensions();
+  if (!existsSync3(RECORD_DIMENSIONS_FILE)) return configuredDesktopDimensions();
   try {
-    const dimensions = JSON.parse(readFileSync2(RECORD_DIMENSIONS_FILE, "utf8"));
-    const width = dimensions?.width;
-    const height = dimensions?.height;
-    if (typeof width === "number" && Number.isFinite(width) && width > 0 && typeof height === "number" && Number.isFinite(height) && height > 0) {
-      return { width, height };
+    const dimensions = JSON.parse(readFileSync3(RECORD_DIMENSIONS_FILE, "utf8"));
+    const width2 = dimensions?.width;
+    const height2 = dimensions?.height;
+    if (typeof width2 === "number" && Number.isFinite(width2) && width2 > 0 && typeof height2 === "number" && Number.isFinite(height2) && height2 > 0) {
+      return { width: width2, height: height2 };
     }
   } catch {
   }
@@ -706,8 +972,8 @@ function isOptionalNumber(value) {
   return value === void 0 || typeof value === "number";
 }
 function readRecordingActions() {
-  if (!existsSync2(RECORD_ACTIONS_FILE)) return [];
-  return readFileSync2(RECORD_ACTIONS_FILE, "utf8").split("\n").filter(Boolean).flatMap((line) => {
+  if (!existsSync3(RECORD_ACTIONS_FILE)) return [];
+  return readFileSync3(RECORD_ACTIONS_FILE, "utf8").split("\n").filter(Boolean).flatMap((line) => {
     try {
       const value = JSON.parse(line);
       if (typeof value !== "object" || value === null) return [];
@@ -728,8 +994,8 @@ function readRecordingActions() {
 }
 async function computerRecordStartCommand(path, options) {
   ensureServicesRunning();
-  if (existsSync2(RECORD_PID_FILE)) {
-    const pid = parseInt(readFileSync2(RECORD_PID_FILE, "utf8").trim(), 10);
+  if (existsSync3(RECORD_PID_FILE)) {
+    const pid = parseInt(readFileSync3(RECORD_PID_FILE, "utf8").trim(), 10);
     if (Number.isFinite(pid)) {
       let alive2 = false;
       try {
@@ -741,12 +1007,12 @@ async function computerRecordStartCommand(path, options) {
     }
   }
   const target = resolvePath(path);
-  mkdirSync2(dirname2(target), { recursive: true });
-  const fps = options.fps ? parseCoord(options.fps, "--fps") : 60;
-  const { width, height } = configuredDesktopDimensions();
-  mkdirSync2(STATE_DIR, { recursive: true });
+  mkdirSync3(dirname3(target), { recursive: true });
+  const fps2 = options.fps ? parseCoord(options.fps, "--fps") : 60;
+  const { width: width2, height: height2 } = configuredDesktopDimensions();
+  mkdirSync3(STATE_DIR, { recursive: true });
   const rawTarget = `${target}.raw-${Date.now()}.mp4`;
-  rmSync2(RECORD_ACTIONS_FILE, { force: true });
+  rmSync3(RECORD_ACTIONS_FILE, { force: true });
   const child = spawn("ffmpeg", [
     "-y",
     "-hide_banner",
@@ -755,9 +1021,9 @@ async function computerRecordStartCommand(path, options) {
     "-f",
     "x11grab",
     "-framerate",
-    String(fps),
+    String(fps2),
     "-video_size",
-    `${width}x${height}`,
+    `${width2}x${height2}`,
     "-draw_mouse",
     "0",
     "-i",
@@ -778,17 +1044,17 @@ async function computerRecordStartCommand(path, options) {
   ], { detached: true, stdio: "ignore" });
   child.unref();
   if (!child.pid) fail("failed to launch ffmpeg");
-  writeFileSync2(RECORD_PID_FILE, String(child.pid));
-  writeFileSync2(RECORD_PATH_FILE, target);
-  writeFileSync2(RECORD_RAW_PATH_FILE, rawTarget);
-  writeFileSync2(RECORD_STARTED_AT_FILE, String(Date.now()));
-  writeFileSync2(RECORD_FPS_FILE, String(fps));
-  writeFileSync2(RECORD_DIMENSIONS_FILE, JSON.stringify({ width, height }));
+  writeFileSync3(RECORD_PID_FILE, String(child.pid));
+  writeFileSync3(RECORD_PATH_FILE, target);
+  writeFileSync3(RECORD_RAW_PATH_FILE, rawTarget);
+  writeFileSync3(RECORD_STARTED_AT_FILE, String(Date.now()));
+  writeFileSync3(RECORD_FPS_FILE, String(fps2));
+  writeFileSync3(RECORD_DIMENSIONS_FILE, JSON.stringify({ width: width2, height: height2 }));
   const startedAt = Date.now();
   while (Date.now() - startedAt < 5e3) {
     try {
       process.kill(child.pid, 0);
-      if (existsSync2(rawTarget) && statSync(rawTarget).size > 0) {
+      if (existsSync3(rawTarget) && statSync(rawTarget).size > 0) {
         console.log(`${target} (recording ready in ${Date.now() - startedAt}ms)`);
         return;
       }
@@ -805,13 +1071,13 @@ async function computerRecordStartCommand(path, options) {
   }
   if (alive) fail("ffmpeg is running but did not produce recording output within 5 seconds; run `replicas computer record stop` to finalize or retry");
   clearRecordingState();
-  rmSync2(rawTarget, { force: true });
+  rmSync3(rawTarget, { force: true });
   fail("ffmpeg exited before screen recording became ready");
 }
 async function computerRecordStopCommand() {
-  if (!existsSync2(RECORD_PID_FILE) && !existsSync2(RECORD_PATH_FILE)) fail("no recording in progress");
-  if (existsSync2(RECORD_PID_FILE)) {
-    const pid = parseInt(readFileSync2(RECORD_PID_FILE, "utf8").trim(), 10);
+  if (!existsSync3(RECORD_PID_FILE) && !existsSync3(RECORD_PATH_FILE)) fail("no recording in progress");
+  if (existsSync3(RECORD_PID_FILE)) {
+    const pid = parseInt(readFileSync3(RECORD_PID_FILE, "utf8").trim(), 10);
     if (!Number.isFinite(pid)) fail("invalid recording pidfile");
     try {
       process.kill(pid, "SIGINT");
@@ -829,351 +1095,35 @@ async function computerRecordStopCommand() {
     }
     if (alive) fail(`ffmpeg did not finalize recording within 30 seconds (pid ${pid})`);
   }
-  if (existsSync2(RECORD_PATH_FILE)) {
-    const target = readFileSync2(RECORD_PATH_FILE, "utf8").trim();
-    const rawPath = existsSync2(RECORD_RAW_PATH_FILE) ? readFileSync2(RECORD_RAW_PATH_FILE, "utf8").trim() : target;
-    const fps = existsSync2(RECORD_FPS_FILE) ? parseInt(readFileSync2(RECORD_FPS_FILE, "utf8").trim(), 10) : 60;
+  if (existsSync3(RECORD_PATH_FILE)) {
+    const target = readFileSync3(RECORD_PATH_FILE, "utf8").trim();
+    const rawPath = existsSync3(RECORD_RAW_PATH_FILE) ? readFileSync3(RECORD_RAW_PATH_FILE, "utf8").trim() : target;
+    const fps2 = existsSync3(RECORD_FPS_FILE) ? parseInt(readFileSync3(RECORD_FPS_FILE, "utf8").trim(), 10) : 60;
     const size = readRecordingDimensions();
     const actions = readRecordingActions();
     if (rawPath !== target) {
-      renderRecording(rawPath, target, actions, Number.isFinite(fps) ? fps : 60, size);
-      rmSync2(rawPath, { force: true });
+      renderRecording(rawPath, target, actions, Number.isFinite(fps2) ? fps2 : 60, size);
+      rmSync3(rawPath, { force: true });
     }
     console.log(target);
   }
   clearRecordingState();
 }
 
-// src/commands/index.ts
+// ../shared/src/type-guards.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function getDesktopViewerUrl(publicUrl) {
-  const url = new URL(`${publicUrl.replace(/\/$/, "")}/`);
-  url.searchParams.set("v", "13");
-  return url.toString();
-}
-function bridgeStatus(details, includeBacklog = false, rootsOnly = false) {
-  const pids = rootsOnly ? details.rootPids ?? [] : details.listenerPids ?? [];
-  const listenerCount = rootsOnly ? details.rootListeners ?? pids.length : details.listeners ?? pids.length;
-  const listenerLabel = rootsOnly ? "root listener" : "listener";
-  const parts = [`${listenerCount} ${listenerLabel}${listenerCount === 1 ? "" : "s"} on ${details.port}`];
-  if (includeBacklog) parts.push(`backlog ${details.backlog ?? 0}`);
-  if (pids.length > 0) parts.push(`pid${pids.length === 1 ? "" : "s"} ${pids.join(",")}`);
-  return ` (${parts.join(", ")})`;
-}
-async function lookupDesktopViewerUrl() {
+
+// src/commands/browser.ts
+async function fetchChromeJson(path) {
+  let res;
   try {
-    const value = JSON.parse(readFileSync3(join(homedir(), ".replicas", "preview-ports.json"), "utf8"));
-    if (!isRecord(value) || !Array.isArray(value.previews)) return null;
-    const preview = value.previews.find(
-      (item) => isRecord(item) && item.port === NOVNC_PORT && typeof item.publicUrl === "string"
-    );
-    return isRecord(preview) && typeof preview.publicUrl === "string" ? getDesktopViewerUrl(preview.publicUrl) : null;
+    res = await fetch(`http://127.0.0.1:${CHROME_DEBUG_PORT}${path}`);
   } catch {
-    return null;
-  }
-}
-async function waitForDesktopViewerUrl(timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const url = await lookupDesktopViewerUrl();
-    if (url) return url;
-    await new Promise((resolve3) => setTimeout(resolve3, INFO_WAIT_INTERVAL_MS));
-  }
-  return await lookupDesktopViewerUrl();
-}
-async function computerInfoCommand() {
-  const viewerUrl = await waitForDesktopViewerUrl(INFO_WAIT_TIMEOUT_MS);
-  if (!viewerUrl) {
-    fail(
-      `Desktop preview for port ${NOVNC_PORT} is not registered. The engine registers it at startup \u2014 check /tmp/replicas-desktop-stack.log and engine logs for errors.`
-    );
-  }
-  console.log(viewerUrl);
-  console.error(chalk.dim(`Share this URL with the user to let them watch the desktop live.`));
-}
-async function computerStatusCommand() {
-  ensureServicesRunning();
-  const bridge = getDesktopBridgeStatus();
-  const procs = ["Xvfb", "openbox", "tint2", "x11vnc", "websockify"];
-  for (const p of procs) {
-    const r = spawnSync3("pgrep", ["-af", p], { stdio: "pipe" });
-    const running = r.status === 0 && !!r.stdout?.toString().trim();
-    const suffix = p === "x11vnc" && bridge ? bridgeStatus(bridge.x11vnc, true) : p === "websockify" && bridge ? bridgeStatus(bridge.websockify, false, true) : "";
-    console.log(`  ${running ? chalk.green("\u25CF") : chalk.red("\u25CB")} ${p}${suffix}`);
-  }
-  const viewerUrl = await lookupDesktopViewerUrl();
-  if (viewerUrl) {
-    console.log(`  ${chalk.cyan("preview")}: ${viewerUrl}`);
-  } else {
-    console.log(`  ${chalk.dim("preview: not yet registered (engine registers it at startup)")}`);
-  }
-}
-var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
-function readPngDimensions(filePath) {
-  const fd = openSync(filePath, "r");
-  try {
-    const buf = Buffer.alloc(24);
-    const bytesRead = readSync(fd, buf, 0, 24, 0);
-    if (bytesRead < 24 || !buf.subarray(0, 8).equals(PNG_SIGNATURE)) {
-      fail(`${filePath} is not a valid PNG (read ${bytesRead}/24 bytes)`);
-    }
-    return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
-  } finally {
-    closeSync(fd);
-  }
-}
-function brandSvgPath() {
-  const dir = process.env.REPLICAS_DESKTOP_TEMPLATES || "/usr/local/share/replicas/desktop";
-  return `${dir}/brand-wallpaper.svg`;
-}
-function loadBrandSvg(canvasW, canvasH) {
-  const path = brandSvgPath();
-  if (!existsSync3(path)) {
-    fail(
-      `Brand wallpaper SVG missing at ${path}. The workspace image is out of date \u2014 \`replicas-computer setup\` must install brand-wallpaper.svg at $REPLICAS_DESKTOP_TEMPLATES.`
-    );
-  }
-  return readFileSync3(path, "utf8").replace(/(<svg[^>]*\s)width="\d+"/, `$1width="${canvasW}"`).replace(/(<svg[^>]*\s)height="\d+"/, `$1height="${canvasH}"`);
-}
-var BRAND_PAD_FRACTION = 0.06;
-var SCREENSHOT_CORNER_FRACTION = 0.022;
-var SHADOW_SIGMA_FRACTION = 0.022;
-var SHADOW_OFFSET_Y_FRACTION = 0.013;
-var SHADOW_ALPHA = 0.6;
-var SCREENSHOT_MASK_TEMPLATE = `<svg width="__W__" height="__H__" xmlns="http://www.w3.org/2000/svg"><rect width="__W__" height="__H__" rx="__R__" ry="__R__" fill="white"/></svg>`;
-var SHADOW_MASK_TEMPLATE = `<svg width="__SW__" height="__SH__" xmlns="http://www.w3.org/2000/svg"><rect x="__M__" y="__M__" width="__W__" height="__H__" rx="__R__" ry="__R__" fill="white"/></svg>`;
-function parseGridSize(value) {
-  if (value === void 0 || value === false) return null;
-  const size = value === true ? 100 : parseCoord(value, "--grid");
-  if (size < 25 || size > 500) fail("--grid must be between 25 and 500 pixels");
-  return size;
-}
-function buildGridSvg(width, height, size) {
-  const lines = [];
-  const labels = [];
-  for (let x = 0; x <= width; x += size) {
-    const strokeWidth = x % (size * 5) === 0 ? 2 : 1;
-    lines.push(`<line x1="${x}" y1="0" x2="${x}" y2="${height}" stroke="#00e5ff" stroke-opacity="0.42" stroke-width="${strokeWidth}"/>`);
-    if (x > 0 && x < width) labels.push(`<text x="${x + 4}" y="18">${x}</text>`);
-  }
-  for (let y = 0; y <= height; y += size) {
-    const strokeWidth = y % (size * 5) === 0 ? 2 : 1;
-    lines.push(`<line x1="0" y1="${y}" x2="${width}" y2="${y}" stroke="#00e5ff" stroke-opacity="0.42" stroke-width="${strokeWidth}"/>`);
-    if (y > 0 && y < height) labels.push(`<text x="4" y="${y - 4}">${y}</text>`);
-  }
-  return `<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
-<style>text{font:16px monospace;fill:white;paint-order:stroke;stroke:black;stroke-width:4px;stroke-linejoin:round}</style>
-${lines.join("\n")}
-${labels.join("\n")}
-</svg>`;
-}
-function overlayGrid(rawPath, target, width, height, gridSize, gridPath) {
-  writeFileSync3(gridPath, buildGridSvg(width, height, gridSize));
-  const r = spawnSync3(
-    "ffmpeg",
-    [
-      "-y",
-      "-hide_banner",
-      "-loglevel",
-      "error",
-      "-i",
-      rawPath,
-      "-i",
-      gridPath,
-      "-filter_complex",
-      "[0:v][1:v]overlay=0:0:format=auto",
-      "-frames:v",
-      "1",
-      "-update",
-      "1",
-      target
-    ],
-    { stdio: "pipe" }
-  );
-  if (r.status !== 0) {
-    fail(`ffmpeg grid overlay failed: ${r.stderr?.toString().trim() || `exit ${r.status}`}`);
-  }
-}
-async function computerScreenshotCommand(path, options = {}) {
-  const target = resolvePath(path);
-  mkdirSync3(dirname3(target), { recursive: true });
-  const stamp = `${process.pid}-${Date.now()}`;
-  const rawPath = `/tmp/replicas-screenshot-${stamp}.raw.png`;
-  const svgPath = `/tmp/replicas-screenshot-${stamp}.brand.svg`;
-  const maskPath = `/tmp/replicas-screenshot-${stamp}.mask.svg`;
-  const shadowPath = `/tmp/replicas-screenshot-${stamp}.shadow.svg`;
-  const gridPath = `/tmp/replicas-screenshot-${stamp}.grid.svg`;
-  try {
-    runDisplayCmd("scrot", ["-o", rawPath]);
-    const { width, height } = readPngDimensions(rawPath);
-    const gridSize = parseGridSize(options.grid);
-    if (options.raw && gridSize === null) {
-      copyFileSync2(rawPath, target);
-      console.log(`${target} (${width}x${height}, raw 1:1 desktop pixels)`);
-      return;
-    }
-    if (gridSize !== null) {
-      overlayGrid(rawPath, target, width, height, gridSize, gridPath);
-      console.log(`${target} (${width}x${height}, raw 1:1 desktop pixels, ${gridSize}px grid)`);
-      return;
-    }
-    const padX = Math.round(width * BRAND_PAD_FRACTION);
-    const padY = Math.round(height * BRAND_PAD_FRACTION);
-    const canvasW = width + padX * 2;
-    const canvasH = height + padY * 2;
-    const minDim = Math.min(width, height);
-    const cornerR = Math.round(minDim * SCREENSHOT_CORNER_FRACTION);
-    const shadowSigma = Math.max(12, Math.round(minDim * SHADOW_SIGMA_FRACTION));
-    const shadowOffsetY = Math.round(minDim * SHADOW_OFFSET_Y_FRACTION);
-    const shadowMargin = shadowSigma * 3;
-    const shadowW = width + shadowMargin * 2;
-    const shadowH = height + shadowMargin * 2;
-    writeFileSync3(svgPath, loadBrandSvg(canvasW, canvasH));
-    writeFileSync3(
-      maskPath,
-      SCREENSHOT_MASK_TEMPLATE.replace(/__W__/g, String(width)).replace(/__H__/g, String(height)).replace(/__R__/g, String(cornerR))
-    );
-    writeFileSync3(
-      shadowPath,
-      SHADOW_MASK_TEMPLATE.replace(/__SW__/g, String(shadowW)).replace(/__SH__/g, String(shadowH)).replace(/__M__/g, String(shadowMargin)).replace(/__W__/g, String(width)).replace(/__H__/g, String(height)).replace(/__R__/g, String(cornerR))
-    );
-    const r = spawnSync3(
-      "ffmpeg",
-      [
-        "-y",
-        "-hide_banner",
-        "-loglevel",
-        "error",
-        "-i",
-        svgPath,
-        "-i",
-        rawPath,
-        "-i",
-        maskPath,
-        "-i",
-        shadowPath,
-        "-filter_complex",
-        `[2:v]format=rgba,alphaextract[mask];[3:v]format=rgba,colorchannelmixer=rr=0:gg=0:bb=0:aa=${SHADOW_ALPHA},gblur=sigma=${shadowSigma}[shadow];[1:v]format=rgba[scr];[scr][mask]alphamerge[rounded];[0:v]format=rgba[bg];[bg][shadow]overlay=${padX - shadowMargin}:${padY - shadowMargin + shadowOffsetY}:format=auto[bg_shadow];[bg_shadow][rounded]overlay=${padX}:${padY}:format=auto`,
-        "-frames:v",
-        "1",
-        "-update",
-        "1",
-        target
-      ],
-      { stdio: "pipe" }
-    );
-    if (r.status !== 0) {
-      fail(`ffmpeg branding failed: ${r.stderr?.toString().trim() || `exit ${r.status}`}`);
-    }
-  } finally {
-    rmSync3(rawPath, { force: true });
-    rmSync3(svgPath, { force: true });
-    rmSync3(maskPath, { force: true });
-    rmSync3(shadowPath, { force: true });
-    rmSync3(gridPath, { force: true });
-  }
-  console.log(target);
-}
-function hashFile(path) {
-  return createHash("sha256").update(readFileSync3(path)).digest("hex");
-}
-async function captureStableRawScreenshot(target, options) {
-  const start = Date.now();
-  const framePath = `${target}.frame.png`;
-  let lastHash = null;
-  let lastChangeAt = start;
-  let frames = 0;
-  let changes = 0;
-  let width = 0;
-  let height = 0;
-  try {
-    while (Date.now() - start <= options.timeoutMs) {
-      runDisplayCmd("scrot", ["-o", framePath]);
-      frames++;
-      const dimensions = readPngDimensions(framePath);
-      width = dimensions.width;
-      height = dimensions.height;
-      const hash = hashFile(framePath);
-      const now = Date.now();
-      if (lastHash === null) {
-        lastChangeAt = now;
-      } else if (hash !== lastHash) {
-        changes++;
-        lastChangeAt = now;
-      }
-      lastHash = hash;
-      copyFileSync2(framePath, target);
-      if (frames > 1 && now - lastChangeAt >= options.stableMs) {
-        return { width, height, stable: true, elapsedMs: now - start, frames, changes };
-      }
-      await sleep(options.pollMs);
-    }
-    return { width, height, stable: false, elapsedMs: Date.now() - start, frames, changes };
-  } finally {
-    rmSync3(framePath, { force: true });
-  }
-}
-function getActiveWindowTitle() {
-  return tryDisplayCmd("xdotool", ["getactivewindow", "getwindowname"]);
-}
-function getVisibleWindowTitles() {
-  const out = tryDisplayCmd("xdotool", ["search", "--onlyvisible", "--name", ".", "getwindowname", "%@"]);
-  return out ? out.split("\n").filter(Boolean).slice(0, 20) : [];
-}
-function recordingMousePosition() {
-  const mouse = getMouseLocation();
-  return mouse ? { x: mouse.x, y: mouse.y } : null;
-}
-async function computerObserveCommand(path, options = {}) {
-  const target = resolvePath(path);
-  mkdirSync3(dirname3(target), { recursive: true });
-  const timeoutMs = options.timeout ? parseCoord(options.timeout, "--timeout") : 3e3;
-  const stableMs = options.stableMs ? parseCoord(options.stableMs, "--stable-ms") : 600;
-  const pollMs = options.pollMs ? parseCoord(options.pollMs, "--poll-ms") : 200;
-  if (timeoutMs < 0) fail("--timeout must be >= 0");
-  if (stableMs < 0) fail("--stable-ms must be >= 0");
-  if (pollMs < 50 || pollMs > 2e3) fail("--poll-ms must be between 50 and 2000");
-  const stamp = `${process.pid}-${Date.now()}`;
-  const rawPath = `/tmp/replicas-observe-${stamp}.raw.png`;
-  const gridPath = `/tmp/replicas-observe-${stamp}.grid.svg`;
-  try {
-    ensureServicesRunning();
-    const capture = await captureStableRawScreenshot(rawPath, { timeoutMs, stableMs, pollMs });
-    const gridSize = options.raw ? null : parseGridSize(options.grid ?? true);
-    if (gridSize === null) {
-      copyFileSync2(rawPath, target);
-    } else {
-      overlayGrid(rawPath, target, capture.width, capture.height, gridSize, gridPath);
-    }
-    console.log(JSON.stringify({
-      screenshot: target,
-      width: capture.width,
-      height: capture.height,
-      stable: capture.stable,
-      elapsedMs: capture.elapsedMs,
-      frames: capture.frames,
-      changes: capture.changes,
-      mouse: getMouseLocation(),
-      activeWindow: getActiveWindowTitle(),
-      visibleWindows: getVisibleWindowTitles(),
-      mode: gridSize === null ? "raw" : "grid",
-      gridSize
-    }, null, 2));
-  } finally {
-    rmSync3(rawPath, { force: true });
-    rmSync3(gridPath, { force: true });
-  }
-}
-async function fetchChromeJson(path) {
-  let res;
-  try {
-    res = await fetch(`http://127.0.0.1:${CHROME_DEBUG_PORT}${path}`);
-  } catch {
-    fail(
-      `Chrome DevTools is not available on localhost:${CHROME_DEBUG_PORT}. Launch Chrome with \`replicas computer launch chrome <url>\` and try again.`
-    );
+    fail(
+      `Chrome DevTools is not available on localhost:${CHROME_DEBUG_PORT}. Launch Chrome with \`replicas computer launch chrome <url>\` and try again.`
+    );
   }
   if (!res.ok) fail(`Chrome DevTools returned HTTP ${res.status}`);
   try {
@@ -1224,7 +1174,7 @@ async function sendChromeSessionCommand(session, method, params) {
   return chromeResult(await session.send({ method, params }), method);
 }
 async function withChromeSession(webSocketDebuggerUrl, callback) {
-  return await new Promise((resolve3, reject) => {
+  return await new Promise((resolve4, reject) => {
     const ws = new WebSocket(webSocketDebuggerUrl);
     const pending = /* @__PURE__ */ new Map();
     let nextId = 1;
@@ -1246,7 +1196,7 @@ async function withChromeSession(webSocketDebuggerUrl, callback) {
       for (const request of pending.values()) clearTimeout(request.timeout);
       pending.clear();
       ws.close();
-      resolve3(value);
+      resolve4(value);
     };
     const session = {
       send: ({ method, params }) => new Promise((resolveCommand, rejectCommand) => {
@@ -1363,7 +1313,7 @@ function browserStateProperties(node) {
 function readBrowserStateCache(path) {
   let value;
   try {
-    value = JSON.parse(readFileSync3(path, "utf8"));
+    value = JSON.parse(readFileSync4(path, "utf8"));
   } catch {
     return null;
   }
@@ -1421,9 +1371,9 @@ function browserContentQuadRects(quads, viewportRect) {
     const ys = [quad[1], quad[3], quad[5], quad[7]];
     const x = Math.min(...xs);
     const y = Math.min(...ys);
-    const width = Math.max(...xs) - x;
-    const height = Math.max(...ys) - y;
-    return { x, y, width, height, centerX: x + width / 2, centerY: y + height / 2 };
+    const width2 = Math.max(...xs) - x;
+    const height2 = Math.max(...ys) - y;
+    return { x, y, width: width2, height: height2, centerX: x + width2 / 2, centerY: y + height2 / 2 };
   }).map((rect) => intersectRects(rect, viewportRect)).filter((rect) => !!rect).sort((a, b) => b.width * b.height - a.width * a.height);
 }
 function buildBrowserBounds(result, viewport, targetId) {
@@ -1438,14 +1388,14 @@ function buildBrowserBounds(result, viewport, targetId) {
     nodeIndexes.forEach((nodeIndex, index) => {
       const bound = bounds[index];
       if (!Array.isArray(bound) || bound.length < 4 || !bound.every(Number.isFinite)) return;
-      const [rawX, rawY, width, height] = bound;
+      const [rawX, rawY, width2, height2] = bound;
       rects.set(nodeIndex, {
         x: rawX - scrollX,
         y: rawY - scrollY,
-        width,
-        height,
-        centerX: rawX - scrollX + width / 2,
-        centerY: rawY - scrollY + height / 2
+        width: width2,
+        height: height2,
+        centerX: rawX - scrollX + width2 / 2,
+        centerY: rawY - scrollY + height2 / 2
       });
     });
     return rects;
@@ -1640,7 +1590,8 @@ async function captureBrowserSnapshot(page, options) {
     node,
     role: roleOf(node),
     bound: typeof node.backendDOMNodeId === "number" ? bounds.get(node.backendDOMNodeId) : void 0
-  })).filter(({ node, role, bound }) => {
+  })).filter((entry) => {
+    const { node, role, bound } = entry;
     if (!bound || bound.rect.width <= 0 || bound.rect.height <= 0) return false;
     if (role === "InlineTextBox" || role === "none" || role === "generic") return false;
     if (BROWSER_INTERACTIVE_ROLES.has(role) || BROWSER_STRUCTURAL_ROLES.has(role)) return true;
@@ -1709,7 +1660,7 @@ async function captureBrowserSnapshot(page, options) {
       visibleTextLength += Math.min(name.length, remaining) + 1;
     }
   }
-  const revision = createHash("sha256").update(JSON.stringify([page.url, entries.map(({ key, semantic }) => [key, semantic])])).digest("hex").slice(0, 16);
+  const revision = createHash2("sha256").update(JSON.stringify([page.url, entries.map(({ key, semantic }) => [key, semantic])])).digest("hex").slice(0, 16);
   const snapshot = {
     title: (page.title ?? "").slice(0, 1e3),
     url: (page.url ?? "").slice(0, 2e3),
@@ -1889,7 +1840,7 @@ async function computerBrowserStateCommand(path, options = {}) {
   const page = await selectChromePage(options);
   const stability = await waitForBrowserStability(page, { timeoutMs, stableMs, pollMs });
   const target = resolvePath(path);
-  mkdirSync3(dirname3(target), { recursive: true });
+  mkdirSync4(dirname4(target), { recursive: true });
   const [{ snapshot, entries }, screenshotResult] = await Promise.all([
     captureBrowserSnapshot(page, { textLimit, elementLimit }),
     sendChromeCommand(page.webSocketDebuggerUrl, "Page.captureScreenshot", {
@@ -1900,14 +1851,14 @@ async function computerBrowserStateCommand(path, options = {}) {
   ]);
   const data = screenshotResult.data;
   if (typeof data !== "string") fail("Chrome did not return screenshot data");
-  writeFileSync3(target, Buffer.from(data, "base64"));
+  writeFileSync4(target, Buffer.from(data, "base64"));
   const screenshot = readPngDimensions(target);
   const targetId = page.id ?? "unknown";
   const cachePath = browserStateCachePath(targetId);
   let mode = "full";
   let tree = snapshot.tree;
   let changes = { added: snapshot.nodeCount, changed: 0, removed: 0 };
-  if (!options.full && existsSync3(cachePath)) {
+  if (!options.full && existsSync4(cachePath)) {
     const cached = readBrowserStateCache(cachePath);
     if (cached?.url === snapshot.url && cached.documentId === snapshot.documentId) {
       mode = "diff";
@@ -1916,8 +1867,8 @@ async function computerBrowserStateCommand(path, options = {}) {
       changes = { added: diff.added, changed: diff.changed, removed: diff.removed };
     }
   }
-  mkdirSync3(STATE_DIR, { recursive: true });
-  writeFileSync3(cachePath, JSON.stringify({ url: snapshot.url, documentId: snapshot.documentId, entries }));
+  mkdirSync4(STATE_DIR, { recursive: true });
+  writeFileSync4(cachePath, JSON.stringify({ url: snapshot.url, documentId: snapshot.documentId, entries }));
   const stableState = isRecord(stability.state) ? stability.state : {};
   const state = {
     title: snapshot.title,
@@ -1963,7 +1914,7 @@ function readBrowserRefCache(page) {
   const targetId = page.id;
   if (!targetId) fail("Chrome target has no stable ID. Capture fresh browser state and retry.");
   const cachePath = browserStateCachePath(targetId);
-  if (!existsSync3(cachePath)) fail(`No browser state is cached for target ${targetId}. Run replicas computer browser-state <path> --target-id ${targetId} first.`);
+  if (!existsSync4(cachePath)) fail(`No browser state is cached for target ${targetId}. Run replicas computer browser-state <path> --target-id ${targetId} first.`);
   const cached = readBrowserStateCache(cachePath);
   if (!cached) fail(`Browser state for target ${targetId} is invalid. Capture fresh browser state and retry.`);
   if (cached.url !== (page.url ?? "").slice(0, 2e3)) fail("Cached browser state belongs to a different URL. Capture fresh browser state and retry.");
@@ -2718,16 +2669,96 @@ async function computerBrowserBatchCommand(actionsJson, options = {}) {
   }
   console.log(JSON.stringify({ ok: true, targetId, elapsedMs: Date.now() - startedAt, completed }, null, 2));
 }
-async function computerClickCommand(xStr, yStr, options) {
-  const dimensions = getDisplayDimensions();
-  const x = parseScreenCoord(xStr, "x", dimensions.width);
-  const y = parseScreenCoord(yStr, "y", dimensions.height);
-  const button = options.button ?? "1";
-  const args = ["mousemove", "--sync", String(x), String(y)];
-  if (options.modifiers) {
-    for (const mod of options.modifiers.split("+")) {
-      args.push("keydown", mod);
-    }
+var APP_ALIASES = {
+  chrome: [CHROME_WRAPPER],
+  chromium: ["chromium", "--no-first-run", "--no-default-browser-check"],
+  firefox: ["firefox"],
+  terminal: ["xfce4-terminal"],
+  xterm: ["xterm"],
+  notepad: ["mousepad"],
+  editor: ["mousepad"],
+  files: ["thunar"],
+  filemanager: ["thunar"]
+};
+var LEGACY_CHROME_ALIAS = [
+  "google-chrome",
+  "--no-first-run",
+  "--no-default-browser-check",
+  "--start-maximized",
+  "--user-data-dir=/tmp/replicas-computer/chrome-profile"
+];
+async function computerLaunchCommand(app, args) {
+  ensureServicesRunning();
+  const baseArgs = app === "chrome" && !existsSync4(CHROME_WRAPPER) ? LEGACY_CHROME_ALIAS : APP_ALIASES[app] ?? [app];
+  const bin = baseArgs[0];
+  const fullArgs = [...baseArgs.slice(1), ...args];
+  const expectsNewChromePage = args.some((arg) => !arg.startsWith("-"));
+  const existingChromePageIds = /* @__PURE__ */ new Set();
+  if (app === "chrome") {
+    try {
+      for (const page of await getChromePages()) {
+        if (page.id) existingChromePageIds.add(page.id);
+      }
+    } catch {
+    }
+  }
+  const child = spawn2(bin, fullArgs, {
+    env: withDisplay(),
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  if (app === "chrome") {
+    const startedAt = Date.now();
+    let pageCount = 0;
+    let readyPage = null;
+    while (Date.now() - startedAt < 15e3) {
+      let pages = [];
+      try {
+        pages = await getChromePages();
+      } catch {
+      }
+      pageCount = pages.length;
+      const candidates = expectsNewChromePage && existingChromePageIds.size > 0 ? pages.filter((page) => page.id && !existingChromePageIds.has(page.id)) : pages;
+      for (const page of candidates) {
+        if (!page.webSocketDebuggerUrl || !page.url || page.url === "about:blank") continue;
+        const readyState = await evaluateChromeTarget(page.webSocketDebuggerUrl, "document.readyState");
+        if (readyState === "interactive" || readyState === "complete") {
+          readyPage = page;
+          break;
+        }
+      }
+      if (readyPage) break;
+      try {
+        if (child.pid) process.kill(child.pid, 0);
+      } catch {
+        fail(`Chrome exited before its desktop control channel became ready.`);
+      }
+      await sleep(100);
+    }
+    if (!readyPage?.webSocketDebuggerUrl) fail(`Chrome launched but its requested page was not controllable after 15 seconds.`);
+    await sendChromeCommand(readyPage.webSocketDebuggerUrl, "Page.bringToFront", {});
+    console.log(`launched ${bin} (pid ${child.pid}, ready in ${Date.now() - startedAt}ms, page ${readyPage.id}, ${pageCount} open)`);
+    return;
+  }
+  console.log(`launched ${bin} (pid ${child.pid})`);
+}
+
+// src/commands/input.ts
+var recordingMousePosition = () => {
+  const mouse = getMouseLocation();
+  return mouse ? { x: mouse.x, y: mouse.y } : null;
+};
+async function computerClickCommand(xStr, yStr, options) {
+  const dimensions = getDisplayDimensions();
+  const x = parseScreenCoord(xStr, "x", dimensions.width);
+  const y = parseScreenCoord(yStr, "y", dimensions.height);
+  const button = options.button ?? "1";
+  const args = ["mousemove", "--sync", String(x), String(y)];
+  if (options.modifiers) {
+    for (const mod of options.modifiers.split("+")) {
+      args.push("keydown", mod);
+    }
   }
   if (options.double) {
     args.push("click", "--repeat", "2", "--delay", "50", button);
@@ -2817,83 +2848,80 @@ async function computerDragCommand(fx, fy, tx, ty) {
   logRecordingAction({ type: "drag", x: fromX, y: fromY, toX, toY });
   console.log(`dragged (${fromX},${fromY}) -> (${toX},${toY})`);
 }
-var APP_ALIASES = {
-  chrome: [CHROME_WRAPPER],
-  chromium: ["chromium", "--no-first-run", "--no-default-browser-check"],
-  firefox: ["firefox"],
-  terminal: ["xfce4-terminal"],
-  xterm: ["xterm"],
-  notepad: ["mousepad"],
-  editor: ["mousepad"],
-  files: ["thunar"],
-  filemanager: ["thunar"]
-};
-var LEGACY_CHROME_ALIAS = [
-  "google-chrome",
-  "--no-first-run",
-  "--no-default-browser-check",
-  "--start-maximized",
-  "--user-data-dir=/tmp/replicas-computer/chrome-profile"
-];
-async function computerLaunchCommand(app, args) {
+
+// src/commands/system.ts
+import { spawnSync as spawnSync4 } from "child_process";
+import { readFileSync as readFileSync5 } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import chalk from "chalk";
+function bridgeStatus(details, includeBacklog = false, rootsOnly = false) {
+  const pids = rootsOnly ? details.rootPids ?? [] : details.listenerPids ?? [];
+  const listenerCount = rootsOnly ? details.rootListeners ?? pids.length : details.listeners ?? pids.length;
+  const listenerLabel = rootsOnly ? "root listener" : "listener";
+  const parts = [`${listenerCount} ${listenerLabel}${listenerCount === 1 ? "" : "s"} on ${details.port}`];
+  parts.push(`${details.connections ?? 0} active`);
+  if (includeBacklog) parts.push(`backlog ${details.backlog ?? 0}`);
+  if (pids.length > 0) parts.push(`pid${pids.length === 1 ? "" : "s"} ${pids.join(",")}`);
+  return ` (${parts.join(", ")})`;
+}
+async function lookupDesktopViewerUrl() {
+  try {
+    const value = JSON.parse(readFileSync5(join(homedir(), ".replicas", "preview-ports.json"), "utf8"));
+    if (!isRecord(value) || !Array.isArray(value.previews)) return null;
+    const preview = value.previews.find(
+      (item) => isRecord(item) && item.port === STREAM_PORT && typeof item.publicUrl === "string"
+    );
+    return isRecord(preview) && typeof preview.publicUrl === "string" ? getDesktopViewerUrl(preview.publicUrl) : null;
+  } catch {
+    return null;
+  }
+}
+async function waitForDesktopViewerUrl(timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const url = await lookupDesktopViewerUrl();
+    if (url) return url;
+    await new Promise((resolve4) => setTimeout(resolve4, INFO_WAIT_INTERVAL_MS));
+  }
+  return await lookupDesktopViewerUrl();
+}
+async function computerInfoCommand() {
+  const viewerUrl = await waitForDesktopViewerUrl(INFO_WAIT_TIMEOUT_MS);
+  if (!viewerUrl) {
+    fail(
+      `Desktop preview for port ${STREAM_PORT} is not registered. The engine registers it at startup \u2014 check /tmp/replicas-desktop-stack.log and engine logs for errors.`
+    );
+  }
+  console.log(viewerUrl);
+  console.error(chalk.dim(`Share this URL with the user to let them watch the desktop live.`));
+}
+async function computerStatusCommand() {
   ensureServicesRunning();
-  const baseArgs = app === "chrome" && !existsSync3(CHROME_WRAPPER) ? LEGACY_CHROME_ALIAS : APP_ALIASES[app] ?? [app];
-  const bin = baseArgs[0];
-  const fullArgs = [...baseArgs.slice(1), ...args];
-  const expectsNewChromePage = args.some((arg) => !arg.startsWith("-"));
-  const existingChromePageIds = /* @__PURE__ */ new Set();
-  if (app === "chrome") {
-    try {
-      for (const page of await getChromePages()) {
-        if (page.id) existingChromePageIds.add(page.id);
-      }
-    } catch {
-    }
+  const bridge = getDesktopBridgeStatus();
+  const procs = [
+    ["Xvfb", "Xvfb"],
+    ["openbox", "openbox"],
+    ["tint2", "tint2"],
+    ["PulseAudio", "pulseaudio"],
+    ["desktop stream", "replicas-computer.*stream"]
+  ];
+  for (const [label, pattern] of procs) {
+    const r = spawnSync4("pgrep", ["-af", pattern], { stdio: "pipe" });
+    const running = r.status === 0 && !!r.stdout?.toString().trim();
+    const suffix = label === "desktop stream" && bridge ? bridgeStatus(bridge.stream) : "";
+    console.log(`  ${running ? chalk.green("\u25CF") : chalk.red("\u25CB")} ${label}${suffix}`);
   }
-  const child = spawn2(bin, fullArgs, {
-    env: withDisplay(),
-    detached: true,
-    stdio: "ignore"
-  });
-  child.unref();
-  if (app === "chrome") {
-    const startedAt = Date.now();
-    let pageCount = 0;
-    let readyPage = null;
-    while (Date.now() - startedAt < 15e3) {
-      let pages = [];
-      try {
-        pages = await getChromePages();
-      } catch {
-      }
-      pageCount = pages.length;
-      const candidates = expectsNewChromePage && existingChromePageIds.size > 0 ? pages.filter((page) => page.id && !existingChromePageIds.has(page.id)) : pages;
-      for (const page of candidates) {
-        if (!page.webSocketDebuggerUrl || !page.url || page.url === "about:blank") continue;
-        const readyState = await evaluateChromeTarget(page.webSocketDebuggerUrl, "document.readyState");
-        if (readyState === "interactive" || readyState === "complete") {
-          readyPage = page;
-          break;
-        }
-      }
-      if (readyPage) break;
-      try {
-        if (child.pid) process.kill(child.pid, 0);
-      } catch {
-        fail(`Chrome exited before its desktop control channel became ready.`);
-      }
-      await sleep(100);
-    }
-    if (!readyPage?.webSocketDebuggerUrl) fail(`Chrome launched but its requested page was not controllable after 15 seconds.`);
-    await sendChromeCommand(readyPage.webSocketDebuggerUrl, "Page.bringToFront", {});
-    console.log(`launched ${bin} (pid ${child.pid}, ready in ${Date.now() - startedAt}ms, page ${readyPage.id}, ${pageCount} open)`);
-    return;
+  const viewerUrl = await lookupDesktopViewerUrl();
+  if (viewerUrl) {
+    console.log(`  ${chalk.cyan("preview")}: ${viewerUrl}`);
+  } else {
+    console.log(`  ${chalk.dim("preview: not yet registered (engine registers it at startup)")}`);
   }
-  console.log(`launched ${bin} (pid ${child.pid})`);
 }
 
 // src/version.ts
-var COMPUTER_USE_VERSION = "0.1.0";
+var COMPUTER_USE_VERSION = "0.2.0";
 var COMPUTER_USE_PROTOCOL_VERSION = 1;
 
 // src/program.ts
@@ -2971,6 +2999,8 @@ async function runDirectCommand(argv, cwd = process.cwd()) {
 // src/daemon.ts
 var COMPUTER_USE_SOCKET_PATH = process.env.REPLICAS_COMPUTER_SOCKET || `${STATE_DIR}/control.sock`;
 var MAX_REQUEST_BYTES = 1024 * 1024;
+var MAX_CLIENTS = 256;
+var REQUEST_READ_TIMEOUT_MS = 1e4;
 function isDaemonRequest(value) {
   return typeof value === "object" && value !== null && "protocolVersion" in value && value.protocolVersion === COMPUTER_USE_PROTOCOL_VERSION && "cwd" in value && typeof value.cwd === "string" && value.cwd.startsWith("/") && "argv" in value && Array.isArray(value.argv) && value.argv.length <= 100 && value.argv.every((arg) => typeof arg === "string" && arg.length <= 1e5);
 }
@@ -2979,27 +3009,38 @@ function writeResult(socket, result) {
 `);
 }
 async function hasSocketListener() {
-  if (!existsSync4(COMPUTER_USE_SOCKET_PATH)) return false;
-  return await new Promise((resolve3) => {
+  if (!existsSync5(COMPUTER_USE_SOCKET_PATH)) return false;
+  return await new Promise((resolve4) => {
     const socket = createConnection(COMPUTER_USE_SOCKET_PATH);
     socket.setTimeout(500, () => socket.destroy());
     socket.once("connect", () => {
       socket.destroy();
-      resolve3(true);
+      resolve4(true);
     });
-    socket.once("error", () => resolve3(false));
-    socket.once("close", () => resolve3(false));
+    socket.once("error", () => resolve4(false));
+    socket.once("close", () => resolve4(false));
   });
 }
 async function runComputerDaemon() {
   if (await hasSocketListener()) throw new Error(`Computer-use daemon is already listening on ${COMPUTER_USE_SOCKET_PATH}`);
   ensureServicesRunning();
-  mkdirSync4(dirname4(COMPUTER_USE_SOCKET_PATH), { recursive: true, mode: 448 });
+  mkdirSync5(dirname5(COMPUTER_USE_SOCKET_PATH), { recursive: true, mode: 448 });
   rmSync4(COMPUTER_USE_SOCKET_PATH, { force: true });
   let queue = Promise.resolve();
+  const clients = /* @__PURE__ */ new Set();
   const server = createServer({ allowHalfOpen: true }, (socket) => {
+    if (clients.size >= MAX_CLIENTS) {
+      writeResult(socket, { exitCode: 75, stdout: "", stderr: "Computer-use daemon is busy; retry the request\n" });
+      return;
+    }
     let input = "";
     let rejected = false;
+    clients.add(socket);
+    socket.once("close", () => clients.delete(socket));
+    socket.setTimeout(REQUEST_READ_TIMEOUT_MS, () => {
+      rejected = true;
+      writeResult(socket, { exitCode: 2, stdout: "", stderr: "Computer-use request was not received within 10 seconds\n" });
+    });
     socket.setEncoding("utf8");
     socket.on("data", (chunk) => {
       if (rejected) return;
@@ -3011,6 +3052,7 @@ async function runComputerDaemon() {
     });
     socket.on("end", () => {
       if (rejected) return;
+      socket.setTimeout(0);
       queue = queue.then(async () => {
         let request;
         try {
@@ -3030,33 +3072,35 @@ async function runComputerDaemon() {
       });
     });
   });
-  await new Promise((resolve3, reject) => {
+  await new Promise((resolve4, reject) => {
     server.once("error", reject);
     server.listen(COMPUTER_USE_SOCKET_PATH, () => {
       server.off("error", reject);
       chmodSync(COMPUTER_USE_SOCKET_PATH, 384);
       console.log(`replicas-computer ${COMPUTER_USE_VERSION} listening on ${COMPUTER_USE_SOCKET_PATH}`);
-      resolve3();
+      resolve4();
     });
   });
   const healthTimer = setInterval(() => {
-    queue = queue.then(() => ensureServicesRunning()).catch((error) => {
+    try {
+      ensureServicesRunning();
+    } catch (error) {
       console.error(error instanceof Error ? error.message : String(error));
-    });
+    }
   }, 5e3);
   healthTimer.unref();
-  await new Promise((resolve3) => {
+  await new Promise((resolve4) => {
     let closing = false;
     const close = () => {
       if (closing) return;
       closing = true;
       clearInterval(healthTimer);
-      server.close(() => resolve3());
+      server.close(() => resolve4());
     };
     process.once("SIGTERM", close);
     process.once("SIGINT", close);
   });
-  spawnSync4("bash", [SERVICES_SCRIPT, "--stop"], { stdio: "inherit" });
+  spawnSync5("bash", [SERVICES_SCRIPT, "--stop"], { stdio: "inherit" });
   rmSync4(COMPUTER_USE_SOCKET_PATH, { force: true });
 }
 
@@ -3065,7 +3109,7 @@ var DAEMON_STARTUP_TIMEOUT_MS = 5e3;
 var ComputerDaemonUnavailableError = class extends Error {
 };
 function sendComputerRequest(argv) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const socket = createConnection2(COMPUTER_USE_SOCKET_PATH);
     let response = "";
     let settled = false;
@@ -3073,7 +3117,7 @@ function sendComputerRequest(argv) {
       if (settled) return;
       settled = true;
       if (error) reject(error);
-      else if (result) resolve3(result);
+      else if (result) resolve4(result);
     };
     socket.setEncoding("utf8");
     socket.setTimeout(10 * 60 * 1e3, () => socket.destroy(new Error("Computer-use command timed out")));
@@ -3111,16 +3155,645 @@ async function runComputerClient(argv) {
       return await sendComputerRequest(argv);
     } catch (error) {
       if (!(error instanceof ComputerDaemonUnavailableError) || Date.now() >= deadline) throw error;
-      await new Promise((resolve3) => setTimeout(resolve3, 100));
+      await new Promise((resolve4) => setTimeout(resolve4, 100));
     }
   }
 }
 
-// src/setup.ts
-import { spawnSync as spawnSync5 } from "child_process";
-import { accessSync, appendFileSync as appendFileSync2, chmodSync as chmodSync2, constants, cpSync, existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname5, resolve as resolve2 } from "path";
+// src/media-server.ts
+import { spawn as spawn4 } from "child_process";
+import { createSocket } from "dgram";
+import { createReadStream, existsSync as existsSync6, statSync as statSync2 } from "fs";
+import { createServer as createServer2 } from "http";
+import { dirname as dirname6, extname, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
+
+// src/input-bridge.ts
+import { spawn as spawn3 } from "child_process";
+var namedKeys = {
+  AltLeft: "Alt_L",
+  AltRight: "Alt_R",
+  ArrowDown: "Down",
+  ArrowLeft: "Left",
+  ArrowRight: "Right",
+  ArrowUp: "Up",
+  Backquote: "grave",
+  Backslash: "backslash",
+  Backspace: "BackSpace",
+  BracketLeft: "bracketleft",
+  BracketRight: "bracketright",
+  Comma: "comma",
+  ContextMenu: "Menu",
+  ControlLeft: "Control_L",
+  ControlRight: "Control_R",
+  Delete: "Delete",
+  End: "End",
+  Enter: "Return",
+  Equal: "equal",
+  Escape: "Escape",
+  Home: "Home",
+  Insert: "Insert",
+  MetaLeft: "Super_L",
+  MetaRight: "Super_R",
+  Minus: "minus",
+  PageDown: "Page_Down",
+  PageUp: "Page_Up",
+  Period: "period",
+  Quote: "apostrophe",
+  Semicolon: "semicolon",
+  ShiftLeft: "Shift_L",
+  ShiftRight: "Shift_R",
+  Slash: "slash",
+  Space: "space",
+  Tab: "Tab"
+};
+function xKey(code) {
+  if (/^Key[A-Z]$/.test(code)) return code.slice(-1).toLowerCase();
+  if (/^Digit[0-9]$/.test(code)) return code.slice(-1);
+  if (/^F(?:[1-9]|1[0-9]|2[0-4])$/.test(code)) return code;
+  if (/^Numpad[0-9]$/.test(code)) return `KP_${code.slice(-1)}`;
+  return namedKeys[code];
+}
+var InputBridge = class {
+  constructor(display2, width2, height2) {
+    this.display = display2;
+    this.width = width2;
+    this.height = height2;
+  }
+  display;
+  width;
+  height;
+  process;
+  pointer;
+  pointerFlush;
+  pressedButtons = /* @__PURE__ */ new Set();
+  pressedKeys = /* @__PURE__ */ new Set();
+  close() {
+    this.release();
+    this.process?.kill("SIGTERM");
+    this.process = void 0;
+  }
+  handle(message) {
+    if (message.type === "pointer") {
+      this.pointer = this.coordinates(message.x, message.y);
+      this.pointerFlush ??= setImmediate(() => this.flushPointer());
+      return;
+    }
+    if (message.type === "button") {
+      this.pointer = this.coordinates(message.x, message.y);
+      this.flushPointer();
+      const button = message.button === 0 ? 1 : message.button === 1 ? 2 : message.button === 2 ? 3 : 0;
+      if (!button) return;
+      if (message.down) {
+        if (this.pressedButtons.has(button)) return;
+        this.pressedButtons.add(button);
+        this.write(`mousedown ${button}`);
+      } else {
+        this.pressedButtons.delete(button);
+        this.write(`mouseup ${button}`);
+      }
+      return;
+    }
+    if (message.type === "wheel") {
+      this.pointer = this.coordinates(message.x, message.y);
+      this.flushPointer();
+      const vertical = Math.min(4, Math.max(1, Math.round(Math.abs(message.deltaY) / 80)));
+      const horizontal = Math.min(4, Math.max(1, Math.round(Math.abs(message.deltaX) / 80)));
+      if (Math.abs(message.deltaY) >= Math.abs(message.deltaX) && message.deltaY) {
+        for (let index = 0; index < vertical; index += 1) this.write(`mouseclick ${message.deltaY < 0 ? 4 : 5}`);
+      } else if (message.deltaX) {
+        for (let index = 0; index < horizontal; index += 1) this.write(`mouseclick ${message.deltaX < 0 ? 6 : 7}`);
+      }
+      return;
+    }
+    if (message.type === "key") {
+      const key = xKey(message.code);
+      if (!key || message.repeat) return;
+      if (message.down) {
+        if (this.pressedKeys.has(key)) return;
+        this.pressedKeys.add(key);
+        this.write(`keydown ${key}`);
+      } else {
+        this.pressedKeys.delete(key);
+        this.write(`keyup ${key}`);
+      }
+      return;
+    }
+    if (message.type === "release") this.release();
+  }
+  release() {
+    if (this.pointerFlush) clearImmediate(this.pointerFlush);
+    this.pointerFlush = void 0;
+    this.pointer = void 0;
+    for (const button of this.pressedButtons) this.write(`mouseup ${button}`);
+    for (const key of this.pressedKeys) this.write(`keyup ${key}`);
+    this.pressedButtons.clear();
+    this.pressedKeys.clear();
+  }
+  coordinates(x, y) {
+    return {
+      x: Math.round(Math.min(1, Math.max(0, x)) * (this.width - 1)),
+      y: Math.round(Math.min(1, Math.max(0, y)) * (this.height - 1))
+    };
+  }
+  flushPointer() {
+    if (this.pointerFlush) clearImmediate(this.pointerFlush);
+    this.pointerFlush = void 0;
+    if (!this.pointer) return;
+    this.write(`mousemove ${this.pointer.x} ${this.pointer.y}`);
+    this.pointer = void 0;
+  }
+  write(command) {
+    if (!this.process || this.process.exitCode !== null || this.process.stdin.destroyed) {
+      const child = spawn3("xte", [], {
+        env: { ...process.env, DISPLAY: this.display },
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      child.stdout.resume();
+      child.stderr.resume();
+      child.stdin.on("error", () => {
+      });
+      child.once("exit", () => {
+        if (this.process === child) this.process = void 0;
+      });
+      this.process = child;
+    }
+    this.process.stdin.write(`${command}
+`);
+  }
+};
+
+// src/media-protocol.ts
+var STREAM_PROTOCOL_VERSION = 1;
+var MEDIA_PACKET_HEADER_BYTES = 12;
+
+// src/rtp.ts
+function parseRtpPacket(data) {
+  if (data.length < 12 || data[0] >> 6 !== 2) return null;
+  if (data[1] >= 192 && data[1] <= 223) return null;
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const padding = Boolean(data[0] & 32);
+  const extension = Boolean(data[0] & 16);
+  let offset = 12 + (data[0] & 15) * 4;
+  if (offset > data.length) return null;
+  if (extension) {
+    if (offset + 4 > data.length) return null;
+    offset += 4 + view.getUint16(offset + 2) * 4;
+  }
+  const end = data.length - (padding ? data[data.length - 1] : 0);
+  if (offset >= end) return null;
+  return {
+    marker: Boolean(data[1] & 128),
+    payload: data.subarray(offset, end),
+    sequence: view.getUint16(2),
+    timestamp: view.getUint32(4)
+  };
+}
+var RtpClock = class {
+  constructor(rate) {
+    this.rate = rate;
+  }
+  rate;
+  base;
+  last;
+  wraps = 0;
+  reset() {
+    this.base = void 0;
+    this.last = void 0;
+    this.wraps = 0;
+  }
+  microseconds(timestamp) {
+    if (this.last !== void 0 && timestamp < this.last && this.last - timestamp > 2147483648) this.wraps += 1;
+    this.last = timestamp;
+    const extended = timestamp + this.wraps * 4294967296;
+    this.base ??= extended;
+    return Math.round((extended - this.base) * 1e6 / this.rate);
+  }
+};
+var startCode = new Uint8Array([0, 0, 0, 1]);
+var H264RtpAssembler = class {
+  clock = new RtpClock(9e4);
+  chunks = [];
+  key = false;
+  timestamp;
+  sequence;
+  fragmentType;
+  damaged = false;
+  clearFrame() {
+    this.chunks = [];
+    this.key = false;
+    this.timestamp = void 0;
+    this.sequence = void 0;
+    this.fragmentType = void 0;
+    this.damaged = false;
+  }
+  reset() {
+    this.clock.reset();
+    this.clearFrame();
+  }
+  push(packet) {
+    if (this.timestamp !== void 0 && packet.timestamp !== this.timestamp) {
+      this.clearFrame();
+    }
+    this.timestamp ??= packet.timestamp;
+    if (this.sequence !== void 0 && packet.sequence !== (this.sequence + 1) % 65536) this.damaged = true;
+    this.sequence = packet.sequence;
+    const type = packet.payload[0] & 31;
+    if (this.damaged) {
+    } else if (type > 0 && type < 24 && this.fragmentType === void 0) {
+      this.chunks.push(startCode, packet.payload);
+      this.key ||= type === 5;
+    } else if (type === 24 && this.fragmentType === void 0) {
+      let offset2 = 1;
+      let nals = 0;
+      while (offset2 < packet.payload.length) {
+        if (offset2 + 2 > packet.payload.length) {
+          this.damaged = true;
+          break;
+        }
+        const size = packet.payload[offset2] * 256 + packet.payload[offset2 + 1];
+        offset2 += 2;
+        if (!size || offset2 + size > packet.payload.length) {
+          this.damaged = true;
+          break;
+        }
+        const nal = packet.payload.subarray(offset2, offset2 + size);
+        this.chunks.push(startCode, nal);
+        this.key ||= (nal[0] & 31) === 5;
+        offset2 += size;
+        nals += 1;
+      }
+      if (!nals) this.damaged = true;
+    } else if (type === 28 && packet.payload.length >= 3) {
+      const fragmentType = packet.payload[1] & 31;
+      const start = Boolean(packet.payload[1] & 128);
+      const end = Boolean(packet.payload[1] & 64);
+      if (start && !end && this.fragmentType === void 0) {
+        this.fragmentType = fragmentType;
+        this.chunks.push(startCode, new Uint8Array([packet.payload[0] & 224 | fragmentType]));
+        this.key ||= fragmentType === 5;
+      } else if (!start && this.fragmentType === fragmentType) {
+        if (end) this.fragmentType = void 0;
+      } else {
+        this.damaged = true;
+      }
+      if (!this.damaged) this.chunks.push(packet.payload.subarray(2));
+    } else this.damaged = true;
+    if (!packet.marker) return null;
+    if (this.damaged || this.fragmentType !== void 0 || this.chunks.length === 0) {
+      this.clearFrame();
+      return null;
+    }
+    const length = this.chunks.reduce((total, chunk) => total + chunk.length, 0);
+    const data = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of this.chunks) {
+      data.set(chunk, offset);
+      offset += chunk.length;
+    }
+    const frame = { data, key: this.key, timestamp: this.clock.microseconds(packet.timestamp) };
+    this.clearFrame();
+    return frame;
+  }
+};
+
+// src/media-server.ts
+import WebSocket2, { WebSocketServer } from "ws";
+var width = Number.parseInt(process.env.REPLICAS_DESKTOP_WIDTH || String(DESKTOP_VIEWER_WIDTH), 10);
+var height = Number.parseInt(process.env.REPLICAS_DESKTOP_HEIGHT || String(DESKTOP_VIEWER_HEIGHT), 10);
+var fps = Number.parseInt(process.env.REPLICAS_DESKTOP_STREAM_FPS || "60", 10);
+var keyframeInterval = fps;
+var port = Number.parseInt(process.env.REPLICAS_DESKTOP_STREAM_PORT || String(DESKTOP_STREAM_PORT), 10);
+var display = process.env.REPLICAS_DESKTOP_DISPLAY?.replace(/^([^:])/, ":$1") || ":99";
+var videoCodec = "avc1.42E02A";
+var config = {
+  type: "config",
+  protocolVersion: STREAM_PROTOCOL_VERSION,
+  width,
+  height,
+  fps,
+  videoCodec,
+  audioCodec: "opus",
+  audioSampleRate: 48e3,
+  audioChannels: 2
+};
+var packageRoot = resolve2(dirname6(fileURLToPath(import.meta.url)), "..");
+var webroot = process.env.REPLICAS_DESKTOP_STREAM_WEBROOT || resolve2(packageRoot, "assets", "desktop");
+var contentTypes = {
+  ".css": "text/css; charset=utf-8",
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".woff2": "font/woff2"
+};
+function bindUdp() {
+  return new Promise((resolveSocket, reject) => {
+    const socket = createSocket("udp4");
+    socket.once("error", reject);
+    socket.bind(0, "127.0.0.1", () => {
+      socket.off("error", reject);
+      socket.setRecvBufferSize(4 * 1024 * 1024);
+      resolveSocket(socket);
+    });
+  });
+}
+function mediaPacket(kind, timestamp, payload) {
+  const header = Buffer.alloc(MEDIA_PACKET_HEADER_BYTES);
+  header[0] = kind;
+  header[1] = STREAM_PROTOCOL_VERSION;
+  header.writeBigUInt64BE(BigInt(Math.max(0, timestamp)), 4);
+  return Buffer.concat([header, payload]);
+}
+function validInput(value) {
+  if (!value || typeof value !== "object" || !("type" in value) || typeof value.type !== "string") return false;
+  if (value.type === "release") return true;
+  if (value.type === "stats") return "videoFps" in value && typeof value.videoFps === "number" && Number.isFinite(value.videoFps) && "audioPacketsPerSecond" in value && typeof value.audioPacketsPerSecond === "number" && Number.isFinite(value.audioPacketsPerSecond) && "decodeQueue" in value && typeof value.decodeQueue === "number" && Number.isFinite(value.decodeQueue) && "rttMs" in value && typeof value.rttMs === "number" && Number.isFinite(value.rttMs);
+  if (value.type === "ping") return "sentAt" in value && typeof value.sentAt === "number";
+  if (value.type === "key") return "code" in value && typeof value.code === "string" && value.code.length < 40 && "down" in value && typeof value.down === "boolean";
+  if (!("x" in value) || !("y" in value) || typeof value.x !== "number" || typeof value.y !== "number") return false;
+  if (value.type === "pointer") return true;
+  if (value.type === "button") return "button" in value && typeof value.button === "number" && "down" in value && typeof value.down === "boolean";
+  return value.type === "wheel" && "deltaX" in value && typeof value.deltaX === "number" && "deltaY" in value && typeof value.deltaY === "number";
+}
+async function runMediaServer() {
+  if (![width, height, fps, port].every((value) => Number.isInteger(value) && value > 0)) throw new Error("Invalid desktop stream dimensions, frame rate, or port");
+  const videoSocket = await bindUdp();
+  const audioSocket = await bindUdp();
+  const videoPort = videoSocket.address().port;
+  const audioPort = audioSocket.address().port;
+  const videoAssembler = new H264RtpAssembler();
+  const audioClock = new RtpClock(48e3);
+  const clients = /* @__PURE__ */ new Map();
+  let encoder;
+  let encoderRestart;
+  let encoderStop;
+  let lastVideoAt = 0;
+  let lastAudioAt = 0;
+  let videoFrames = 0;
+  let audioPackets = 0;
+  let videoBytes = 0;
+  let audioBytes = 0;
+  const broadcast = (packet, keyframe = false) => {
+    for (const [client, state] of clients) {
+      if (client.readyState !== WebSocket2.OPEN) continue;
+      if (client.bufferedAmount > 4 * 1024 * 1024) {
+        client.close(1013, "stream client is too slow");
+        continue;
+      }
+      if (!keyframe && (state.waitingForKeyframe || client.bufferedAmount > 512 * 1024)) {
+        state.waitingForKeyframe = true;
+        continue;
+      }
+      if (keyframe) state.waitingForKeyframe = false;
+      client.send(packet, { binary: true });
+    }
+  };
+  videoSocket.on("message", (data) => {
+    const rtp = parseRtpPacket(data);
+    if (!rtp) return;
+    const frame = videoAssembler.push(rtp);
+    if (!frame) return;
+    lastVideoAt = Date.now();
+    videoFrames += 1;
+    videoBytes += frame.data.byteLength;
+    const packet = mediaPacket(frame.key ? 1 /* VideoKey */ : 2 /* VideoDelta */, frame.timestamp, frame.data);
+    broadcast(packet, frame.key);
+  });
+  audioSocket.on("message", (data) => {
+    const rtp = parseRtpPacket(data);
+    if (!rtp) return;
+    lastAudioAt = Date.now();
+    audioPackets += 1;
+    audioBytes += rtp.payload.byteLength;
+    broadcast(mediaPacket(3 /* Audio */, audioClock.microseconds(rtp.timestamp), rtp.payload));
+  });
+  const startEncoder = () => {
+    clearTimeout(encoderStop);
+    if (encoder && encoder.exitCode === null) return;
+    clearTimeout(encoderRestart);
+    videoAssembler.reset();
+    audioClock.reset();
+    const videoBitrate = process.env.REPLICAS_DESKTOP_STREAM_VIDEO_BITRATE || "12M";
+    encoder = spawn4("ffmpeg", [
+      "-hide_banner",
+      "-loglevel",
+      "warning",
+      "-fflags",
+      "nobuffer",
+      "-flags",
+      "low_delay",
+      "-thread_queue_size",
+      "1024",
+      "-f",
+      "x11grab",
+      "-draw_mouse",
+      "0",
+      "-framerate",
+      String(fps),
+      "-video_size",
+      `${width}x${height}`,
+      "-use_wallclock_as_timestamps",
+      "1",
+      "-i",
+      `${display}.0`,
+      "-thread_queue_size",
+      "1024",
+      "-f",
+      "pulse",
+      "-fragment_size",
+      "2048",
+      "-use_wallclock_as_timestamps",
+      "1",
+      "-i",
+      process.env.REPLICAS_DESKTOP_STREAM_AUDIO_SOURCE || "default",
+      "-map",
+      "0:v:0",
+      "-an",
+      "-c:v",
+      "libx264",
+      "-preset",
+      "ultrafast",
+      "-tune",
+      "zerolatency",
+      "-profile:v",
+      "baseline",
+      "-level:v",
+      "4.2",
+      "-pix_fmt",
+      "yuv420p",
+      "-bf",
+      "0",
+      "-g",
+      String(keyframeInterval),
+      "-keyint_min",
+      String(keyframeInterval),
+      "-sc_threshold",
+      "0",
+      "-crf",
+      "18",
+      "-maxrate",
+      videoBitrate,
+      "-bufsize",
+      "1M",
+      "-x264-params",
+      `repeat-headers=1:sliced-threads=1:slices=4:keyint=${keyframeInterval}:min-keyint=${keyframeInterval}:scenecut=0`,
+      "-fps_mode",
+      "passthrough",
+      "-flush_packets",
+      "1",
+      "-f",
+      "rtp",
+      "-payload_type",
+      "96",
+      `rtp://127.0.0.1:${videoPort}?pkt_size=1200&connect=1&rtcpport=${videoPort}`,
+      "-map",
+      "1:a:0",
+      "-vn",
+      "-af",
+      "aresample=async=1:first_pts=0",
+      "-c:a",
+      "libopus",
+      "-application",
+      "lowdelay",
+      "-frame_duration",
+      "20",
+      "-b:a",
+      "128k",
+      "-ar",
+      "48000",
+      "-ac",
+      "2",
+      "-flush_packets",
+      "1",
+      "-f",
+      "rtp",
+      "-payload_type",
+      "111",
+      `rtp://127.0.0.1:${audioPort}?pkt_size=1200&connect=1&rtcpport=${audioPort}`
+    ], { env: { ...process.env, DISPLAY: display }, stdio: ["ignore", "ignore", "pipe"] });
+    encoder.stderr?.on("data", (chunk) => process.stderr.write(`[desktop-stream] ${chunk}`));
+    encoder.once("exit", (code, signal) => {
+      encoder = void 0;
+      if (clients.size > 0) {
+        process.stderr.write(`[desktop-stream] encoder exited (${signal || code}); restarting
+`);
+        encoderRestart = setTimeout(startEncoder, 500);
+      }
+    });
+  };
+  const stopEncoderSoon = () => {
+    clearTimeout(encoderStop);
+    encoderStop = setTimeout(() => {
+      if (clients.size > 0) return;
+      encoder?.kill("SIGTERM");
+      encoder = void 0;
+    }, 5e3);
+  };
+  const httpServer = createServer2((request, response) => {
+    const url = new URL(request.url || "/", "http://localhost");
+    if (url.pathname === "/health") {
+      response.setHeader("content-type", "application/json");
+      response.end(JSON.stringify({
+        clients: clients.size,
+        encoder: Boolean(encoder && encoder.exitCode === null),
+        lastVideoFrameMsAgo: lastVideoAt ? Date.now() - lastVideoAt : null,
+        lastAudioPacketMsAgo: lastAudioAt ? Date.now() - lastAudioAt : null,
+        videoFrames,
+        audioPackets,
+        videoBytes,
+        audioBytes,
+        clientStats: [...clients.values()].flatMap((client) => client.stats ? [client.stats] : []),
+        width,
+        height,
+        fps
+      }));
+      return;
+    }
+    const requested = url.pathname === "/" ? "stream-index.html" : url.pathname.slice(1);
+    const path = resolve2(webroot, requested);
+    if (!path.startsWith(resolve2(webroot) + "/") || !existsSync6(path) || !statSync2(path).isFile()) {
+      response.statusCode = 404;
+      response.end("Not found");
+      return;
+    }
+    response.setHeader("cache-control", "no-store");
+    response.setHeader("content-type", contentTypes[extname(path)] || "application/octet-stream");
+    createReadStream(path).pipe(response);
+  });
+  const webSocketServer = new WebSocketServer({ noServer: true, maxPayload: 16 * 1024 });
+  httpServer.on("upgrade", (request, socket, head) => {
+    if (new URL(request.url || "/", "http://localhost").pathname !== "/stream") {
+      socket.destroy();
+      return;
+    }
+    webSocketServer.handleUpgrade(request, socket, head, (client) => webSocketServer.emit("connection", client, request));
+  });
+  webSocketServer.on("connection", (client) => {
+    clients.set(client, { waitingForKeyframe: true, input: new InputBridge(display, width, height) });
+    client.send(JSON.stringify(config));
+    startEncoder();
+    client.on("message", (raw, binary) => {
+      if (binary) return;
+      let message;
+      try {
+        message = JSON.parse(raw.toString());
+      } catch {
+        return;
+      }
+      if (!validInput(message)) return;
+      if (message.type === "ping") client.send(JSON.stringify({ type: "pong", sentAt: message.sentAt }));
+      else if (message.type === "stats") {
+        const state = clients.get(client);
+        if (!state) return;
+        state.stats = {
+          videoFps: message.videoFps,
+          audioPacketsPerSecond: message.audioPacketsPerSecond,
+          decodeQueue: message.decodeQueue,
+          rttMs: message.rttMs
+        };
+      } else clients.get(client)?.input.handle(message);
+    });
+    client.once("close", () => {
+      clients.get(client)?.input.close();
+      clients.delete(client);
+      if (clients.size === 0) stopEncoderSoon();
+    });
+  });
+  await new Promise((resolveServer, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(port, "0.0.0.0", () => {
+      httpServer.off("error", reject);
+      console.log(`replicas desktop stream listening on ${port}`);
+      resolveServer();
+    });
+  });
+  await new Promise((resolveShutdown) => {
+    let closing = false;
+    const close = () => {
+      if (closing) return;
+      closing = true;
+      clearTimeout(encoderRestart);
+      clearTimeout(encoderStop);
+      for (const [client, state] of clients) {
+        state.input.close();
+        client.close(1001, "server shutting down");
+      }
+      encoder?.kill("SIGTERM");
+      videoSocket.close();
+      audioSocket.close();
+      webSocketServer.close();
+      httpServer.close(() => resolveShutdown());
+    };
+    process.once("SIGTERM", close);
+    process.once("SIGINT", close);
+  });
+}
+
+// src/setup.ts
+import { spawnSync as spawnSync6 } from "child_process";
+import { accessSync, chmodSync as chmodSync2, constants, cpSync, existsSync as existsSync7, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname7, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var dependencies = [
   ["bash", "bash"],
   ["Node.js", "node"],
@@ -3133,6 +3806,9 @@ var dependencies = [
   ["tint2", "tint2"],
   ["picom", "picom"],
   ["ffmpeg", "ffmpeg"],
+  ["PulseAudio", "pulseaudio"],
+  ["PulseAudio control", "pactl"],
+  ["X automation", "xte"],
   ["x11vnc", "x11vnc"],
   ["websockify", "websockify"],
   ["Google Chrome", "google-chrome-stable"],
@@ -3169,13 +3845,13 @@ StandardError=inherit
 WantedBy=multi-user.target
 `;
 function commandVersion(command) {
-  const result = spawnSync5(command, ["--version"], { encoding: "utf8" });
+  const result = spawnSync6(command, ["--version"], { encoding: "utf8" });
   return `${result.stdout || result.stderr}`.trim().split("\n")[0]?.slice(0, 200) || "available";
 }
 function hasCommand(command) {
   return (process.env.PATH ?? "").split(":").some((directory) => {
     try {
-      accessSync(resolve2(directory, command), constants.X_OK);
+      accessSync(resolve3(directory, command), constants.X_OK);
       return true;
     } catch {
       return false;
@@ -3195,7 +3871,7 @@ function setupComputer(options = {}) {
     }
   }
   if (found.ffmpeg) {
-    const encoders = spawnSync5("ffmpeg", ["-hide_banner", "-encoders"], { encoding: "utf8" });
+    const encoders = spawnSync6("ffmpeg", ["-hide_banner", "-encoders"], { encoding: "utf8" });
     if (!`${encoders.stdout}${encoders.stderr}`.includes("libx264")) {
       missing.push("ffmpeg encoder libx264");
       console.error("\u2717 ffmpeg encoder libx264 is unavailable");
@@ -3203,47 +3879,55 @@ function setupComputer(options = {}) {
       console.log("\u2713 ffmpeg encoder libx264");
     }
   }
-  const noVncRoot = ["/usr/share/novnc", "/usr/share/novnc-common"].find(existsSync5);
-  if (!noVncRoot) {
-    missing.push("noVNC web root");
-    console.error("\u2717 noVNC web root \u2014 /usr/share/novnc and /usr/share/novnc-common are missing");
+  const noVncPackageRoot = dirname7(dirname7(fileURLToPath2(import.meta.resolve("@novnc/novnc"))));
+  const noVncCore = resolve3(noVncPackageRoot, "core");
+  const noVncVendor = resolve3(noVncPackageRoot, "vendor");
+  if (!existsSync7(noVncCore) || !existsSync7(noVncVendor)) {
+    missing.push("bundled noVNC client");
+    console.error("\u2717 bundled noVNC client");
   } else {
-    console.log(`\u2713 noVNC web root (${noVncRoot})`);
+    console.log("\u2713 bundled noVNC client");
   }
-  if (spawnSync5("id", ["user"], { stdio: "ignore" }).status !== 0) {
+  if (spawnSync6("id", ["user"], { stdio: "ignore" }).status !== 0) {
     missing.push("workspace user account");
     console.error("\u2717 workspace user account \u2014 user does not exist");
   } else {
     console.log("\u2713 workspace user account");
   }
   if (missing.length > 0) throw new Error(`Missing ${missing.length} computer-use requirement${missing.length === 1 ? "" : "s"}: ${missing.join(", ")}`);
-  if (!noVncRoot) throw new Error("noVNC web root is unavailable");
   if (options.checkOnly) return;
   if (process.getuid?.() !== 0) throw new Error("replicas-computer setup must run as root to install runtime files");
-  const packageRoot = resolve2(dirname5(fileURLToPath(import.meta.url)), "..");
-  const assets = resolve2(packageRoot, "assets", "desktop");
-  if (!existsSync5(assets)) throw new Error(`Computer-use assets are missing from ${assets}`);
-  mkdirSync5("/usr/local/share/replicas/desktop", { recursive: true });
+  const packageRoot2 = resolve3(dirname7(fileURLToPath2(import.meta.url)), "..");
+  const assets = resolve3(packageRoot2, "assets", "desktop");
+  if (!existsSync7(assets)) throw new Error(`Computer-use assets are missing from ${assets}`);
+  mkdirSync6("/usr/local/share/replicas/desktop", { recursive: true });
   cpSync(assets, "/usr/local/share/replicas/desktop", { recursive: true, force: true });
-  cpSync(resolve2(assets, "start-services.sh"), "/usr/local/bin/replicas-start-desktop-services", { force: true });
-  cpSync(resolve2(assets, "replicas-chrome"), "/usr/local/bin/replicas-chrome", { force: true });
-  cpSync(resolve2(assets, "replicas-chrome.desktop"), "/usr/share/applications/replicas-chrome.desktop", { force: true });
+  const viewerRoot = "/usr/local/share/replicas/desktop/novnc";
+  mkdirSync6(viewerRoot, { recursive: true });
+  cpSync(noVncCore, resolve3(viewerRoot, "core"), { recursive: true, force: true });
+  cpSync(noVncVendor, resolve3(viewerRoot, "vendor"), { recursive: true, force: true });
+  for (const file of ["novnc-index.html", "viewer.css", "viewer-icon.svg", "geist-mono.woff2"]) {
+    cpSync(resolve3(assets, file), resolve3(viewerRoot, file === "novnc-index.html" ? "index.html" : file), { force: true });
+  }
+  cpSync(resolve3(packageRoot2, "dist", "viewer.js"), resolve3(viewerRoot, "viewer.js"), { force: true });
+  const streamRoot = "/usr/local/share/replicas/desktop/stream";
+  mkdirSync6(streamRoot, { recursive: true });
+  for (const file of ["stream-index.html", "stream-viewer.css", "viewer-icon.svg", "geist-mono.woff2"]) {
+    cpSync(resolve3(assets, file), resolve3(streamRoot, file), { force: true });
+  }
+  cpSync(resolve3(packageRoot2, "dist", "stream-viewer.js"), resolve3(streamRoot, "stream-viewer.js"), { force: true });
+  cpSync(resolve3(assets, "start-services.sh"), "/usr/local/bin/replicas-start-desktop-services", { force: true });
+  cpSync(resolve3(assets, "replicas-chrome"), "/usr/local/bin/replicas-chrome", { force: true });
+  cpSync(resolve3(assets, "replicas-chrome.desktop"), "/usr/share/applications/replicas-chrome.desktop", { force: true });
   chmodSync2("/usr/local/bin/replicas-start-desktop-services", 493);
   chmodSync2("/usr/local/bin/replicas-chrome", 493);
-  cpSync(resolve2(assets, "novnc-index.html"), resolve2(noVncRoot, "index.html"), { force: true });
-  cpSync(resolve2(assets, "geist-mono.woff2"), resolve2(noVncRoot, "geist-mono.woff2"), { force: true });
-  const noVncStyles = resolve2(noVncRoot, "app", "styles", "base.css");
-  const styleOverride = "\n#noVNC_status { display: none !important; }\n#noVNC_control_bar_anchor { display: none !important; }\n";
-  if (existsSync5(noVncStyles) && !readFileSync4(noVncStyles, "utf8").includes("#noVNC_status { display: none !important; }")) {
-    appendFileSync2(noVncStyles, styleOverride);
-  }
-  writeFileSync4("/etc/systemd/system/replicas-computer.service", serviceUnit, { mode: 420 });
-  if (existsSync5("/run/systemd/system")) {
-    const reload = spawnSync5("systemctl", ["daemon-reload"], { stdio: "pipe" });
+  writeFileSync5("/etc/systemd/system/replicas-computer.service", serviceUnit, { mode: 420 });
+  if (existsSync7("/run/systemd/system")) {
+    const reload = spawnSync6("systemctl", ["daemon-reload"], { stdio: "pipe" });
     if (reload.status !== 0) throw new Error(`Failed to reload systemd: ${reload.stderr?.toString().trim() || `exit ${reload.status}`}`);
   }
-  mkdirSync5("/usr/local/share/replicas-computer", { recursive: true });
-  writeFileSync4("/usr/local/share/replicas-computer/install.json", `${JSON.stringify({
+  mkdirSync6("/usr/local/share/replicas-computer", { recursive: true });
+  writeFileSync5("/usr/local/share/replicas-computer/install.json", `${JSON.stringify({
     version: COMPUTER_USE_VERSION,
     protocolVersion: COMPUTER_USE_PROTOCOL_VERSION,
     dependencies: found
@@ -3273,6 +3957,11 @@ async function main() {
     await runComputerDaemon();
     return;
   }
+  if (argv[0] === "stream") {
+    if (argv.length > 1) throw new Error(`Unknown stream option: ${argv[1]}`);
+    await runMediaServer();
+    return;
+  }
   const direct = argv[0] === "--direct";
   const commandArgv = direct ? argv.slice(1) : argv;
   const local = commandArgv.length === 0 || ["--help", "-h", "--version", "-V", "help"].includes(commandArgv[0]);