@runalabs/rill-cli 0.1.9 → 0.1.10

package/README.md

@@ -25,14 +25,7 @@ The following local-recording instructions remain available through `record star
 
 ## Install and verify
 
-Browser recording runs on macOS and Linux. Install Node.js 22+, Google Chrome or Chromium, and ffmpeg on `PATH`.
-
-```sh
-# macOS
-brew install ffmpeg
-# Debian / Ubuntu
-sudo apt install ffmpeg
-```
+Browser recording runs on macOS and Linux. Install Node.js 22+ and Google Chrome or Chromium. Rill encodes recordings remotely by default; local FFmpeg is optional. Chrome stays on your machine and can access localhost. Raw frames upload after recording stops.
 
 Then install the scoped package:
 
@@ -43,7 +36,7 @@ rill login
 rill doctor
 ```
 
-Do not use `npx rill`: the unscoped package belongs to a different product. Doctor checks Node, API reachability, CLI compatibility, authentication, Chrome, and ffmpeg. Resolve failed checks before starting a run.
+Do not use `npx rill`: the unscoped package belongs to a different product. Doctor checks Node, API reachability, CLI compatibility, authentication, Chrome, and remote encoding availability. Resolve failed checks before starting a run.
 
 ## Authenticate
 
@@ -67,7 +60,7 @@ rill record stop <recording-id>
 rill inspect https://userill.dev/s/<share-secret>
 ```
 
-Start returns `recordingId`, `cdpUrl`, `status`, `bodyCaptureEnabled`, and `maxDurationSeconds`. Stop finalizes capture, uploads video and diagnostics, and waits for playback. Confirm `status: "ready"` and a non-null `shareUrl` before returning the evidence link. Local capture finishing does not establish remote readiness.
+Start returns `recordingId`, `cdpUrl`, `status`, `bodyCaptureEnabled`, and `maxDurationSeconds`. Stop finalizes capture, uploads frames and diagnostics for remote encoding, and waits for playback. Confirm `status: "ready"` and a non-null `shareUrl` before returning the evidence link. Local capture finishing does not establish remote readiness.
 
 New browser recordings include a visible cursor and click pulses by default. In Rill Settings → Cursor appearance, workspace members can turn them off or choose an accent color. The CLI reads this preference when starting a recording; it is baked into the video and does not change existing recordings. Use an updated CLI and recorder daemon to capture the overlay.
 
@@ -100,6 +93,7 @@ Capture follows the first page selected at recording start. Keep the flow in tha
 | Option | Behavior |
 | --- | --- |
 | `--url <url>` | Open the target in a managed browser. |
+| `--encoding remote` / `--encoding local` | Remote is the default; local requires FFmpeg. |
 | `--title <title>` | Name the run; defaults to a timestamped title. |
 | `--description <text>` | Describe what the run demonstrates. |
 | `--headed` | Show the managed browser; default is headless. |
@@ -142,7 +136,7 @@ rill upload ./test-results/checkout.webm --title "Checkout test"
 
 Upload WebM or MP4 evidence. The command waits for readiness and returns the recording ID and share URL. Existing uploads report `diagnosticsAvailable: false`; they do not import Playwright traces or reconstruct diagnostic events.
 
-Both `upload` and `record stop` accept `--no-wait`. This still waits for upload but skips playback processing: the result is `status: "processing"` with `shareUrl: null`. Check the recording in the dashboard before sharing.
+Both `upload` and `record stop` accept `--no-wait`. This waits for upload acceptance, then returns while processing continues. Remote recordings may report `queued` or `encoding` before `processing` and `ready`. Use `rill record status <recording-id>` to retrieve progress and the eventual share link.
 
 ## Command reference
 
@@ -269,3 +263,9 @@ Substitute your API URL if you configured another environment. These commands cl
 Use `--json` for a machine-readable result (`--pretty` also enables JSON formatting).
 Provider token usage is retained internally and omitted from customer output.
 `rill run status <run-id>` and `rill run cancel <run-id>` support the same output options.
+
+### Remote encoding
+
+Since 0.1.10, `record start` uses remote encoding by default. Chrome stays local, including access to localhost; FFmpeg is required only for `record start --encoding local`. For local encoding, install FFmpeg with `brew install ffmpeg` on macOS or `sudo apt install ffmpeg` on Debian/Ubuntu, then run `doctor --encoding local`. Remote encoding adds no charge and consumes no cloud-run credits; existing recording allowances still apply. Captures are limited to ten minutes and 1 GiB of raw frames, with three pending jobs per workspace. Busy recordings can reach the byte limit sooner.
+
+`record stop` uploads frames and waits for playback. `record stop ID --no-wait` returns after upload acceptance; processing continues if the terminal closes. Use `record status ID` to retrieve progress and the share link, or `record retry ID` to resume an interrupted upload or retry encoding without repeating browser actions. Failed raw captures expire after 24 hours. Remote encoding uses no cloud-run credits and adds no charge.

package/dist/cli.js

@@ -5,80 +5,9 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/cli.ts
-import { spawn as spawn6 } from "child_process";
-import { Command } from "commander";
-import { hostname as hostname3 } from "os";
-import { basename, dirname as dirname2 } from "path";
-import { readdir, rm as rm2, stat as stat2 } from "fs/promises";
-
-// ../recorder/src/client.ts
-import { request } from "http";
-import { spawn } from "child_process";
-
-// ../recorder/src/paths.ts
-import { homedir, tmpdir } from "os";
+// src/remote-encoding.ts
+import { open, readFile as readFile2 } from "fs/promises";
 import { join } from "path";
-var rillDirectory = () => process.env.RILL_HOME ?? join(homedir(), ".rill");
-var daemonSocketPath = () => process.env.RILL_SOCKET ?? join(rillDirectory(), "recorder.sock");
-var daemonStatePath = () => join(rillDirectory(), "sessions.json");
-var recordingTempRoot = () => process.env.RILL_TEMP ?? join(tmpdir(), "rill-recordings");
-
-// ../recorder/src/client.ts
-async function ensureDaemon(cliEntryPath) {
-  try {
-    await callDaemon("GET", "/health");
-    return;
-  } catch {
-  }
-  const child = spawn(process.execPath, [cliEntryPath, "daemon"], { detached: true, stdio: "ignore", env: process.env });
-  child.unref();
-  const deadline = Date.now() + 1e4;
-  while (Date.now() < deadline) {
-    try {
-      await callDaemon("GET", "/health");
-      return;
-    } catch {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-  }
-  throw new Error("The local recorder service did not start.");
-}
-function startRecording(input) {
-  return callDaemon("POST", "/sessions", input);
-}
-function stopRecording(recordingId) {
-  return callDaemon("POST", `/sessions/${encodeURIComponent(recordingId)}/stop`, {});
-}
-function recordingStatus(recordingId) {
-  return callDaemon("GET", `/sessions/${encodeURIComponent(recordingId)}`);
-}
-function callDaemon(method, path, body) {
-  return new Promise((resolve, reject) => {
-    const payload = body === void 0 ? void 0 : Buffer.from(JSON.stringify(body));
-    const outgoing = request({ socketPath: daemonSocketPath(), method, path, headers: payload ? { "Content-Type": "application/json", "Content-Length": payload.length } : void 0 }, (incoming) => {
-      const chunks = [];
-      incoming.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
-      incoming.on("end", () => {
-        try {
-          const value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
-          if ((incoming.statusCode ?? 500) >= 400) reject(new Error(value.error?.message ?? `Recorder returned ${incoming.statusCode}.`));
-          else resolve(value);
-        } catch (error51) {
-          reject(error51);
-        }
-      });
-    });
-    outgoing.once("error", reject);
-    if (payload) outgoing.write(payload);
-    outgoing.end();
-  });
-}
-
-// ../recorder/src/daemon.ts
-import { createServer as createServer2 } from "http";
-import { mkdir as mkdir3, readFile, unlink, writeFile as writeFile2 } from "fs/promises";
-import { dirname, join as join4 } from "path";
 
 // ../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -14594,6 +14523,352 @@ function date4(params) {
 // ../../node_modules/zod/v4/classic/external.js
 config(en_default());
 
+// ../contracts/src/encoding.ts
+var ENCODING_PART_BYTES = 4 * 1024 * 1024;
+var ENCODING_MAX_BYTES = 1024 * 1024 * 1024;
+var frameManifestSchema = external_exports.object({
+  version: external_exports.literal(1),
+  durationSeconds: external_exports.number().positive().max(600),
+  width: external_exports.number().int().min(320).max(3840),
+  height: external_exports.number().int().min(240).max(2160),
+  frames: external_exports.array(external_exports.object({ timestamp: external_exports.number().nonnegative().finite(), size: external_exports.number().int().positive().max(ENCODING_PART_BYTES) }).strict()).min(1).max(36e3)
+}).strict().superRefine((m, ctx) => {
+  if (m.frames.reduce((n, f) => n + f.size, 0) > ENCODING_MAX_BYTES) ctx.addIssue({ code: "custom", message: "Frame upload exceeds the trial byte limit." });
+  for (let i = 1; i < m.frames.length; i++) if (m.frames[i].timestamp < m.frames[i - 1].timestamp) ctx.addIssue({ code: "custom", message: "Frame timestamps must be ordered." });
+  if (m.frames.at(-1).timestamp - m.frames[0].timestamp > m.durationSeconds + 1) ctx.addIssue({ code: "custom", message: "Frame timestamps exceed capture duration." });
+});
+
+// src/control-plane.ts
+import { createReadStream } from "fs";
+import { readFile, stat } from "fs/promises";
+import { Upload } from "tus-js-client";
+var ControlPlaneError = class extends Error {
+  constructor(code, message, recovery, details, httpStatus) {
+    super(`${code}: ${message}${recovery ? `: ${recovery}` : ""}`);
+    this.code = code;
+    this.recovery = recovery;
+    this.details = details;
+    this.httpStatus = httpStatus;
+    this.name = "ControlPlaneError";
+  }
+};
+var ControlPlaneHttpError = class extends Error {
+  constructor(httpStatus) {
+    super(`Request failed (${httpStatus}).`);
+    this.httpStatus = httpStatus;
+    this.name = "ControlPlaneHttpError";
+  }
+};
+var ControlPlaneClient = class {
+  constructor(apiUrl, token) {
+    this.apiUrl = apiUrl;
+    this.token = token;
+  }
+  encodingCapabilities() {
+    return this.request("/api/encoding/capabilities");
+  }
+  beginEncoding(id, manifest) {
+    return this.request(`/api/encoding/${encodeURIComponent(id)}`, { method: "POST", body: JSON.stringify(manifest) });
+  }
+  encodingStatus(id) {
+    return this.request(`/api/encoding/${encodeURIComponent(id)}`);
+  }
+  uploadEncodingPart(id, part, bytes) {
+    return this.request(`/api/encoding/${encodeURIComponent(id)}/parts/${part}`, { method: "PUT", headers: { "Content-Type": "application/octet-stream", "Content-Length": String(bytes.length) }, body: new Uint8Array(bytes), signal: AbortSignal.timeout(12e4) });
+  }
+  completeEncoding(id) {
+    return this.request(`/api/encoding/${encodeURIComponent(id)}/complete`, { method: "POST" });
+  }
+  retryEncoding(id) {
+    return this.request(`/api/encoding/${encodeURIComponent(id)}/retry`, { method: "POST" });
+  }
+  createCloudRun(input) {
+    return this.request("/api/cloud/runs", { method: "POST", body: JSON.stringify(input) });
+  }
+  cloudRun(id) {
+    return this.request(`/api/cloud/runs/${encodeURIComponent(id)}`);
+  }
+  cancelCloudRun(id) {
+    return this.request(`/api/cloud/runs/${encodeURIComponent(id)}/cancel`, { method: "POST" });
+  }
+  health() {
+    return this.request("/api/health", {}, false);
+  }
+  agentSession() {
+    return this.request("/api/agent/session", { signal: AbortSignal.timeout(5e3) });
+  }
+  reportCliCommand(input) {
+    return this.request("/api/analytics/cli-command", { method: "POST", body: JSON.stringify(input) });
+  }
+  createRecording(input) {
+    return this.request("/api/recordings", { method: "POST", body: JSON.stringify(input) });
+  }
+  markRecordingStarted(recordingId, input) {
+    return this.request(`/api/recordings/${recordingId}/local-started`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  markRecordingStopped(recordingId, input) {
+    return this.request(`/api/recordings/${recordingId}/local-stopped`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  submitRecordingFeedback(recordingId, input) {
+    return this.request(recordingId ? `/api/recordings/${recordingId}/feedback` : "/api/feedback", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  provisionVideo(recordingId, input) {
+    return this.request(`/api/recordings/${recordingId}/video-upload`, { method: "POST", body: JSON.stringify(input) });
+  }
+  recordingStatus(recordingId) {
+    return this.request(`/api/recordings/${recordingId}`);
+  }
+  cancelRecording(recordingId, reason = "cancelled_by_agent") {
+    return this.request(`/api/recordings/${recordingId}/cancel`, {
+      method: "POST",
+      body: JSON.stringify({ reason })
+    });
+  }
+  async waitUntilPlayable(recordingId, timeoutMs = 10 * 6e4) {
+    const deadline = Date.now() + timeoutMs;
+    let intervalMs = 1e3;
+    while (Date.now() < deadline) {
+      const recording = await this.recordingStatus(recordingId);
+      if (recording.status === "ready" && recording.shareUrl) {
+        return { ...recording, shareUrl: new URL(recording.shareUrl, this.apiUrl).toString() };
+      }
+      if (recording.status === "failed") throw new Error(`processing_failed: ${recording.failure_message ?? "Cloudflare Stream could not process the recording."}`);
+      process.stderr.write(`\rprocessing ${recording.status.padEnd(12)}`);
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+      intervalMs = Math.min(5e3, Math.round(intervalMs * 1.4));
+    }
+    throw new Error("processing_failed: Timed out waiting for the recording to become playable. Run `rill record status <recording-id>` to continue checking.");
+  }
+  async uploadVideo(uploadUrl, filePath) {
+    const file2 = await stat(filePath);
+    if (uploadUrl.startsWith(this.apiUrl)) {
+      const response = await fetch(uploadUrl, { method: "PUT", headers: { "Content-Length": String(file2.size) }, body: createReadStream(filePath), duplex: "half" });
+      if (!response.ok) throw new Error(`Video upload failed (${response.status}).`);
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      const upload = new Upload(createReadStream(filePath), {
+        uploadUrl,
+        uploadSize: file2.size,
+        retryDelays: [0, 1e3, 3e3, 5e3, 1e4],
+        removeFingerprintOnSuccess: true,
+        onError: reject,
+        onSuccess: () => resolve(),
+        onProgress: (sent, total) => process.stderr.write(`\ruploading ${Math.round(sent / total * 100)}%`)
+      });
+      upload.start();
+    });
+    process.stderr.write("\n");
+  }
+  async uploadDiagnostics(recordingId, filePath, summary) {
+    const body = await readFile(filePath);
+    return this.request(`/api/recordings/${recordingId}/diagnostics`, { method: "PUT", headers: { "Content-Encoding": "gzip", "Content-Type": "application/x-ndjson", "Content-Length": String(body.length), "X-Rill-Summary": JSON.stringify(summary) }, body });
+  }
+  createDeviceAuthorization(input) {
+    return this.request("/api/device/authorizations", { method: "POST", body: JSON.stringify(input) }, false);
+  }
+  pollDeviceAuthorization(deviceCode) {
+    return this.request("/api/device/token", { method: "POST", body: JSON.stringify({ deviceCode }) }, false);
+  }
+  inspect(shareUrl) {
+    const url2 = new URL(shareUrl);
+    const slug = url2.pathname.split("/").filter(Boolean).at(-1);
+    if (!slug) throw new Error("The share URL does not contain a slug.");
+    return fetch(`${url2.origin}/api/public/shares/${encodeURIComponent(slug)}/context`, { headers: { Accept: "application/json" } }).then(async (response) => {
+      if (!response.ok) throw new Error(`Could not inspect the share link (${response.status}).`);
+      return response.json();
+    });
+  }
+  async request(path, init = {}, authenticated = true) {
+    const headers = new Headers(init.headers);
+    if (init.body && !headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+    if (authenticated) {
+      if (!this.token) throw new Error("authentication_required: Run `rill login` or set RILL_TOKEN.");
+      headers.set("Authorization", `Bearer ${this.token}`);
+    }
+    const response = await fetch(`${this.apiUrl}${path}`, { ...init, headers });
+    const value = await response.json().catch(() => null);
+    if (!response.ok && value?.error?.code && value.error.message) {
+      throw new ControlPlaneError(value.error.code, value.error.message, value.error.recovery, value.error.details, response.status);
+    }
+    if (!response.ok) throw new ControlPlaneHttpError(response.status);
+    return value;
+  }
+};
+
+// src/remote-encoding.ts
+async function withFrameUploadRetry(upload, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await upload();
+    } catch (error51) {
+      const status = error51 instanceof ControlPlaneError || error51 instanceof ControlPlaneHttpError ? error51.httpStatus : void 0;
+      const transient = status !== void 0 ? status === 408 || status === 429 || status >= 500 : error51 instanceof TypeError || error51 instanceof DOMException && ["TimeoutError", "AbortError"].includes(error51.name);
+      if (!transient || attempt >= 7) throw error51;
+      const delay = Math.min(15e3, 1e3 * 2 ** attempt);
+      process.stderr.write(`
+Frame upload interrupted; retrying in ${delay / 1e3}s.
+`);
+      await sleep(delay);
+    }
+  }
+}
+async function submitFrameCapture(client, id, directory) {
+  const manifest = frameManifestSchema.parse(JSON.parse(await readFile2(join(directory, "capture-manifest.json"), "utf8")));
+  let status = await client.beginEncoding(id, manifest);
+  if (status.status === "failed") status = await client.retryEncoding(id);
+  if (status.status !== "uploading") {
+    if (["expired", "cancelled"].includes(status.status)) throw new Error(`Capture ${status.status}; it cannot be retried.`);
+    return status;
+  }
+  const file2 = await open(join(directory, "frames.bin"), "r");
+  try {
+    const total = manifest.frames.reduce((n, f) => n + f.size, 0);
+    if ((await file2.stat()).size !== total) throw new Error("Capture bytes do not match the manifest.");
+    const uploaded = new Set(status.uploadedParts);
+    for (let part = 0; part < Math.ceil(total / ENCODING_PART_BYTES); part++) {
+      if (uploaded.has(part)) continue;
+      const bytes = Buffer.alloc(Math.min(ENCODING_PART_BYTES, total - part * ENCODING_PART_BYTES));
+      let offset = 0;
+      while (offset < bytes.length) {
+        const r = await file2.read(bytes, offset, bytes.length - offset, part * ENCODING_PART_BYTES + offset);
+        if (!r.bytesRead) throw new Error("Incomplete capture bytes.");
+        offset += r.bytesRead;
+      }
+      await withFrameUploadRetry(() => client.uploadEncodingPart(id, part, bytes));
+      process.stderr.write(`\ruploading frames ${Math.round(Math.min(total, (part + 1) * ENCODING_PART_BYTES) / total * 100)}%`);
+    }
+  } finally {
+    await file2.close();
+  }
+  return client.completeEncoding(id);
+}
+async function waitForEncoding(client, id, timeoutMs = 30 * 6e4) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const status = await client.encodingStatus(id);
+    if (status.status === "ready") return { ...status, ...await client.recordingStatus(id), recordingId: id };
+    if (["failed", "expired", "cancelled"].includes(status.status)) throw new Error(`${status.error ?? status.status}. Retry with rill record retry ${id}; capture expires ${status.expiresAt}.`);
+    process.stderr.write(`\r${status.status.padEnd(20)}`);
+    await new Promise((r) => setTimeout(r, 2e3));
+  }
+  throw new Error(`Encoding continues remotely. Check rill record status ${id}.`);
+}
+
+// src/cli.ts
+import { spawn as spawn6 } from "child_process";
+import { Command } from "commander";
+import { hostname as hostname3 } from "os";
+import { basename, dirname as dirname2 } from "path";
+import { readdir as readdir2, rm as rm4, stat as stat3 } from "fs/promises";
+
+// ../recorder/src/client.ts
+import { request } from "http";
+import { spawn } from "child_process";
+
+// ../recorder/src/paths.ts
+import { homedir, tmpdir } from "os";
+import { join as join2 } from "path";
+var rillDirectory = () => process.env.RILL_HOME ?? join2(homedir(), ".rill");
+var daemonSocketPath = () => process.env.RILL_SOCKET ?? join2(rillDirectory(), "recorder-v2.sock");
+var daemonStatePath = () => join2(rillDirectory(), "sessions-v2.json");
+var recordingTempRoot = () => process.env.RILL_TEMP ?? join2(tmpdir(), "rill-recordings");
+
+// ../recorder/src/client.ts
+async function ensureDaemon(cliEntryPath) {
+  try {
+    await callDaemon("GET", "/health");
+    return;
+  } catch {
+  }
+  const child = spawn(process.execPath, [cliEntryPath, "daemon"], { detached: true, stdio: "ignore", env: process.env });
+  child.unref();
+  const deadline = Date.now() + 1e4;
+  while (Date.now() < deadline) {
+    try {
+      await callDaemon("GET", "/health");
+      return;
+    } catch {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  throw new Error("The local recorder service did not start.");
+}
+function startRecording(input) {
+  return callDaemon("POST", "/sessions", input);
+}
+function stopRecording(recordingId) {
+  return callDaemon("POST", `/sessions/${encodeURIComponent(recordingId)}/stop`, {});
+}
+function recordingStatus(recordingId) {
+  return callDaemon("GET", `/sessions/${encodeURIComponent(recordingId)}`);
+}
+function callDaemon(method, path, body) {
+  return new Promise((resolve, reject) => {
+    const payload = body === void 0 ? void 0 : Buffer.from(JSON.stringify(body));
+    const outgoing = request({ socketPath: daemonSocketPath(), method, path, headers: payload ? { "Content-Type": "application/json", "Content-Length": payload.length } : void 0 }, (incoming) => {
+      const chunks = [];
+      incoming.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+      incoming.on("end", () => {
+        try {
+          const value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+          if ((incoming.statusCode ?? 500) >= 400) reject(new Error(value.error?.message ?? `Recorder returned ${incoming.statusCode}.`));
+          else resolve(value);
+        } catch (error51) {
+          reject(error51);
+        }
+      });
+    });
+    outgoing.once("error", reject);
+    if (payload) outgoing.write(payload);
+    outgoing.end();
+  });
+}
+
+// ../recorder/src/retention.ts
+import { readdir, readFile as readFile3, rm } from "fs/promises";
+import { join as join3 } from "path";
+async function purgeExpiredRemoteCaptures(root, now = Date.now()) {
+  const removed = [];
+  for (const id of await readdir(root).catch(() => [])) {
+    if (!/^rec_[a-zA-Z0-9_-]+$/.test(id)) continue;
+    const directory = join3(root, id);
+    try {
+      const marker = JSON.parse(await readFile3(join3(directory, "remote-capture.json"), "utf8"));
+      if (typeof marker.expiresAt !== "number" || marker.expiresAt > now) continue;
+      await rm(directory, { recursive: true, force: true });
+      removed.push(id);
+    } catch {
+    }
+  }
+  return removed;
+}
+async function hasRetainedRemoteCaptures(root) {
+  for (const id of await readdir(root).catch(() => [])) {
+    if (!/^rec_[a-zA-Z0-9_-]+$/.test(id)) continue;
+    try {
+      const marker = JSON.parse(await readFile3(join3(root, id, "remote-capture.json"), "utf8"));
+      if (typeof marker.expiresAt === "number" && Number.isFinite(marker.expiresAt)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+
+// ../recorder/src/daemon.ts
+import { createServer as createServer2 } from "http";
+import { mkdir as mkdir4, readFile as readFile5, unlink, writeFile as writeFile4, rename, stat as stat2 } from "fs/promises";
+import { dirname, join as join7 } from "path";
+
 // ../contracts/src/recording.ts
 var cursorAppearanceSchema = external_exports.object({
   enabled: external_exports.boolean().default(true),
@@ -14755,8 +15030,8 @@ async function attachCursorOverlay(page, cdp, input) {
 import { chromium } from "playwright-core";
 import { spawn as spawn3 } from "child_process";
 import { createServer } from "net";
-import { mkdir as mkdir2, mkdtemp, rm } from "fs/promises";
-import { join as join3 } from "path";
+import { mkdir as mkdir3, mkdtemp, rm as rm2, writeFile as writeFile3 } from "fs/promises";
+import { join as join6 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 
 // ../recorder/src/bundle.ts
@@ -14835,27 +15110,70 @@ function redactJson(value, depth = 0) {
   return value;
 }
 
-// ../recorder/src/screencast.ts
-import { mkdir, writeFile } from "fs/promises";
+// ../recorder/src/encoding.ts
+import { open as open2, writeFile, mkdir } from "fs/promises";
 import { spawn as spawn2 } from "child_process";
-import { join as join2 } from "path";
-import { once as once2 } from "events";
-function createFfconcatManifest(frames, expectedDurationSeconds) {
-  if (!frames.length) throw new Error("No video frames were captured.");
-  const orderedFrames = frames.toSorted((left, right) => left.timestamp - right.timestamp);
-  const firstTimestamp = orderedFrames[0].timestamp;
-  const lines = ["ffconcat version 1.0"];
-  for (let index = 0; index < orderedFrames.length; index += 1) {
-    const frame = orderedFrames[index];
-    const next = orderedFrames[index + 1];
-    const elapsedAtFrame = Math.max(0, frame.timestamp - firstTimestamp);
-    const duration3 = next ? Math.max(1 / 60, next.timestamp - frame.timestamp) : Math.max(1 / 60, expectedDurationSeconds - elapsedAtFrame);
-    lines.push(`file '${frame.path.replaceAll("'", "'\\''")}'`, `duration ${duration3.toFixed(6)}`);
-  }
-  lines.push(`file '${orderedFrames.at(-1).path.replaceAll("'", "'\\''")}'`);
-  return `${lines.join("\n")}
-`;
+import { join as join4 } from "path";
+var active = 0;
+var waiting = [];
+function encodingConcurrency() {
+  const n = Number(process.env.RILL_ENCODING_CONCURRENCY ?? 2);
+  if (!Number.isInteger(n) || n < 1 || n > 8) throw new Error("Invalid RILL_ENCODING_CONCURRENCY");
+  return n;
+}
+async function withEncodingSlot(work) {
+  if (active >= encodingConcurrency()) await new Promise((resolve) => waiting.push(resolve));
+  else active++;
+  try {
+    return await work();
+  } finally {
+    const next = waiting.shift();
+    if (next) next();
+    else active--;
+  }
+}
+async function encodeFrames(directory, manifest, output, signal) {
+  frameManifestSchema.parse(manifest);
+  return withEncodingSlot(async () => {
+    signal?.throwIfAborted();
+    const lines = ["ffconcat version 1.0"];
+    for (let i = 0; i < manifest.frames.length; i++) {
+      const next = manifest.frames[i + 1];
+      const duration3 = next ? next.timestamp - manifest.frames[i].timestamp : manifest.durationSeconds - (manifest.frames[i].timestamp - manifest.frames[0].timestamp);
+      lines.push(`file 'frame-${String(i).padStart(6, "0")}.jpg'`, `duration ${Math.max(1 / 60, duration3).toFixed(6)}`);
+    }
+    lines.push(`file 'frame-${String(manifest.frames.length - 1).padStart(6, "0")}.jpg'`);
+    await writeFile(join4(directory, "frames.ffconcat"), lines.join("\n") + "\n", { mode: 384 });
+    const threads = Number(process.env.RILL_FFMPEG_THREADS ?? 1);
+    if (!Number.isInteger(threads) || threads < 1 || threads > 16) throw new Error("Invalid RILL_FFMPEG_THREADS");
+    await new Promise((resolve, reject) => {
+      const child = spawn2(process.env.RILL_FFMPEG ?? "ffmpeg", ["-hide_banner", "-loglevel", "error", "-protocol_whitelist", "file", "-f", "concat", "-safe", "1", "-i", "frames.ffconcat", "-vsync", "vfr", "-pix_fmt", "yuv420p", "-c:v", "libvpx-vp9", "-deadline", "good", "-cpu-used", "4", "-threads", String(threads), "-b:v", "0", "-crf", "32", "-y", output], { cwd: directory, stdio: ["ignore", "ignore", "pipe"] });
+      let stderr = "";
+      child.stderr.on("data", (chunk) => {
+        stderr = (stderr + String(chunk)).slice(-2e3);
+      });
+      const abort = () => child.kill("SIGKILL");
+      const timer = setTimeout(abort, 20 * 6e4);
+      signal?.addEventListener("abort", abort, { once: true });
+      const clean = () => {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", abort);
+      };
+      child.once("error", (error51) => {
+        clean();
+        reject(error51);
+      });
+      child.once("exit", (code) => {
+        clean();
+        code === 0 ? resolve() : reject(new Error(`ffmpeg failed (${code}): ${stderr}`));
+      });
+    });
+  });
 }
+
+// ../recorder/src/screencast.ts
+import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile4, open as open3 } from "fs/promises";
+import { join as join5 } from "path";
 var ScreencastRecorder = class {
   constructor(session, directory, width, height) {
     this.session = session;
@@ -14867,13 +15185,24 @@ var ScreencastRecorder = class {
   pendingWrites = /* @__PURE__ */ new Set();
   started = false;
   frameCounter = 0;
+  frameBytes = 0;
+  captureError;
   async start() {
-    await mkdir(this.directory, { recursive: true, mode: 448 });
+    await mkdir2(this.directory, { recursive: true, mode: 448 });
     this.session.on("Page.screencastFrame", (payload) => {
-      const path = join2(this.directory, `frame-${String(this.frameCounter).padStart(6, "0")}.jpg`);
+      const bytes = Buffer.from(payload.data, "base64");
+      if (this.frameCounter >= 36e3 || this.frameBytes + bytes.length > ENCODING_MAX_BYTES || bytes.length > ENCODING_PART_BYTES) {
+        this.captureError = new Error("Capture exceeds the remote encoding frame or byte limit.");
+        void this.session.send("Page.screencastFrameAck", { sessionId: payload.sessionId }).catch(() => void 0);
+        return;
+      }
+      this.frameBytes += bytes.length;
+      const path = join5(this.directory, `frame-${String(this.frameCounter).padStart(6, "0")}.jpg`);
       this.frameCounter += 1;
-      const write = writeFile(path, Buffer.from(payload.data, "base64"), { mode: 384 }).then(() => {
+      const write = writeFile2(path, bytes, { mode: 384 }).then(() => {
         this.frames.push({ path, timestamp: payload.metadata.timestamp ?? Date.now() / 1e3 });
+      }).catch((error51) => {
+        this.captureError = error51 instanceof Error ? error51 : new Error(String(error51));
       }).finally(() => {
         this.pendingWrites.delete(write);
         void this.session.send("Page.screencastFrameAck", { sessionId: payload.sessionId }).catch(() => void 0);
@@ -14884,21 +15213,27 @@ var ScreencastRecorder = class {
     await this.session.send("Page.startScreencast", { format: "jpeg", quality: 82, maxWidth: this.width, maxHeight: this.height, everyNthFrame: 1 });
     this.started = true;
   }
-  async stop(outputPath, expectedDurationSeconds) {
+  async stop(outputPath, expectedDurationSeconds, captureOnly = false) {
     if (this.started) await this.session.send("Page.stopScreencast").catch(() => void 0);
     await new Promise((resolve) => setTimeout(resolve, 120));
     await Promise.all(this.pendingWrites);
+    if (this.captureError) throw this.captureError;
     if (!this.frames.length) throw new Error("No video frames were captured.");
-    const manifestPath = join2(this.directory, "frames.ffconcat");
-    await writeFile(manifestPath, createFfconcatManifest(this.frames, expectedDurationSeconds), { mode: 384 });
-    const ffmpeg = process.env.RILL_FFMPEG ?? "ffmpeg";
-    const processHandle = spawn2(ffmpeg, ["-hide_banner", "-loglevel", "error", "-f", "concat", "-safe", "0", "-i", manifestPath, "-vsync", "vfr", "-pix_fmt", "yuv420p", "-c:v", "libvpx-vp9", "-b:v", "0", "-crf", "32", "-y", outputPath], { stdio: ["ignore", "ignore", "pipe"] });
-    let stderr = "";
-    processHandle.stderr.on("data", (chunk) => {
-      stderr += String(chunk);
-    });
-    const [exitCode] = await once2(processHandle, "exit");
-    if (exitCode !== 0) throw new Error(`ffmpeg could not finalize the recording: ${stderr.trim()}`);
+    const ordered = this.frames.toSorted((a, b) => a.timestamp - b.timestamp);
+    const frames = [];
+    const bundle = await open3(join5(this.directory, "frames.bin"), "w", 384);
+    try {
+      for (const frame of ordered) {
+        const bytes = await readFile4(frame.path);
+        await bundle.writeFile(bytes);
+        frames.push({ timestamp: frame.timestamp, size: bytes.length });
+      }
+    } finally {
+      await bundle.close();
+    }
+    const manifest = frameManifestSchema.parse({ version: 1, durationSeconds: Math.min(600, expectedDurationSeconds), width: this.width, height: this.height, frames });
+    await writeFile2(join5(this.directory, "capture-manifest.json"), JSON.stringify(manifest), { mode: 384 });
+    if (!captureOnly) await encodeFrames(this.directory, manifest, outputPath);
     return { frameCount: this.frames.length, outputPath };
   }
 };
@@ -14932,6 +15267,7 @@ var RecordingSession = class _RecordingSession {
   bodyBytes = 0;
   truncated = false;
   constructor(options, runtime) {
+    this.encoding = options.encoding ?? "local";
     this.recordingId = options.recordingId;
     this.cdpUrl = runtime.cdpUrl;
     this.browser = runtime.browser;
@@ -14945,10 +15281,11 @@ var RecordingSession = class _RecordingSession {
   static async start(options) {
     const width = options.width ?? 1280;
     const height = options.height ?? 720;
-    await mkdir2(options.outputDirectory, { recursive: true, mode: 448 });
+    await mkdir3(options.outputDirectory, { recursive: true, mode: 448 });
+    if (options.encoding === "remote") await writeFile3(join6(options.outputDirectory, "remote-capture.json"), JSON.stringify({ expiresAt: Date.now() + 864e5 }), { mode: 384 });
     const runtime = options.cdpUrl ? await connectAttached(options.cdpUrl, options.outputDirectory) : await launchManaged({ headed: options.headed ?? false, width, height, outputDirectory: options.outputDirectory, proxyServer: options.proxyServer });
     const cdpSession = await runtime.context.newCDPSession(runtime.page);
-    const screencast = new ScreencastRecorder(cdpSession, join3(options.outputDirectory, "frames"), width, height);
+    const screencast = new ScreencastRecorder(cdpSession, join6(options.outputDirectory, "frames"), width, height);
     const session = new _RecordingSession(options, { ...runtime, screencast });
     try {
       await session.attachDiagnostics(options.captureNetworkBodies ?? false);
@@ -14980,8 +15317,8 @@ var RecordingSession = class _RecordingSession {
     if (this.maxTimer) clearTimeout(this.maxTimer);
     const durationSeconds = Math.max(0.1, (Date.now() - this.startedAt.getTime()) / 1e3);
     const outputDirectory = this.outputDirectory;
-    const videoPath = join3(outputDirectory, "recording.webm");
-    const diagnosticsPath = join3(outputDirectory, "diagnostics-v1.ndjson.gz");
+    const videoPath = join6(outputDirectory, "recording.webm");
+    const diagnosticsPath = join6(outputDirectory, "diagnostics-v1.ndjson.gz");
     const bundle = {
       schemaVersion: 1,
       capturePolicyVersion: "safe-default-v1",
@@ -14998,21 +15335,22 @@ var RecordingSession = class _RecordingSession {
     try {
       const safeBundle = JSON.parse(this.secretValues.reduce((text, secret) => text.split(JSON.stringify(secret).slice(1, -1)).join("[redacted]"), JSON.stringify(bundle)));
       await writeBundle(safeBundle, diagnosticsPath);
-      await this.screencast.stop(videoPath, durationSeconds);
+      await this.screencast.stop(videoPath, durationSeconds, this.encoding === "remote");
     } finally {
       await this.removeCursorOverlay?.();
       if (this.browserProcess) {
         await this.browser.close().catch(() => void 0);
         await terminateBrowser(this.browserProcess);
-        if (this.profileDirectory) await rm(this.profileDirectory, { recursive: true, force: true }).catch(() => void 0);
+        if (this.profileDirectory) await rm2(this.profileDirectory, { recursive: true, force: true }).catch(() => void 0);
       }
     }
     const consoleErrors = this.consoleEvents.filter((event) => event.severity === "error").length;
     const failedRequests = this.networkEvents.filter((event) => event.failureReason).length;
     const httpErrors = this.networkEvents.filter((event) => (event.status ?? 0) >= 400).length;
-    return { recordingId: this.recordingId, videoPath, diagnosticsPath, durationSeconds, stoppedReason: reason, diagnostics: { consoleErrors, failedRequests, httpErrors, truncated: this.truncated, bodyCaptureEnabled: this.captureNetworkBodies } };
+    return { recordingId: this.recordingId, videoPath, ...this.encoding === "remote" ? { frameDirectory: join6(outputDirectory, "frames") } : {}, diagnosticsPath, durationSeconds, stoppedReason: reason, diagnostics: { consoleErrors, failedRequests, httpErrors, truncated: this.truncated, bodyCaptureEnabled: this.captureNetworkBodies } };
   }
   captureNetworkBodies = false;
+  encoding = "local";
   outputDirectory = "";
   async attachDiagnostics(captureNetworkBodies) {
     this.captureNetworkBodies = captureNetworkBodies;
@@ -15121,7 +15459,7 @@ var RecordingSession = class _RecordingSession {
 };
 async function launchManaged(options) {
   const port = await getAvailablePort();
-  const profileDirectory = await mkdtemp(join3(tmpdir2(), "rill-chrome-"));
+  const profileDirectory = await mkdtemp(join6(tmpdir2(), "rill-chrome-"));
   const executable = findChromeExecutable();
   const args = [
     `--remote-debugging-port=${port}`,
@@ -15150,7 +15488,7 @@ async function launchManaged(options) {
     return { cdpUrl, browser, context, page, browserProcess, profileDirectory };
   } catch (error51) {
     await terminateBrowser(browserProcess);
-    await rm(profileDirectory, { recursive: true, force: true }).catch(() => void 0);
+    await rm2(profileDirectory, { recursive: true, force: true }).catch(() => void 0);
     throw error51;
   }
 }
@@ -15201,17 +15539,22 @@ var sessions = /* @__PURE__ */ new Map();
 var lastActivity = Date.now();
 async function runDaemon() {
   const socketPath = daemonSocketPath();
-  await mkdir3(dirname(socketPath), { recursive: true, mode: 448 });
-  await mkdir3(recordingTempRoot(), { recursive: true, mode: 448 });
+  await mkdir4(dirname(socketPath), { recursive: true, mode: 448 });
+  await mkdir4(recordingTempRoot(), { recursive: true, mode: 448 });
   await restoreRecoverableSessions();
+  await purgeExpiredCaptures();
   await unlink(socketPath).catch((error51) => {
     if (error51.code !== "ENOENT") throw error51;
   });
   const server = createServer2((request2, response) => void route(request2, response));
   server.listen(socketPath, () => process.platform !== "win32" && import("fs/promises").then(({ chmod }) => chmod(socketPath, 384)));
   const idleTimer = setInterval(() => {
-    const hasActiveSession = [...sessions.values()].some((entry) => entry.state === "recording" || entry.state === "finalizing");
-    if (!hasActiveSession && Date.now() - lastActivity > 5 * 6e4) server.close(() => process.exit(0));
+    void (async () => {
+      await purgeExpiredCaptures();
+      const hasActiveSession = [...sessions.values()].some((entry) => entry.state === "recording" || entry.state === "finalizing");
+      const hasRetainedCapture = await hasRetainedRemoteCaptures(recordingTempRoot());
+      if (!hasActiveSession && !hasRetainedCapture && Date.now() - lastActivity > 5 * 6e4) server.close(() => process.exit(0));
+    })().catch(() => void 0);
   }, 3e4);
   idleTimer.unref();
   const close = () => {
@@ -15230,8 +15573,8 @@ async function route(request2, response) {
     if ([...sessions.values()].filter((entry) => entry.state === "recording").length >= 2) return json2(response, 429, { error: { code: "quota_exceeded", message: "This recorder already has two active sessions." } });
     try {
       const input = await readJson(request2);
-      if (!input.recordingId) return json2(response, 400, { error: { code: "validation_failed", message: "recordingId is required." } });
-      const outputDirectory = join4(recordingTempRoot(), input.recordingId);
+      if (!/^rec_[a-zA-Z0-9_-]+$/.test(input.recordingId)) return json2(response, 400, { error: { code: "validation_failed", message: "recordingId is required." } });
+      const outputDirectory = join7(recordingTempRoot(), input.recordingId);
       const session = await RecordingSession.start({ ...input, outputDirectory });
       const status = session.status();
       const entry = { session, base: { recordingId: status.recordingId, cdpUrl: status.cdpUrl, startedAt: status.startedAt }, state: "recording" };
@@ -15275,7 +15618,7 @@ function serializeEntry(entry) {
 }
 async function restoreRecoverableSessions() {
   try {
-    const value = JSON.parse(await readFile(daemonStatePath(), "utf8"));
+    const value = JSON.parse(await readFile5(daemonStatePath(), "utf8"));
     for (const [id, entry] of Object.entries(value)) {
       if (entry.status !== "ready" && entry.status !== "failed") continue;
       sessions.set(id, { base: { recordingId: entry.recordingId, cdpUrl: entry.cdpUrl, startedAt: entry.startedAt }, state: entry.status, result: entry.result, error: entry.error });
@@ -15285,8 +15628,10 @@ async function restoreRecoverableSessions() {
 }
 async function persistState() {
   const state = Object.fromEntries([...sessions.entries()].map(([id, entry]) => [id, serializeEntry(entry)]));
-  await writeFile2(daemonStatePath(), `${JSON.stringify(state, null, 2)}
+  const temporary = daemonStatePath() + "." + crypto.randomUUID() + ".tmp";
+  await writeFile4(temporary, `${JSON.stringify(state, null, 2)}
 `, { mode: 384 });
