replicas-cli 0.2.328 → 0.2.329

package/dist/index.mjs

@@ -8086,7 +8086,7 @@ Anything else gets \`exec\`'d verbatim, so \`replicas computer launch xeyes\` wo
 When opening a known page, prefer passing the URL directly: \`replicas computer launch chrome http://localhost:3000/\`.
 
 ### \`replicas computer record start <path> [--fps N]\`
-Starts an ffmpeg screen recorder. Output is a fragmented MP4 (still playable if the workspace dies mid-record). Default 60fps; drop to 30 if the workspace is CPU-constrained.
+Starts an ffmpeg screen recorder. Output is post-processed when stopped: action windows stay at normal speed, idle gaps accelerate, click moments get eased camera zoom, and a synthetic cursor animates between logged mouse positions. The raw capture is fragmented MP4 while active (still playable if the workspace dies mid-record). Default 60fps; drop to 30 if the workspace is CPU-constrained.
 
 Only one recording at a time. Re-running \`start\` while one is active fails - call \`stop\` first.
 
@@ -9537,7 +9537,7 @@ var HOOK_EXEC_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
 var REPLICAS_CONFIG_FILENAMES = ["replicas.json", "replicas.yaml", "replicas.yml"];
 
 // ../shared/src/cli-version.ts
-var CLI_VERSION = "0.2.328";
+var CLI_VERSION = "0.2.329";
 
 // ../shared/src/engine/environment.ts
 var DESKTOP_NOVNC_PORT = 6080;
@@ -14481,12 +14481,17 @@ async function mediaListCommand(options) {
   }
 }
 
-// src/commands/computer.ts
-import { spawn as spawn3, spawnSync } from "child_process";
+// src/commands/computer/index.ts
+import { spawn as spawn4, spawnSync as spawnSync3 } from "child_process";
 import { createHash as createHash2 } from "crypto";
-import { closeSync, copyFileSync, existsSync, mkdirSync, openSync, readFileSync, readSync, rmSync, writeFileSync } from "fs";
-import { dirname, isAbsolute, resolve } from "path";
+import { closeSync, copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync2, readSync, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2 } from "path";
 import chalk20 from "chalk";
+
+// src/commands/computer/desktop.ts
+import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { isAbsolute, resolve } from "path";
 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;
@@ -14547,6 +14552,23 @@ function getDisplayDimensions() {
   if (!match) fail("could not read display dimensions from xdpyinfo");
   return { width: Number.parseInt(match[1], 10), height: Number.parseInt(match[2], 10) };
 }
+function getMouseLocation() {
+  const out = tryDisplayCmd("xdotool", ["getmouselocation", "--shell"]);
+  if (!out) return null;
+  const values = Object.fromEntries(
+    out.split("\n").map((line) => {
+      const [key, value] = line.split("=");
+      return [key.toLowerCase(), Number.parseInt(value, 10)];
+    })
+  );
+  if (!Number.isFinite(values.x) || !Number.isFinite(values.y)) return null;
+  return {
+    x: values.x,
+    y: values.y,
+    screen: Number.isFinite(values.screen) ? values.screen : 0,
+    window: Number.isFinite(values.window) ? values.window : 0
+  };
+}
 function parseScreenCoord(value, label, size) {
   if (value.endsWith("%")) {
     const rawPct = value.slice(0, -1);
@@ -14562,8 +14584,655 @@ function parseScreenCoord(value, label, size) {
 function resolvePath(p) {
   return isAbsolute(p) ? p : resolve(process.cwd(), p);
 }
+function configuredDesktopDimensions() {
+  const width = parseInt(process.env.REPLICAS_DESKTOP_WIDTH || String(DESKTOP_VIEWER_WIDTH), 10);
+  const height = parseInt(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 };
+}
+function clamp(n, min, max) {
+  return Math.min(max, Math.max(min, n));
+}
+var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+
+// src/commands/computer/recording.ts
+import { spawn as spawn3 } from "child_process";
+import { appendFileSync, existsSync as existsSync2, mkdirSync, readFileSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname } from "path";
+
+// src/commands/computer/recording/render.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { copyFileSync, rmSync, writeFileSync } from "fs";
+
+// src/commands/computer/recording/config.ts
+var cameraMotion = {
+  clickLeadSeconds: 1.2,
+  clickTailSeconds: 0.5,
+  actionLeadSeconds: 0.9,
+  clickZoom: 1.24,
+  closeClickOutputGapSeconds: 6,
+  clickMoveSeconds: 1.2,
+  returnSeconds: 1,
+  minSegmentSeconds: 0.05
+};
+var cursorMotion = {
+  minMoveSeconds: 0.38,
+  maxMoveSeconds: 1.7,
+  speedPxPerSecond: 700,
+  defaultLeadSeconds: 0.16,
+  clickShrinkSeconds: 0.08,
+  clickGrowSeconds: 0.14,
+  clickDwellGapStartSeconds: 0.75,
+  clickDwellFullGapSeconds: 3.2,
+  clickMinDwellSeconds: 0.12,
+  clickMaxDwellSeconds: 1.15,
+  maxDwellGapShare: 0.45,
+  dragLeadSeconds: 0.55,
+  maxKeyframes: 120
+};
+var cursorStyle = {
+  size: 30,
+  clickSize: 24
+};
+
+// src/commands/computer/recording/ffmpeg-expressions.ts
+function expressionNumber(n) {
+  return Number.isInteger(n) ? String(n) : n.toFixed(3);
+}
+function mixNumber(from, to, progress) {
+  return from + (to - from) * progress;
+}
+function easeInOutSmootherNumber(progress) {
+  const p = clamp(progress, 0, 1);
+  return p * p * p * (p * (p * 6 - 15) + 10);
+}
+function easeInOutSmootherExpression(progress) {
+  const p = `(${progress})`;
+  return `${p}*${p}*${p}*(${p}*(${p}*6-15)+10)`;
+}
+function progressOverTime(timeExpression, seconds) {
+  return easeInOutSmootherExpression(`min(max((${timeExpression})/${seconds.toFixed(3)}\\,0)\\,1)`);
+}
+function progressBetween(start, duration) {
+  return easeInOutSmootherExpression(`min(max((t-${start.toFixed(3)})/${duration.toFixed(3)}\\,0)\\,1)`);
+}
+function mixExpression(from, to, progress) {
+  return `${expressionNumber(from)}+(${expressionNumber(to - from)})*${progress}`;
+}
+function cropOrigin(point, zoom, size) {
+  return clamp(point * zoom - size / 2, 0, size * zoom - size);
+}
+function easedCropOrigin(fromPoint, toPoint, fromZoom, toZoom, size, progress) {
+  return mixExpression(
+    cropOrigin(fromPoint, fromZoom, size),
+    cropOrigin(toPoint, toZoom, size),
+    progress
+  );
+}
+function betweenExpression(start, end) {
+  return `between(t\\,${start.toFixed(3)}\\,${end.toFixed(3)})`;
+}
+
+// src/commands/computer/recording/timeline.ts
+function centerOf(size) {
+  return { x: size.width / 2, y: size.height / 2 };
+}
+function actionPoint(action, size) {
+  const x = action.toX ?? action.x ?? size.width / 2;
+  const y = action.toY ?? action.y ?? size.height / 2;
+  return { x: clamp(x, 0, size.width), y: clamp(y, 0, size.height) };
+}
+function idleSpeed(duration) {
+  if (duration < 1.2) return 1;
+  return clamp(1 + Math.log1p(duration - 0.8) * 1.8, 1.5, 5);
+}
+function renderedGapSeconds(duration) {
+  return duration / idleSpeed(duration);
+}
+function timelineActions(actions) {
+  return actions.filter((action) => action.type !== "key" && action.type !== "move");
+}
+function actionWindow(action, duration) {
+  const shouldZoom = action.type === "click";
+  const at = clamp(action.atMs / 1e3, 0, duration);
+  const start = clamp(at - (shouldZoom ? cameraMotion.clickLeadSeconds : cameraMotion.actionLeadSeconds), 0, duration);
+  const tail = shouldZoom ? cameraMotion.clickTailSeconds : action.type === "type" ? 1.5 : 0.9;
+  return { start, end: clamp(at + tail, start, duration), shouldZoom };
+}
+function nextClickStart(actions, index, duration) {
+  const nextClick = actions.slice(index + 1).find((candidate) => candidate.type === "click");
+  return nextClick ? clamp(nextClick.atMs / 1e3 - cameraMotion.clickLeadSeconds, 0, duration) : null;
+}
+function shouldPreserveZoom(nextStart, cursor, lastZoom) {
+  return lastZoom > 1 && nextStart !== null && nextStart > cursor && renderedGapSeconds(nextStart - cursor) <= cameraMotion.closeClickOutputGapSeconds;
+}
+function fullFrameSegment(duration, size) {
+  const center = centerOf(size);
+  return {
+    start: 0,
+    end: duration,
+    speed: 1,
+    motionSeconds: cameraMotion.returnSeconds,
+    fromZoom: 1,
+    zoom: 1,
+    fromX: center.x,
+    fromY: center.y,
+    ...center
+  };
+}
+function buildRecordingSegments(actions, duration, size) {
+  const actionsForTimeline = timelineActions(actions);
+  if (actionsForTimeline.length === 0) return [fullFrameSegment(duration, size)];
+  const center = centerOf(size);
+  const segments = [];
+  let cursor = 0;
+  let lastPoint = center;
+  let lastZoom = 1;
+  for (let i = 0; i < actionsForTimeline.length; i++) {
+    const action = actionsForTimeline[i];
+    const { start, end, shouldZoom } = actionWindow(action, duration);
+    const preserveZoom = !shouldZoom && shouldPreserveZoom(nextClickStart(actionsForTimeline, i, duration), cursor, lastZoom);
+    const point = shouldZoom ? actionPoint(action, size) : preserveZoom ? lastPoint : center;
+    const zoom = shouldZoom ? cameraMotion.clickZoom : preserveZoom ? lastZoom : 1;
+    if (start > cursor + cameraMotion.minSegmentSeconds) {
+      const gap = start - cursor;
+      const speed = idleSpeed(gap);
+      const bridgeZoom = shouldZoom && lastZoom > 1 && renderedGapSeconds(gap) <= cameraMotion.closeClickOutputGapSeconds;
+      segments.push({
+        start: cursor,
+        end: start,
+        speed,
+        motionSeconds: bridgeZoom ? Math.min(cameraMotion.clickMoveSeconds, Math.max(0.18, gap / speed)) : cameraMotion.returnSeconds,
+        fromZoom: lastZoom,
+        zoom: bridgeZoom ? cameraMotion.clickZoom : zoom,
+        fromX: lastPoint.x,
+        fromY: lastPoint.y,
+        ...point
+      });
+      lastZoom = bridgeZoom ? cameraMotion.clickZoom : zoom;
+      lastPoint = point;
+    }
+    const actionStart = Math.max(cursor, start);
+    if (end > actionStart + cameraMotion.minSegmentSeconds) {
+      segments.push({
+        start: actionStart,
+        end,
+        speed: 1,
+        motionSeconds: shouldZoom ? cameraMotion.clickMoveSeconds : cameraMotion.returnSeconds,
+        fromZoom: lastZoom,
+        zoom,
+        fromX: lastPoint.x,
+        fromY: lastPoint.y,
+        ...point
+      });
+      cursor = end;
+      lastZoom = zoom;
+    }
+    lastPoint = point;
+  }
+  if (duration > cursor + cameraMotion.minSegmentSeconds) {
+    segments.push({
+      start: cursor,
+      end: duration,
+      speed: idleSpeed(duration - cursor),
+      motionSeconds: cameraMotion.returnSeconds,
+      fromZoom: lastZoom,
+      zoom: 1,
+      fromX: lastPoint.x,
+      fromY: lastPoint.y,
+      ...center
+    });
+  }
+  return segments.filter((segment) => segment.end > segment.start + cameraMotion.minSegmentSeconds);
+}
+
+// src/commands/computer/recording/cursor.ts
+var cursorHotspotRatio = { x: 8 / 32, y: 4 / 32 };
+function cursorAssets(stamp) {
+  return {
+    path: `/tmp/replicas-cursor-${stamp}.svg`,
+    size: cursorStyle.size
+  };
+}
+function clickDwellSeconds(gapSeconds) {
+  if (gapSeconds <= cursorMotion.clickDwellGapStartSeconds) return cursorMotion.defaultLeadSeconds;
+  const progress = (gapSeconds - cursorMotion.clickDwellGapStartSeconds) / (cursorMotion.clickDwellFullGapSeconds - cursorMotion.clickDwellGapStartSeconds);
+  const dwell = mixNumber(
+    cursorMotion.clickMinDwellSeconds,
+    cursorMotion.clickMaxDwellSeconds,
+    easeInOutSmootherNumber(progress)
+  );
+  return Math.min(dwell, gapSeconds * cursorMotion.maxDwellGapShare);
+}
+function arrivalLeadSeconds(action, gapSeconds) {
+  return action.type === "click" ? clickDwellSeconds(gapSeconds) : cursorMotion.defaultLeadSeconds;
+}
+function cursorKeyframe(action, at, previousAt, size) {
+  if (typeof action.x !== "number" || typeof action.y !== "number") return null;
+  const point = actionPoint(action, size);
+  const lead = arrivalLeadSeconds(action, at - previousAt);
+  return { ...point, at, arriveAt: clamp(at - lead, previousAt, at) };
+}
+function dedupeKeyframes(points) {
+  return points.sort((a, b) => a.at - b.at).filter(
+    (point, index, all) => index === 0 || point.at - all[index - 1].at > 0.08 || Math.hypot(point.x - all[index - 1].x, point.y - all[index - 1].y) > 24
+  );
+}
+function downsampleKeyframes(points, actions, size) {
+  if (points.length <= cursorMotion.maxKeyframes) return points;
+  const anchors = actions.filter((action) => action.type !== "move").map((action) => actionPoint(action, size));
+  const result = points.filter(
+    (point, index) => index === 0 || index === points.length - 1 || anchors.some((anchor) => Math.hypot(anchor.x - point.x, anchor.y - point.y) < 1)
+  );
+  const step = points.length / Math.max(1, cursorMotion.maxKeyframes - result.length);
+  for (let i = 0; result.length < cursorMotion.maxKeyframes && i < points.length; i += step) {
+    const point = points[Math.floor(i)];
+    if (!result.includes(point)) result.push(point);
+  }
+  return result.sort((a, b) => a.at - b.at);
+}
+function cursorKeyframes(actions, duration, size) {
+  const center = { x: size.width / 2, y: size.height / 2 };
+  const points = [{ at: 0, arriveAt: 0, ...center }];
+  for (const action of actions) {
+    const at = clamp(action.atMs / 1e3, 0, duration);
+    const previousAt = points[points.length - 1].at;
+    if (action.type === "drag" && typeof action.x === "number" && typeof action.y === "number") {
+      const startAt = clamp(at - cursorMotion.dragLeadSeconds, 0, duration);
+      points.push({
+        at: startAt,
+        arriveAt: startAt,
+        x: clamp(action.x, 0, size.width),
+        y: clamp(action.y, 0, size.height)
+      });
+      if (typeof action.toX === "number" && typeof action.toY === "number") {
+        points.push({
+          at,
+          arriveAt: at,
+          x: clamp(action.toX, 0, size.width),
+          y: clamp(action.toY, 0, size.height)
+        });
+      }
+      continue;
+    }
+    const point = cursorKeyframe(action, at, previousAt, size);
+    if (point) points.push(point);
+  }
+  return downsampleKeyframes(dedupeKeyframes(points), actions, size);
+}
+function cursorAxisExpression(points, axis) {
+  if (points.length === 0) return "0";
+  let expression = expressionNumber(points[points.length - 1][axis]);
+  for (let i = points.length - 2; i >= 0; i--) {
+    const from = points[i];
+    const to = points[i + 1];
+    const arriveAt = clamp(to.arriveAt, from.at, to.at);
+    const moveWindow = Math.max(1e-3, arriveAt - from.at);
+    const distance = Math.hypot(to.x - from.x, to.y - from.y);
+    const moveSeconds = Math.min(
+      moveWindow,
+      Math.max(cursorMotion.minMoveSeconds, Math.min(cursorMotion.maxMoveSeconds, distance / cursorMotion.speedPxPerSecond))
+    );
+    const moveStart = Math.max(from.at, arriveAt - moveSeconds);
+    const duration = Math.max(1e-3, arriveAt - moveStart);
+    const interpolated = mixExpression(from[axis], to[axis], progressBetween(moveStart, duration));
+    expression = `if(lte(t\\,${moveStart.toFixed(3)})\\,${expressionNumber(from[axis])}\\,if(lte(t\\,${to.at.toFixed(3)})\\,${interpolated}\\,${expression}))`;
+  }
+  return expression;
+}
+function cursorSizeExpression(actions, normalSize) {
+  let expression = expressionNumber(normalSize);
+  const clicks = actions.filter((action) => action.type === "click").sort((a, b) => b.atMs - a.atMs);
+  for (const action of clicks) {
+    const at = action.atMs / 1e3;
+    const shrinkStart = Math.max(0, at - cursorMotion.clickShrinkSeconds);
+    const shrink = mixExpression(
+      normalSize,
+      cursorStyle.clickSize,
+      progressBetween(shrinkStart, Math.max(1e-3, at - shrinkStart))
+    );
+    const grow = mixExpression(cursorStyle.clickSize, normalSize, progressBetween(at, cursorMotion.clickGrowSeconds));
+    expression = `if(${betweenExpression(shrinkStart, at)}\\,${shrink}\\,if(${betweenExpression(at, at + cursorMotion.clickGrowSeconds)}\\,${grow}\\,${expression}))`;
+  }
+  return expression;
+}
+function cursorOverlayPositionExpression(cursor, size, hotspotRatio, overlaySize) {
+  return `max(0\\,min(${expressionNumber(size)}-${overlaySize}\\,(${cursor})-${hotspotRatio.toFixed(6)}*${overlaySize}))`;
+}
+function cursorSvg(size) {
+  return `<svg width="${size}" height="${size}" viewBox="0 0 32 32" xmlns="http://www.w3.org/2000/svg"><path d="M7.7 3.4c-1.45 0-2.62 1.17-2.62 2.62v19.7c0 2.46 3.02 3.65 4.7 1.85l5.06-5.44a5.42 5.42 0 0 1 3.96-1.73h5.82c2.48 0 3.63-3.08 1.76-4.7L9.42 4.04A2.62 2.62 0 0 0 7.7 3.4Z" fill="white" fill-opacity="0.98" stroke="black" stroke-opacity="0.88" stroke-width="2.9" stroke-linejoin="round"/></svg>`;
+}
+function buildCursorOverlayFilter(actions, duration, size, assets, projectCursor = null, inputLabel = "[screen]", outputLabel = "[v]") {
+  const points = cursorKeyframes(actions, duration, size);
+  const rawCursorX = cursorAxisExpression(points, "x");
+  const rawCursorY = cursorAxisExpression(points, "y");
+  const cursorX = projectCursor ? projectCursor.x(rawCursorX) : rawCursorX;
+  const cursorY = projectCursor ? projectCursor.y(rawCursorY) : rawCursorY;
+  const cursorSize = cursorSizeExpression(actions, assets.size);
+  const cursorOverlayX = cursorOverlayPositionExpression(cursorX, size.width, cursorHotspotRatio.x, "overlay_w");
+  const cursorOverlayY = cursorOverlayPositionExpression(cursorY, size.height, cursorHotspotRatio.y, "overlay_h");
+  return `[1:v]scale=w='${cursorSize}':h='${cursorSize}':eval=frame[cursor];${inputLabel}[cursor]overlay=x='${cursorOverlayX}':y='${cursorOverlayY}':eof_action=repeat:shortest=1:eval=frame${outputLabel}`;
+}
+
+// src/commands/computer/recording/render.ts
+function videoDuration(path6) {
+  const r = spawnSync2("ffprobe", [
+    "-v",
+    "error",
+    "-show_entries",
+    "format=duration",
+    "-of",
+    "default=noprint_wrappers=1:nokey=1",
+    path6
+  ], { stdio: "pipe" });
+  if (r.status !== 0) fail(`ffprobe failed: ${r.stderr?.toString().trim() || `exit ${r.status}`}`);
+  const duration = Number.parseFloat(r.stdout?.toString().trim() ?? "");
+  if (!Number.isFinite(duration) || duration <= 0) fail(`could not read recording duration for ${path6}`);
+  return duration;
+}
+function renderedSegmentSpans(segments) {
+  let outputStart = 0;
+  return segments.map((segment) => {
+    const outputEnd = outputStart + (segment.end - segment.start) / segment.speed;
+    const span = {
+      rawStart: segment.start,
+      rawEnd: segment.end,
+      outputStart,
+      outputEnd,
+      speed: segment.speed
+    };
+    outputStart = outputEnd;
+    return span;
+  });
+}
+function outputTimeForRawTime(spans, rawTime) {
+  const span = spans.find((candidate) => rawTime >= candidate.rawStart && rawTime <= candidate.rawEnd);
+  if (span) return span.outputStart + (rawTime - span.rawStart) / span.speed;
+  if (spans.length === 0) return rawTime;
+  if (rawTime <= spans[0].rawStart) return spans[0].outputStart;
+  const lastSpan = spans[spans.length - 1];
+  if (rawTime >= lastSpan.rawEnd) return lastSpan.outputEnd;
+  return spans.find((candidate) => rawTime < candidate.rawStart)?.outputStart ?? lastSpan.outputEnd;
+}
+function actionsOnRenderedTimeline(actions, spans) {
+  return actions.map((action) => ({
+    ...action,
+    atMs: outputTimeForRawTime(spans, action.atMs / 1e3) * 1e3
+  }));
+}
+function segmentMotionSeconds(segment) {
+  return Math.min(segment.motionSeconds, Math.max(0.12, (segment.end - segment.start) / segment.speed));
+}
+function scaledFrameClampExpression(value, zoom, outputSize) {
+  return `max(0\\,min(${outputSize}*(${zoom})-${outputSize}\\,${value}))`;
+}
+function cameraTransformExpressions(segment, size, timeExpression) {
+  const progress = progressOverTime(timeExpression, segmentMotionSeconds(segment));
+  const zoom = mixExpression(segment.fromZoom, segment.zoom, progress);
+  return {
+    zoom,
+    cropX: scaledFrameClampExpression(
+      easedCropOrigin(segment.fromX, segment.x, segment.fromZoom, segment.zoom, size.width, progress),
+      zoom,
+      size.width
+    ),
+    cropY: scaledFrameClampExpression(
+      easedCropOrigin(segment.fromY, segment.y, segment.fromZoom, segment.zoom, size.height, progress),
+      zoom,
+      size.height
+    )
+  };
+}
+function projectedCursorExpression(rawCursor, axis, segments, spans, size) {
+  let expression = rawCursor;
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const span = spans[i];
+    const camera = cameraTransformExpressions(segments[i], size, `t-${span.outputStart.toFixed(3)}`);
+    const crop = axis === "x" ? camera.cropX : camera.cropY;
+    const projected = `(${rawCursor})*(${camera.zoom})-(${crop})`;
+    expression = `if(${betweenExpression(span.outputStart, span.outputEnd)}\\,${projected}\\,${expression})`;
+  }
+  return expression;
+}
+function renderRecording(rawPath, target, actions, fps, size) {
+  if (actions.length === 0) {
+    copyFileSync(rawPath, target);
+    return;
+  }
+  const duration = videoDuration(rawPath);
+  const segments = buildRecordingSegments(actions, duration, size);
+  if (segments.length === 0) {
+    copyFileSync(rawPath, target);
+    return;
+  }
+  const stamp = `${process.pid}-${Date.now()}`;
+  const cursor = cursorAssets(stamp);
+  writeFileSync(cursor.path, cursorSvg(cursor.size));
+  const spans = renderedSegmentSpans(segments);
+  const renderedDuration = spans.length ? spans[spans.length - 1].outputEnd : duration;
+  const renderedActions = actionsOnRenderedTimeline(actions, spans);
+  const cursorFilter = buildCursorOverlayFilter(
+    renderedActions,
+    renderedDuration,
+    size,
+    cursor,
+    {
+      x: (cursorX) => projectedCursorExpression(cursorX, "x", segments, spans, size),
+      y: (cursorY) => projectedCursorExpression(cursorY, "y", segments, spans, size)
+    }
+  );
+  const screenLabels = segments.map((_, index) => `[screen${index}]`).join("");
+  const screenSplitFilter = `[0:v]split=${segments.length}${screenLabels}`;
+  const filters = segments.map((segment, index) => {
+    const { zoom, cropX, cropY } = cameraTransformExpressions(segment, size, "t");
+    return `[screen${index}]trim=start=${segment.start.toFixed(3)}:end=${segment.end.toFixed(3)},setpts=(PTS-STARTPTS)/${segment.speed.toFixed(3)},scale=w=${size.width}*(${zoom}):h=${size.height}*(${zoom}):eval=frame,crop=${size.width}:${size.height}:x=${cropX}:y=${cropY},setsar=1[v${index}]`;
+  });
+  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);
+  try {
+    const r = spawnSync2("ffmpeg", [
+      "-y",
+      "-hide_banner",
+      "-loglevel",
+      "warning",
+      "-i",
+      rawPath,
+      "-loop",
+      "1",
+      "-i",
+      cursor.path,
+      "-filter_complex_script",
+      filterPath,
+      "-map",
+      "[v]",
+      "-r",
+      String(fps),
+      "-c:v",
+      "libx264",
+      "-preset",
+      "veryfast",
+      "-crf",
+      "23",
+      "-pix_fmt",
+      "yuv420p",
+      "-movflags",
+      "+faststart",
+      target
+    ], { stdio: "pipe", maxBuffer: 20 * 1024 * 1024 });
+    if (r.status !== 0) {
+      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 });
+  }
+}
+
+// src/commands/computer/recording.ts
+var RECORD_PID_FILE = `${STATE_DIR}/ffmpeg.pid`;
+var RECORD_PATH_FILE = `${STATE_DIR}/recording-path.txt`;
+var RECORD_RAW_PATH_FILE = `${STATE_DIR}/recording-raw-path.txt`;
+var RECORD_STARTED_AT_FILE = `${STATE_DIR}/recording-started-at.txt`;
+var RECORD_FPS_FILE = `${STATE_DIR}/recording-fps.txt`;
+var RECORD_DIMENSIONS_FILE = `${STATE_DIR}/recording-dimensions.json`;
+var RECORD_ACTIONS_FILE = `${STATE_DIR}/recording-actions.jsonl`;
+function recordingStartedAt() {
+  if (!existsSync2(RECORD_STARTED_AT_FILE)) return null;
+  const startedAt = Number.parseInt(readFileSync(RECORD_STARTED_AT_FILE, "utf8").trim(), 10);
+  return Number.isFinite(startedAt) ? startedAt : null;
+}
+function logRecordingAction(action) {
+  const startedAt = recordingStartedAt();
+  if (!startedAt) return;
+  const atMs = Date.now() - startedAt;
+  appendFileSync(RECORD_ACTIONS_FILE, `${JSON.stringify({ ...action, atMs })}
+`);
+}
+function readRecordingDimensions() {
+  if (!existsSync2(RECORD_DIMENSIONS_FILE)) return configuredDesktopDimensions();
+  try {
+    const dimensions = JSON.parse(readFileSync(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 };
+    }
+  } catch {
+  }
+  fail("invalid recording dimensions state");
+}
+function isRecordingActionType(value) {
+  return value === "click" || value === "drag" || value === "key" || value === "move" || value === "scroll" || value === "type";
+}
+function isOptionalNumber(value) {
+  return value === void 0 || typeof value === "number";
+}
+function readRecordingActions() {
+  if (!existsSync2(RECORD_ACTIONS_FILE)) return [];
+  return readFileSync(RECORD_ACTIONS_FILE, "utf8").split("\n").filter(Boolean).flatMap((line) => {
+    try {
+      const value = JSON.parse(line);
+      if (typeof value !== "object" || value === null) return [];
+      const type = "type" in value ? value.type : void 0;
+      const atMs = "atMs" in value ? value.atMs : void 0;
+      const x = "x" in value ? value.x : void 0;
+      const y = "y" in value ? value.y : void 0;
+      const toX = "toX" in value ? value.toX : void 0;
+      const toY = "toY" in value ? value.toY : void 0;
+      if (!isRecordingActionType(type) || typeof atMs !== "number" || !Number.isFinite(atMs) || !isOptionalNumber(x) || !isOptionalNumber(y) || !isOptionalNumber(toX) || !isOptionalNumber(toY)) {
+        return [];
+      }
+      return [{ type, atMs, x, y, toX, toY }];
+    } catch {
+      return [];
+    }
+  }).sort((a, b) => a.atMs - b.atMs);
+}
+async function computerRecordStartCommand(path6, options) {
+  ensureServicesRunning();
+  if (existsSync2(RECORD_PID_FILE)) {
+    const pid = parseInt(readFileSync(RECORD_PID_FILE, "utf8").trim(), 10);
+    if (Number.isFinite(pid)) {
+      let alive = false;
+      try {
+        process.kill(pid, 0);
+        alive = true;
+      } catch {
+      }
+      if (alive) fail(`recording already in progress (pid ${pid}). run \`replicas computer record stop\` first.`);
+    }
+  }
+  const target = resolvePath(path6);
+  mkdirSync(dirname(target), { recursive: true });
+  const fps = options.fps ? parseCoord(options.fps, "--fps") : 60;
+  const { width, height } = configuredDesktopDimensions();
+  mkdirSync(STATE_DIR, { recursive: true });
+  const rawTarget = `${target}.raw-${Date.now()}.mp4`;
+  rmSync2(RECORD_ACTIONS_FILE, { force: true });
+  const child = spawn3("ffmpeg", [
+    "-y",
+    "-hide_banner",
+    "-loglevel",
+    "warning",
+    "-f",
+    "x11grab",
+    "-framerate",
+    String(fps),
+    "-video_size",
+    `${width}x${height}`,
+    "-draw_mouse",
+    "0",
+    "-i",
+    DEFAULT_DISPLAY,
+    "-c:v",
+    "libx264",
+    "-preset",
+    "ultrafast",
+    "-tune",
+    "zerolatency",
+    "-crf",
+    "23",
+    "-pix_fmt",
+    "yuv420p",
+    "-movflags",
+    "+faststart+frag_keyframe+empty_moov",
+    rawTarget
+  ], { 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 }));
+  console.log(target);
+}
+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(readFileSync(RECORD_PID_FILE, "utf8").trim(), 10);
+    if (!Number.isFinite(pid)) fail("invalid recording pidfile");
+    try {
+      process.kill(pid, "SIGINT");
+    } catch {
+    }
+    for (let i = 0; i < 30; i++) {
+      try {
+        process.kill(pid, 0);
+      } catch {
+        break;
+      }
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    rmSync2(RECORD_PID_FILE, { force: true });
+  }
+  if (existsSync2(RECORD_PATH_FILE)) {
+    const target = readFileSync(RECORD_PATH_FILE, "utf8").trim();
+    const rawPath = existsSync2(RECORD_RAW_PATH_FILE) ? readFileSync(RECORD_RAW_PATH_FILE, "utf8").trim() : target;
+    const fps = existsSync2(RECORD_FPS_FILE) ? parseInt(readFileSync(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 });
+    }
+    console.log(target);
+    rmSync2(RECORD_PATH_FILE, { force: true });
+    rmSync2(RECORD_RAW_PATH_FILE, { force: true });
+    rmSync2(RECORD_STARTED_AT_FILE, { force: true });
+    rmSync2(RECORD_FPS_FILE, { force: true });
+    rmSync2(RECORD_DIMENSIONS_FILE, { force: true });
+    rmSync2(RECORD_ACTIONS_FILE, { force: true });
+  }
+}
+
+// src/commands/computer/index.ts
 function desktopBridgeStatus() {
-  const r = spawnSync("bash", [SERVICES_SCRIPT, "--status-json"], { stdio: "pipe" });
+  const r = spawnSync3("bash", [SERVICES_SCRIPT, "--status-json"], { stdio: "pipe" });
   if (r.status !== 0) return null;
   try {
     return JSON.parse(r.stdout.toString());
@@ -14580,7 +15249,6 @@ function bridgeStatus(details, includeBacklog = false, rootsOnly = false) {
   if (pids.length > 0) parts.push(`pid${pids.length === 1 ? "" : "s"} ${pids.join(",")}`);
   return ` (${parts.join(", ")})`;
 }
-var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
 async function lookupDesktopViewerUrl() {
   try {
     const list = await listAgentPreviews();
@@ -14614,7 +15282,7 @@ async function computerStatusCommand() {
   const bridge = desktopBridgeStatus();
   const procs = ["Xvfb", "openbox", "tint2", "x11vnc", "websockify"];
   for (const p of procs) {
-    const r = spawnSync("pgrep", ["-af", p], { stdio: "pipe" });
+    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 ? chalk20.green("\u25CF") : chalk20.red("\u25CB")} ${p}${suffix}`);
@@ -14646,12 +15314,12 @@ function brandSvgPath() {
 }
 function loadBrandSvg(canvasW, canvasH) {
   const path6 = brandSvgPath();
-  if (!existsSync(path6)) {
+  if (!existsSync3(path6)) {
     fail(
       `Brand wallpaper SVG missing at ${path6}. The workspace image is out of date \u2014 \`desktop/brand-wallpaper.svg\` must be installed at $REPLICAS_DESKTOP_TEMPLATES.`
     );
   }
-  return readFileSync(path6, "utf8").replace(/(<svg[^>]*\s)width="\d+"/, `$1width="${canvasW}"`).replace(/(<svg[^>]*\s)height="\d+"/, `$1height="${canvasH}"`);
+  return readFileSync2(path6, "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;
@@ -14686,8 +15354,8 @@ ${labels.join("\n")}
 </svg>`;
 }
 function overlayGrid(rawPath, target, width, height, gridSize, gridPath) {
-  writeFileSync(gridPath, buildGridSvg(width, height, gridSize));
-  const r = spawnSync(
+  writeFileSync3(gridPath, buildGridSvg(width, height, gridSize));
+  const r = spawnSync3(
     "ffmpeg",
     [
       "-y",
@@ -14714,7 +15382,7 @@ function overlayGrid(rawPath, target, width, height, gridSize, gridPath) {
 }
 async function computerScreenshotCommand(path6, options = {}) {
   const target = resolvePath(path6);
-  mkdirSync(dirname(target), { recursive: true });
+  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`;
@@ -14726,7 +15394,7 @@ async function computerScreenshotCommand(path6, options = {}) {
     const { width, height } = readPngDimensions(rawPath);
     const gridSize = parseGridSize(options.grid);
     if (options.raw && gridSize === null) {
-      copyFileSync(rawPath, target);
+      copyFileSync2(rawPath, target);
       console.log(`${target} (${width}x${height}, raw 1:1 desktop pixels)`);
       return;
     }
@@ -14746,16 +15414,16 @@ async function computerScreenshotCommand(path6, options = {}) {
     const shadowMargin = shadowSigma * 3;
     const shadowW = width + shadowMargin * 2;
     const shadowH = height + shadowMargin * 2;
-    writeFileSync(svgPath, loadBrandSvg(canvasW, canvasH));
-    writeFileSync(
+    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))
     );
-    writeFileSync(
+    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 = spawnSync(
+    const r = spawnSync3(
       "ffmpeg",
       [
         "-y",
@@ -14784,16 +15452,16 @@ async function computerScreenshotCommand(path6, options = {}) {
       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 });
+    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(path6) {
-  return createHash2("sha256").update(readFileSync(path6)).digest("hex");
+  return createHash2("sha256").update(readFileSync2(path6)).digest("hex");
 }
 async function captureStableRawScreenshot(target, options) {
   const start = Date.now();
@@ -14820,7 +15488,7 @@ async function captureStableRawScreenshot(target, options) {
         lastChangeAt = now;
       }
       lastHash = hash;
-      copyFileSync(framePath, target);
+      copyFileSync2(framePath, target);
       if (frames > 1 && now - lastChangeAt >= options.stableMs) {
         return { width, height, stable: true, elapsedMs: now - start, frames, changes };
       }
@@ -14828,26 +15496,9 @@ async function captureStableRawScreenshot(target, options) {
     }
     return { width, height, stable: false, elapsedMs: Date.now() - start, frames, changes };
   } finally {
-    rmSync(framePath, { force: true });
+    rmSync3(framePath, { force: true });
   }
 }
-function getMouseLocation() {
-  const out = tryDisplayCmd("xdotool", ["getmouselocation", "--shell"]);
-  if (!out) return null;
-  const values = Object.fromEntries(
-    out.split("\n").map((line) => {
-      const [key, value] = line.split("=");
-      return [key.toLowerCase(), Number.parseInt(value, 10)];
-    })
-  );
-  if (!Number.isFinite(values.x) || !Number.isFinite(values.y)) return null;
-  return {
-    x: values.x,
-    y: values.y,
-    screen: Number.isFinite(values.screen) ? values.screen : 0,
-    window: Number.isFinite(values.window) ? values.window : 0
-  };
-}
 function getActiveWindowTitle() {
   return tryDisplayCmd("xdotool", ["getactivewindow", "getwindowname"]);
 }
@@ -14855,9 +15506,13 @@ 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(path6, options = {}) {
   const target = resolvePath(path6);
-  mkdirSync(dirname(target), { recursive: true });
+  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;
@@ -14871,7 +15526,7 @@ async function computerObserveCommand(path6, options = {}) {
     const capture = await captureStableRawScreenshot(rawPath, { timeoutMs, stableMs, pollMs });
     const gridSize = options.raw ? null : parseGridSize(options.grid ?? true);
     if (gridSize === null) {
-      copyFileSync(rawPath, target);
+      copyFileSync2(rawPath, target);
     } else {
       overlayGrid(rawPath, target, capture.width, capture.height, gridSize, gridPath);
     }
@@ -14890,8 +15545,8 @@ async function computerObserveCommand(path6, options = {}) {
       gridSize
     }, null, 2));
   } finally {
-    rmSync(rawPath, { force: true });
-    rmSync(gridPath, { force: true });
+    rmSync3(rawPath, { force: true });
+    rmSync3(gridPath, { force: true });
   }
 }
 async function fetchChromeJson(path6) {
@@ -15017,7 +15672,7 @@ async function evaluateChromeTarget(webSocketDebuggerUrl, expression) {
       }));
     });
     ws.addEventListener("message", (event) => {
-      const data = typeof event.data === "string" ? event.data : Buffer.from(event.data).toString("utf8");
+      const data = typeof event.data === "string" ? event.data : Buffer.isBuffer(event.data) ? event.data.toString("utf8") : Buffer.from(event.data).toString("utf8");
       let parsed;
       try {
         parsed = JSON.parse(data);
@@ -15342,6 +15997,7 @@ async function computerClickCommand(xStr, yStr, options) {
     }
   }
   runDisplayCmd("xdotool", args);
+  logRecordingAction({ type: "click", x, y });
   console.log(`clicked ${button === "1" ? "left" : button === "2" ? "middle" : button === "3" ? "right" : `button ${button}`} at (${x},${y})${options.double ? " x2" : ""}`);
 }
 async function computerMoveCommand(xStr, yStr) {
@@ -15349,15 +16005,20 @@ async function computerMoveCommand(xStr, yStr) {
   const x = parseScreenCoord(xStr, "x", dimensions.width);
   const y = parseScreenCoord(yStr, "y", dimensions.height);
   runDisplayCmd("xdotool", ["mousemove", "--sync", String(x), String(y)]);
+  logRecordingAction({ type: "move", x, y });
   console.log(`moved to (${x},${y})`);
 }
 async function computerTypeCommand(text, options) {
   const delay = options.delay ? parseCoord(options.delay, "--delay") : 12;
   runDisplayCmd("xdotool", ["type", "--delay", String(delay), "--", text]);
+  const position = recordingMousePosition();
+  logRecordingAction({ type: "type", ...position ?? {} });
   console.log(`typed ${text.length} char${text.length === 1 ? "" : "s"}`);
 }
 async function computerKeyCommand(combo) {
   runDisplayCmd("xdotool", ["key", "--", combo]);
+  const position = recordingMousePosition();
+  logRecordingAction({ type: "key", ...position ?? {} });
   console.log(`pressed ${combo}`);
 }
 async function computerScrollCommand(direction, options) {
@@ -15367,17 +16028,24 @@ async function computerScrollCommand(direction, options) {
   if (!button) fail(`direction must be one of up|down|left|right (got "${direction}")`);
   const amount = options.amount ? parseCoord(options.amount, "--amount") : 3;
   const args = [];
+  let hoverPosition = null;
   if (options.x && options.y) {
     const dimensions = getDisplayDimensions();
+    hoverPosition = {
+      x: parseScreenCoord(options.x, "--x", dimensions.width),
+      y: parseScreenCoord(options.y, "--y", dimensions.height)
+    };
     args.push(
       "mousemove",
       "--sync",
-      String(parseScreenCoord(options.x, "--x", dimensions.width)),
-      String(parseScreenCoord(options.y, "--y", dimensions.height))
+      String(hoverPosition.x),
+      String(hoverPosition.y)
     );
   }
   args.push("click", "--repeat", String(amount), "--delay", "30", button);
   runDisplayCmd("xdotool", args);
+  const position = hoverPosition ?? recordingMousePosition();
+  logRecordingAction({ type: "scroll", ...position ?? {} });
   console.log(`scrolled ${dir} x${amount}`);
 }
 async function computerDragCommand(fx, fy, tx, ty) {
@@ -15386,20 +16054,24 @@ async function computerDragCommand(fx, fy, tx, ty) {
   const fromY = parseScreenCoord(fy, "fromY", dimensions.height);
   const toX = parseScreenCoord(tx, "toX", dimensions.width);
   const toY = parseScreenCoord(ty, "toY", dimensions.height);
-  runDisplayCmd("xdotool", [
+  const distance = Math.hypot(toX - fromX, toY - fromY);
+  const steps = clamp(Math.ceil(distance / 70), 8, 24);
+  const args = [
     "mousemove",
     "--sync",
     String(fromX),
     String(fromY),
     "mousedown",
-    "1",
-    "mousemove",
-    "--sync",
-    String(toX),
-    String(toY),
-    "mouseup",
     "1"
-  ]);
+  ];
+  for (let i = 1; i <= steps; i++) {
+    const x = Math.round(fromX + (toX - fromX) * i / steps);
+    const y = Math.round(fromY + (toY - fromY) * i / steps);
+    args.push("mousemove", "--sync", String(x), String(y), "sleep", "0.018");
+  }
+  args.push("mouseup", "1");
+  runDisplayCmd("xdotool", args);
+  logRecordingAction({ type: "drag", x: fromX, y: fromY, toX, toY });
   console.log(`dragged (${fromX},${fromY}) -> (${toX},${toY})`);
 }
 var APP_ALIASES = {
@@ -15422,10 +16094,10 @@ var LEGACY_CHROME_ALIAS = [
 ];
 async function computerLaunchCommand(app, args) {
   ensureServicesRunning();
-  const baseArgs = app === "chrome" && !existsSync(CHROME_WRAPPER) ? LEGACY_CHROME_ALIAS : APP_ALIASES[app] ?? [app];
+  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 child = spawn3(bin, fullArgs, {
+  const child = spawn4(bin, fullArgs, {
     env: withDisplay(),
     detached: true,
     stdio: "ignore"
@@ -15433,85 +16105,6 @@ async function computerLaunchCommand(app, args) {
   child.unref();
   console.log(`launched ${bin} (pid ${child.pid})`);
 }
-var RECORD_PID_FILE = `${STATE_DIR}/ffmpeg.pid`;
-async function computerRecordStartCommand(path6, options) {
-  ensureServicesRunning();
-  if (existsSync(RECORD_PID_FILE)) {
-    const pid = parseInt(readFileSync(RECORD_PID_FILE, "utf8").trim(), 10);
-    if (Number.isFinite(pid)) {
-      let alive = false;
-      try {
-        process.kill(pid, 0);
-        alive = true;
-      } catch {
-      }
-      if (alive) fail(`recording already in progress (pid ${pid}). run \`replicas computer record stop\` first.`);
-    }
-  }
-  const target = resolvePath(path6);
-  mkdirSync(dirname(target), { recursive: true });
-  const fps = options.fps ? parseCoord(options.fps, "--fps") : 60;
-  const width = process.env.REPLICAS_DESKTOP_WIDTH || String(DESKTOP_VIEWER_WIDTH);
-  const height = process.env.REPLICAS_DESKTOP_HEIGHT || String(DESKTOP_VIEWER_HEIGHT);
-  const child = spawn3("ffmpeg", [
-    "-y",
-    "-hide_banner",
-    "-loglevel",
-    "warning",
-    "-f",
-    "x11grab",
-    "-framerate",
-    String(fps),
-    "-video_size",
-    `${width}x${height}`,
-    "-draw_mouse",
-    "1",
-    "-i",
-    DEFAULT_DISPLAY,
-    "-c:v",
-    "libx264",
-    "-preset",
-    "ultrafast",
-    "-tune",
-    "zerolatency",
-    "-crf",
-    "23",
-    "-pix_fmt",
-    "yuv420p",
-    "-movflags",
-    "+faststart+frag_keyframe+empty_moov",
-    target
-  ], { detached: true, stdio: "ignore" });
-  child.unref();
-  if (!child.pid) fail("failed to launch ffmpeg");
-  mkdirSync(STATE_DIR, { recursive: true });
-  writeFileSync(RECORD_PID_FILE, String(child.pid));
-  writeFileSync(`${STATE_DIR}/recording-path.txt`, target);
-  console.log(target);
-}
-async function computerRecordStopCommand() {
-  if (!existsSync(RECORD_PID_FILE)) fail("no recording in progress");
-  const pid = parseInt(readFileSync(RECORD_PID_FILE, "utf8").trim(), 10);
-  if (!Number.isFinite(pid)) fail("invalid recording pidfile");
-  try {
-    process.kill(pid, "SIGINT");
-  } catch {
-  }
-  for (let i = 0; i < 30; i++) {
-    try {
-      process.kill(pid, 0);
-    } catch {
-      break;
-    }
-    await new Promise((r) => setTimeout(r, 200));
-  }
-  rmSync(RECORD_PID_FILE, { force: true });
-  const pathFile = `${STATE_DIR}/recording-path.txt`;
-  if (existsSync(pathFile)) {
-    console.log(readFileSync(pathFile, "utf8").trim());
-    rmSync(pathFile, { force: true });
-  }
-}
 
 // src/commands/interactive.ts
 import chalk21 from "chalk";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-cli",
-  "version": "0.2.328",
+  "version": "0.2.329",
   "description": "CLI for managing Replicas workspaces - SSH into cloud dev environments with automatic port forwarding",
   "main": "dist/index.mjs",
   "bin": {