+  await rename(temporary, daemonStatePath());
 }
 async function readJson(request2) {
   const chunks = [];
@@ -15303,147 +15648,16 @@ function json2(response, status, value) {
   response.writeHead(status, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" });
   response.end(JSON.stringify(value));
 }
-
-// src/control-plane.ts
-import { createReadStream } from "fs";
-import { readFile as readFile2, stat } from "fs/promises";
-import { Upload } from "tus-js-client";
-var ControlPlaneError = class extends Error {
-  constructor(code, message, recovery, details) {
-    super(`${code}: ${message}${recovery ? `: ${recovery}` : ""}`);
-    this.code = code;
-    this.recovery = recovery;
-    this.details = details;
-    this.name = "ControlPlaneError";
-  }
-};
-var ControlPlaneClient = class {
-  constructor(apiUrl, token) {
-    this.apiUrl = apiUrl;
-    this.token = token;
-  }
-  createCloudRun(input) {
-    return this.request("/api/cloud/runs", { method: "POST", body: JSON.stringify(input) });
-  }
-  cloudRun(id) {
-    return this.request(`/api/cloud/runs/${encodeURIComponent(id)}`);
-  }
-  cancelCloudRun(id) {
-    return this.request(`/api/cloud/runs/${encodeURIComponent(id)}/cancel`, { method: "POST" });
-  }
-  health() {
-    return this.request("/api/health", {}, false);
+async function purgeExpiredCaptures() {
+  const removed = await purgeExpiredRemoteCaptures(recordingTempRoot());
+  for (const id of removed) sessions.delete(id);
+  let changed = removed.length > 0;
+  for (const [id, entry] of sessions) if (entry.result?.frameDirectory && !await stat2(entry.result.frameDirectory).catch(() => null)) {
+    sessions.delete(id);
+    changed = true;
   }
-  agentSession() {
-    return this.request("/api/agent/session", { signal: AbortSignal.timeout(5e3) });
-  }
-  reportCliCommand(input) {
-    return this.request("/api/analytics/cli-command", { method: "POST", body: JSON.stringify(input) });
-  }
-  createRecording(input) {
-    return this.request("/api/recordings", { method: "POST", body: JSON.stringify(input) });
-  }
-  markRecordingStarted(recordingId, input) {
-    return this.request(`/api/recordings/${recordingId}/local-started`, {
-      method: "POST",
-      body: JSON.stringify(input)
-    });
-  }
-  markRecordingStopped(recordingId, input) {
-    return this.request(`/api/recordings/${recordingId}/local-stopped`, {
-      method: "POST",
-      body: JSON.stringify(input)
-    });
-  }
-  submitRecordingFeedback(recordingId, input) {
-    return this.request(recordingId ? `/api/recordings/${recordingId}/feedback` : "/api/feedback", {
-      method: "POST",
-      body: JSON.stringify(input)
-    });
-  }
-  provisionVideo(recordingId, input) {
-    return this.request(`/api/recordings/${recordingId}/video-upload`, { method: "POST", body: JSON.stringify(input) });
-  }
-  recordingStatus(recordingId) {
-    return this.request(`/api/recordings/${recordingId}`);
-  }
-  cancelRecording(recordingId, reason = "cancelled_by_agent") {
-    return this.request(`/api/recordings/${recordingId}/cancel`, {
-      method: "POST",
-      body: JSON.stringify({ reason })
-    });
-  }
-  async waitUntilPlayable(recordingId, timeoutMs = 10 * 6e4) {
-    const deadline = Date.now() + timeoutMs;
-    let intervalMs = 1e3;
-    while (Date.now() < deadline) {
-      const recording = await this.recordingStatus(recordingId);
-      if (recording.status === "ready" && recording.shareUrl) {
-        return { ...recording, shareUrl: new URL(recording.shareUrl, this.apiUrl).toString() };
-      }
-      if (recording.status === "failed") throw new Error(`processing_failed: ${recording.failure_message ?? "Cloudflare Stream could not process the recording."}`);
-      process.stderr.write(`\rprocessing ${recording.status.padEnd(12)}`);
-      await new Promise((resolve) => setTimeout(resolve, intervalMs));
-      intervalMs = Math.min(5e3, Math.round(intervalMs * 1.4));
-    }
-    throw new Error("processing_failed: Timed out waiting for the recording to become playable. Run `rill record status <recording-id>` to continue checking.");
-  }
-  async uploadVideo(uploadUrl, filePath) {
-    const file2 = await stat(filePath);
-    if (uploadUrl.startsWith(this.apiUrl)) {
-      const response = await fetch(uploadUrl, { method: "PUT", headers: { "Content-Length": String(file2.size) }, body: createReadStream(filePath), duplex: "half" });
-      if (!response.ok) throw new Error(`Video upload failed (${response.status}).`);
-      return;
-    }
-    await new Promise((resolve, reject) => {
-      const upload = new Upload(createReadStream(filePath), {
-        uploadUrl,
-        uploadSize: file2.size,
-        retryDelays: [0, 1e3, 3e3, 5e3, 1e4],
-        removeFingerprintOnSuccess: true,
-        onError: reject,
-        onSuccess: () => resolve(),
-        onProgress: (sent, total) => process.stderr.write(`\ruploading ${Math.round(sent / total * 100)}%`)
-      });
-      upload.start();
-    });
-    process.stderr.write("\n");
-  }
-  async uploadDiagnostics(recordingId, filePath, summary) {
-    const body = await readFile2(filePath);
-    return this.request(`/api/recordings/${recordingId}/diagnostics`, { method: "PUT", headers: { "Content-Encoding": "gzip", "Content-Type": "application/x-ndjson", "Content-Length": String(body.length), "X-Rill-Summary": JSON.stringify(summary) }, body });
-  }
-  createDeviceAuthorization(input) {
-    return this.request("/api/device/authorizations", { method: "POST", body: JSON.stringify(input) }, false);
-  }
-  pollDeviceAuthorization(deviceCode) {
-    return this.request("/api/device/token", { method: "POST", body: JSON.stringify({ deviceCode }) }, false);
-  }
-  inspect(shareUrl) {
-    const url2 = new URL(shareUrl);
-    const slug = url2.pathname.split("/").filter(Boolean).at(-1);
-    if (!slug) throw new Error("The share URL does not contain a slug.");
-    return fetch(`${url2.origin}/api/public/shares/${encodeURIComponent(slug)}/context`, { headers: { Accept: "application/json" } }).then(async (response) => {
-      if (!response.ok) throw new Error(`Could not inspect the share link (${response.status}).`);
-      return response.json();
-    });
-  }
-  async request(path, init = {}, authenticated = true) {
-    const headers = new Headers(init.headers);
-    if (init.body && !headers.has("Content-Type")) headers.set("Content-Type", "application/json");
-    if (authenticated) {
-      if (!this.token) throw new Error("authentication_required: Run `rill login` or set RILL_TOKEN.");
-      headers.set("Authorization", `Bearer ${this.token}`);
-    }
-    const response = await fetch(`${this.apiUrl}${path}`, { ...init, headers });
-    const value = await response.json().catch(() => null);
-    if (!response.ok && value?.error?.code && value.error.message) {
-      throw new ControlPlaneError(value.error.code, value.error.message, value.error.recovery, value.error.details);
-    }
-    if (!response.ok) throw new Error(`Request failed (${response.status}).`);
-    return value;
-  }
-};
+  if (changed) await persistState();
+}
 
 // src/analytics.ts
 var commandCategories = /* @__PURE__ */ new Map([
@@ -15597,6 +15811,8 @@ var CLI_VERSION = packageJson.version;
 
 // src/doctor.ts
 var defaultDependencies = {
+  encoding: "remote",
+  encodingCapabilities: (apiUrl, token) => new ControlPlaneClient(apiUrl, token).encodingCapabilities(),
   nodeVersion: process.version,
   cliVersion: CLI_VERSION,
   chromePath: findChromeExecutable(),
@@ -15651,7 +15867,18 @@ async function runDoctor(apiUrl, overrides = {}) {
     }
   }
   checks.push(await executableCheck("chrome", dependencies.chromePath, ["--version"], dependencies.commandVersion, "Install Google Chrome or Chromium, or set RILL_CHROME_PATH to its executable."));
-  checks.push(await executableCheck("ffmpeg", dependencies.ffmpegPath, ["-version"], dependencies.commandVersion, process.platform === "darwin" ? "Install ffmpeg with `brew install ffmpeg`, or set RILL_FFMPEG." : "Install ffmpeg using the system package manager, or set RILL_FFMPEG."));
+  if (dependencies.encoding === "local") {
+    checks.push(await executableCheck("ffmpeg", dependencies.ffmpegPath, ["-version"], dependencies.commandVersion, process.platform === "darwin" ? "Install ffmpeg with `brew install ffmpeg`, or set RILL_FFMPEG." : "Install ffmpeg using the system package manager, or set RILL_FFMPEG."));
+  } else {
+    checks.push({ name: "ffmpeg", status: "skip", message: "Remote encoding does not require local FFmpeg." });
+    try {
+      const token = await dependencies.loadCredential(apiUrl);
+      if (!token || !(await dependencies.encodingCapabilities(apiUrl, token)).enabled) throw new Error("Remote encoding is not enabled for this workspace.");
+      checks.push({ name: "encoding", status: "pass", message: "Remote encoding is enabled." });
+    } catch (error51) {
+      checks.push({ name: "encoding", status: "fail", message: errorMessage(error51), recovery: "Use --encoding local until your workspace joins the private trial." });
+    }
+  }
   return { schemaVersion: 1, status: checks.some((check2) => check2.status === "fail") ? "error" : "ok", apiUrl, checks, ...runFeedbackFields(feedbackEnabled) };
 }
 async function executableCheck(name, path, args, run2, recovery) {
@@ -15760,13 +15987,23 @@ function controlPlaneUrl(environmentUrl) {
 }
 
 // src/cli.ts
+async function removeLocalCapture(id) {
+  await ensureDaemon(process.argv[1]);
+  const local = await recordingStatus(id).catch(() => null);
+  if (local?.result?.frameDirectory) await rm4(dirname2(local.result.videoPath), { recursive: true, force: true });
+}
+function watchEncoding(apiUrl, id, token) {
+  const child = spawn6(process.execPath, [process.argv[1], "--api-url", apiUrl, "encoding-watch", id], { detached: true, stdio: "ignore", env: { ...process.env, RILL_TOKEN: token } });
+  child.on("error", () => void 0);
+  child.unref();
+}
 var program = new Command();
 program.name("rill").description("Record, inspect, and share agent browser runs.").version(CLI_VERSION).option("--api-url <url>", "Rill control plane", controlPlaneUrl(process.env.RILL_API_URL)).option("--pretty", "Pretty-print JSON output", false).option("--json", "Output cloud run results as JSON", false);
 var activeTelemetry = null;
 program.command("daemon", { hidden: true }).action(() => runDaemon());
-program.command("doctor").description("Validate Rill prerequisites before recording.").action(async () => {
+program.command("doctor").description("Validate Rill prerequisites before recording.").option("--encoding <mode>", "remote or local", "remote").action(async (commandOptions) => {
   const options = program.opts();
-  const result = await runDoctor(options.apiUrl);
+  const result = await runDoctor(options.apiUrl, { encoding: commandOptions.encoding });
   emit(result, options.pretty);
   if (result.status === "error") process.exitCode = 1;
 });
@@ -15827,11 +16064,14 @@ for (const action of ["status", "cancel"]) cloudRun.command(action).argument("<r
   if (options.json || options.pretty) emit(customerRun(run2), options.pretty);
   else process.stdout.write(formatCloudRun(run2));
 });
-record2.command("start").option("--url <url>").option("--title <title>").option("--description <description>", "").option("--headed").option("--cdp-url <url>").option("--width <pixels>", "", "1280").option("--height <pixels>", "", "720").option("--max-duration <seconds>", "", "600").action(async (commandOptions) => {
+record2.command("start").option("--encoding <mode>", "remote or local", "remote").option("--url <url>").option("--title <title>").option("--description <description>", "").option("--headed").option("--cdp-url <url>").option("--width <pixels>", "", "1280").option("--height <pixels>", "", "720").option("--max-duration <seconds>", "", "600").action(async (commandOptions) => {
   const options = program.opts();
   const token = await loadCredential(options.apiUrl);
   const client = new ControlPlaneClient(options.apiUrl, token);
   const result = await withRunFeedback(() => client.agentSession(), async (rememberRecording) => {
+    if (!["local", "remote"].includes(commandOptions.encoding)) throw new Error("Encoding must be remote or local.");
+    if (commandOptions.encoding === "remote" && !(await client.encodingCapabilities()).enabled) throw new Error("Remote encoding is unavailable for this workspace. Use --encoding local.");
+    if (!Number.isFinite(Number(commandOptions.maxDuration)) || Number(commandOptions.maxDuration) < 1 || Number(commandOptions.maxDuration) > 600) throw new Error("Recording duration must be between 1 and 600 seconds.");
     const width = Number(commandOptions.width);
     const height = Number(commandOptions.height);
     const remote = await client.createRecording({ title: commandOptions.title ?? `Browser recording \xB7 ${(/* @__PURE__ */ new Date()).toISOString()}`, description: commandOptions.description, sourceUrl: commandOptions.url ?? null, width, height });
@@ -15839,7 +16079,7 @@ record2.command("start").option("--url <url>").option("--title <title>").option(
     const local = await startRecordingWithCompensation(remote, {
       startLocal: async () => {
         await ensureDaemon(process.argv[1]);
-        return startRecording({ recordingId: remote.recordingId, url: commandOptions.url, cdpUrl: commandOptions.cdpUrl, headed: Boolean(commandOptions.headed), width, height, maxDurationSeconds: Number(commandOptions.maxDuration), captureNetworkBodies: remote.bodyCaptureEnabled, cursorAppearance: remote.cursorAppearance });
+        return startRecording({ encoding: commandOptions.encoding, recordingId: remote.recordingId, url: commandOptions.url, cdpUrl: commandOptions.cdpUrl, headed: Boolean(commandOptions.headed), width, height, maxDurationSeconds: Number(commandOptions.maxDuration), captureNetworkBodies: remote.bodyCaptureEnabled, cursorAppearance: remote.cursorAppearance });
       },
       cancelRemote: (recordingId, reason) => client.cancelRecording(recordingId, reason)
     });
@@ -15867,10 +16107,19 @@ record2.command("stop").argument("<recording-id>").option("--no-wait").option("-
     diagnosticsAvailable: true,
     requestFeedback: commandOptions.feedback
   }).catch(() => null);
-  const video = await stat2(local.result.videoPath);
+  if (local.result.frameDirectory) {
+    await client.uploadDiagnostics(recordingId, local.result.diagnosticsPath, local.result.diagnostics);
+    const accepted = await submitFrameCapture(client, recordingId, local.result.frameDirectory);
+    const result2 = commandOptions.wait && record2.opts().wait !== false ? await waitForEncoding(client, recordingId) : accepted;
+    emit({ schemaVersion: 1, ...result2, ...recordingFeedbackFields(recordingId, stopped?.feedbackRequested ?? false) }, options.pretty);
+    if (result2.status === "ready") await rm4(dirname2(local.result.videoPath), { recursive: true, force: true });
+    else watchEncoding(options.apiUrl, recordingId, token);
+    return;
+  }
+  const video = await stat3(local.result.videoPath);
   const provisioned = await client.provisionVideo(recordingId, { sizeBytes: video.size, filename: basename(local.result.videoPath), uploadKind: "recorded_browser" });
   await Promise.all([client.uploadVideo(provisioned.uploadUrl, local.result.videoPath), client.uploadDiagnostics(recordingId, local.result.diagnosticsPath, local.result.diagnostics)]);
-  const remote = commandOptions.wait === false ? null : await client.waitUntilPlayable(recordingId);
+  const remote = commandOptions.wait === false || record2.opts().wait === false ? null : await client.waitUntilPlayable(recordingId);
   if (remote) process.stderr.write("\n");
   const result = {
     schemaVersion: 1,
@@ -15883,7 +16132,40 @@ record2.command("stop").argument("<recording-id>").option("--no-wait").option("-
     ...recordingFeedbackFields(recordingId, stopped?.feedbackRequested ?? false)
   };
   emit(result, options.pretty);
-  if (remote) await rm2(dirname2(local.result.videoPath), { recursive: true, force: true });
+  if (remote) await rm4(dirname2(local.result.videoPath), { recursive: true, force: true });
+});
+record2.command("retry").argument("<recording-id>").option("--no-wait").action(async (recordingId, commandOptions) => {
+  const options = program.opts();
+  const client = new ControlPlaneClient(options.apiUrl, await loadCredential(options.apiUrl));
+  const current = await client.encodingStatus(recordingId).catch((error51) => {
+    if (error51 instanceof ControlPlaneError && error51.code === "recording_not_found") return null;
+    throw error51;
+  });
+  let accepted = current;
+  if (!current || current.status === "uploading") {
+    await ensureDaemon(process.argv[1]);
+    const local = await recordingStatus(recordingId);
+    if (!local.result?.frameDirectory) throw new Error("Local capture is unavailable.");
+    await client.uploadDiagnostics(recordingId, local.result.diagnosticsPath, local.result.diagnostics);
+    accepted = await submitFrameCapture(client, recordingId, local.result.frameDirectory);
+  } else if (current.status === "failed") accepted = await client.retryEncoding(recordingId);
+  if (!accepted) throw new Error("Encoding job is unavailable.");
+  if (["expired", "cancelled"].includes(accepted.status)) throw new Error(`Recording ${accepted.status}.`);
+  const result = commandOptions.wait && record2.opts().wait !== false ? await waitForEncoding(client, recordingId) : accepted;
+  emit({ schemaVersion: 1, ...result }, options.pretty);
+  if (result.status === "ready") await removeLocalCapture(recordingId);
+  else watchEncoding(options.apiUrl, recordingId, await loadCredential(options.apiUrl));
+});
+program.command("encoding-watch", { hidden: true }).argument("<recording-id>").action(async (id) => {
+  if (!/^rec_[a-zA-Z0-9_-]+$/.test(id)) throw new Error("Invalid recording ID");
+  const options = program.opts();
+  const client = new ControlPlaneClient(options.apiUrl, await loadCredential(options.apiUrl));
+  const result = await waitForEncoding(client, id, 864e5);
+  if (result.status === "ready") {
+    await ensureDaemon(process.argv[1]);
+    const local = await recordingStatus(id).catch(() => null);
+    if (local?.result?.frameDirectory) await rm4(dirname2(local.result.videoPath), { recursive: true, force: true });
+  }
 });
 var feedback = program.command("feedback").description("Submit a short Rill product review for a recorded run.");
 feedback.command("submit").argument("[recording-id]", "Omit only when setup failed before a recording was created").requiredOption("--outcome <outcome>", "succeeded, failed, or abandoned").option("--helped <text>", "What went well or helped during setup and the run", "").option("--friction <text>", "What created friction during the run", "").option("--improvement <text>", "Possible Rill improvements, prioritized by usefulness", "").action(async (recordingId, commandOptions) => {
@@ -15905,6 +16187,15 @@ record2.command("status").argument("<recording-id>").action(async (recordingId)
   const options = program.opts();
   const token = await loadCredential(options.apiUrl);
   const client = new ControlPlaneClient(options.apiUrl, token);
+  try {
+    const encoding = await client.encodingStatus(recordingId);
+    const remote = encoding.status === "ready" ? await client.recordingStatus(recordingId) : {};
+    emit({ schemaVersion: 1, ...encoding, ...remote, recordingId, source: "remote" }, options.pretty);
+    if (encoding.status === "ready") await removeLocalCapture(recordingId);
+    return;
+  } catch (error51) {
+    if (!(error51 instanceof Error) || !error51.message.includes("recording_not_found")) throw error51;
+  }
   const status = await remoteAwareRecordingStatus(recordingId, {
     localStatus: async (id) => {
       await ensureDaemon(process.argv[1]);
@@ -15924,7 +16215,7 @@ program.command("upload").argument("<video-file>").option("--title <title>").opt
   const options = program.opts();
   const token = await loadCredential(options.apiUrl);
   const client = new ControlPlaneClient(options.apiUrl, token);
-  const file2 = await stat2(videoFile);
+  const file2 = await stat3(videoFile);
   const recording = await client.createRecording({ title: commandOptions.title ?? basename(videoFile), sourceUrl: null });
   const upload = await client.provisionVideo(recording.recordingId, { sizeBytes: file2.size, filename: basename(videoFile), uploadKind: "existing_video" });
   await client.uploadVideo(upload.uploadUrl, videoFile);
@@ -15940,19 +16231,19 @@ var drafts = program.command("drafts");
 drafts.command("list").action(async () => {
   const options = program.opts();
   const root = process.env.RILL_TEMP ?? `${process.env.TMPDIR ?? "/tmp"}/rill-recordings`;
-  const names = await readdir(root).catch(() => []);
+  const names = await readdir2(root).catch(() => []);
   emit({ schemaVersion: 1, drafts: names }, options.pretty);
 });
 drafts.command("purge").action(async () => {
   const options = program.opts();
   const root = process.env.RILL_TEMP ?? `${process.env.TMPDIR ?? "/tmp"}/rill-recordings`;
-  const names = await readdir(root).catch(() => []);
+  const names = await readdir2(root).catch(() => []);
   let purged = 0;
   for (const name of names) {
     const path = `${root}/${name}`;
-    const metadata = await stat2(path);
+    const metadata = await stat3(path);
     if (Date.now() - metadata.mtimeMs > 24 * 60 * 60 * 1e3) {
-      await rm2(path, { recursive: true, force: true });
+      await rm4(path, { recursive: true, force: true });
       purged += 1;
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runalabs/rill-cli",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Record, inspect, and share agent-controlled browser runs with Rill.",
   "license": "Apache-2.0",
   "repository": {