@runalabs/rill-cli 0.1.1 → 0.1.3

package/README.md

@@ -2,23 +2,23 @@
 
 Record, inspect, and share agent-controlled browser runs with Rill.
 
+After `rill record stop`, compatible agent hosts may receive `feedbackRequested: true`. They can submit a short Rill product review with `rill feedback submit <recording-id>`. Use `rill record stop <recording-id> --no-feedback` to opt out for one run.
+
 ## Install
 
 ```sh
-npm install --global @runalabs/rill-cli@0.1.1
+npm install --global @runalabs/rill-cli@0.1.3
 rill doctor
 ```
 
 Rill requires Node.js 22 or newer, Google Chrome or Chromium, and `ffmpeg`.
-The CLI defaults to the Rill private-alpha staging API. Set `RILL_API_URL` or
-pass `--api-url` to target another environment.
 
 ## Record
 
 ```sh
 rill login
 rill doctor
-rill record start --url https://staging.example.com --title "Agent reproduction"
+rill record start --url https://example.com --title "Agent reproduction"
 # Connect browser automation to the returned cdpUrl.
 rill record stop <recording-id>
 ```

package/dist/cli.js

@@ -603,9 +603,30 @@ var ControlPlaneClient = class {
   agentSession() {
     return this.request("/api/agent/session");
   }
+  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(`/api/recordings/${recordingId}/feedback`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
   provisionVideo(recordingId, input) {
     return this.request(`/api/recordings/${recordingId}/video-upload`, { method: "POST", body: JSON.stringify(input) });
   }
@@ -690,6 +711,33 @@ var ControlPlaneClient = class {
   }
 };
 
+// src/analytics.ts
+var commandCategories = /* @__PURE__ */ new Map([
+  ["doctor", "doctor"],
+  ["record start", "record_start"],
+  ["record stop", "record_stop"],
+  ["record status", "record_status"],
+  ["record cancel", "record_cancel"],
+  ["upload", "upload"],
+  ["drafts list", "drafts_list"],
+  ["drafts purge", "drafts_purge"]
+]);
+function cliCommandCategory(commandPath2) {
+  return commandCategories.get(commandPath2.join(" ")) ?? null;
+}
+function cliDurationBucket(milliseconds) {
+  if (milliseconds < 6e4) return "under_1m";
+  if (milliseconds < 5 * 6e4) return "1m_to_5m";
+  if (milliseconds < 15 * 6e4) return "5m_to_15m";
+  return "15m_plus";
+}
+function cliFailureCode(error) {
+  const directCode = typeof error === "object" && error !== null && "code" in error ? error.code : null;
+  if (typeof directCode === "string" && /^[a-z0-9_]{1,80}$/.test(directCode)) return directCode;
+  const message = error instanceof Error ? error.message : "";
+  return message.match(/^([a-z][a-z0-9_]{0,79}):/)?.[1] ?? "unexpected_error";
+}
+
 // src/keychain.ts
 import { spawn as spawn4 } from "child_process";
 var service = "rill";
@@ -785,8 +833,10 @@ async function runDoctor(apiUrl, overrides = {}) {
     checks.push({ name: "cli_version", status: "fail", message: `CLI ${dependencies.cliVersion} could not be checked against the API compatibility policy.`, version: dependencies.cliVersion, recovery: "Deploy a Rill API that advertises minimumCliVersion and recommendedCliVersion." });
   } else if (compareVersions(dependencies.cliVersion, health.minimumCliVersion) < 0) {
     checks.push({ name: "cli_version", status: "fail", message: `CLI ${dependencies.cliVersion} is older than the minimum supported version ${health.minimumCliVersion}.`, version: dependencies.cliVersion, recovery: `Run \`npm install --global @runalabs/rill-cli@${health.recommendedCliVersion}\`.` });
-  } else if (compareVersions(dependencies.cliVersion, health.recommendedCliVersion) !== 0) {
+  } else if (compareVersions(dependencies.cliVersion, health.recommendedCliVersion) < 0) {
     checks.push({ name: "cli_version", status: "warn", message: `CLI ${dependencies.cliVersion} is supported; ${health.recommendedCliVersion} is recommended.`, version: dependencies.cliVersion, recovery: `Run \`npm install --global @runalabs/rill-cli@${health.recommendedCliVersion}\`.` });
+  } else if (compareVersions(dependencies.cliVersion, health.recommendedCliVersion) > 0) {
+    checks.push({ name: "cli_version", status: "pass", message: `CLI ${dependencies.cliVersion} is supported.`, version: dependencies.cliVersion });
   } else {
     checks.push({ name: "cli_version", status: "pass", message: `CLI ${dependencies.cliVersion} is the recommended version.`, version: dependencies.cliVersion });
   }
@@ -889,9 +939,16 @@ async function remoteAwareRecordingStatus(recordingId, dependencies) {
   }
 }
 
+// src/config.ts
+var PRODUCTION_API_URL = "https://userill.dev";
+function controlPlaneUrl(environmentUrl) {
+  return environmentUrl ?? PRODUCTION_API_URL;
+}
+
 // src/cli.ts
 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", process.env.RILL_API_URL ?? "https://rill-staging.tight-shadow-8e12.workers.dev").option("--pretty", "Pretty-print JSON output", false);
+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);
+var activeTelemetry = null;
 program.command("daemon", { hidden: true }).action(() => runDaemon());
 program.command("doctor").description("Validate Rill prerequisites before recording.").action(async () => {
   const options = program.opts();
@@ -932,24 +989,51 @@ record.command("start").option("--url <url>").option("--title <title>").option("
     },
     cancelRemote: (recordingId, reason) => client.cancelRecording(recordingId, reason)
   });
+  await client.markRecordingStarted(remote.recordingId, {
+    cliVersion: CLI_VERSION,
+    os: process.platform,
+    arch: process.arch,
+    headed: Boolean(commandOptions.headed),
+    attached: Boolean(commandOptions.cdpUrl)
+  }).catch(() => void 0);
   emit({ schemaVersion: 1, recordingId: remote.recordingId, status: local.status, cdpUrl: local.cdpUrl, bodyCaptureEnabled: remote.bodyCaptureEnabled, maxDurationSeconds: Number(commandOptions.maxDuration) }, options.pretty);
 });
-record.command("stop").argument("<recording-id>").option("--no-wait").action(async (recordingId, commandOptions) => {
+record.command("stop").argument("<recording-id>").option("--no-wait").option("--no-feedback").action(async (recordingId, commandOptions) => {
   const options = program.opts();
   await ensureDaemon(process.argv[1]);
   const local = await stopRecording(recordingId);
   if (!local.result) throw new Error(local.error ?? "The recorder did not produce an artifact.");
   const token = await loadCredential(options.apiUrl);
   const client = new ControlPlaneClient(options.apiUrl, token);
+  const stopped = await client.markRecordingStopped(recordingId, {
+    durationSeconds: local.result.durationSeconds,
+    stoppedReason: local.result.stoppedReason,
+    diagnosticsAvailable: true,
+    requestFeedback: commandOptions.feedback
+  }).catch(() => null);
   const video = await stat2(local.result.videoPath);
-  const provisioned = await client.provisionVideo(recordingId, { sizeBytes: video.size, filename: basename(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);
   if (remote) process.stderr.write("\n");
-  const result = { schemaVersion: 1, recordingId, status: remote ? "ready" : "processing", shareUrl: remote?.shareUrl ?? null, durationSeconds: local.result.durationSeconds, stoppedReason: local.result.stoppedReason, diagnostics: local.result.diagnostics };
+  const result = { schemaVersion: 1, recordingId, status: remote ? "ready" : "processing", shareUrl: remote?.shareUrl ?? null, durationSeconds: local.result.durationSeconds, stoppedReason: local.result.stoppedReason, diagnostics: local.result.diagnostics, feedbackRequested: stopped?.feedbackRequested ?? false };
   emit(result, options.pretty);
   if (remote) await rm2(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>").requiredOption("--outcome <outcome>", "succeeded, failed, or abandoned").option("--helped <text>", "What helped during the run", "").option("--friction <text>", "What created friction during the run", "").option("--improvement <text>", "The single most useful Rill improvement", "").action(async (recordingId, commandOptions) => {
+  if (!["succeeded", "failed", "abandoned"].includes(commandOptions.outcome)) throw new Error("validation_failed: Feedback outcome must be succeeded, failed, or abandoned.");
+  if (![commandOptions.helped, commandOptions.friction, commandOptions.improvement].some((value) => value.trim())) throw new Error("validation_failed: Include at least one short feedback answer.");
+  const options = program.opts();
+  const token = await loadCredential(options.apiUrl);
+  const client = new ControlPlaneClient(options.apiUrl, token);
+  await client.submitRecordingFeedback(recordingId, {
+    outcome: commandOptions.outcome,
+    whatHelped: commandOptions.helped,
+    friction: commandOptions.friction,
+    improvement: commandOptions.improvement
+  });
+});
 record.command("status").argument("<recording-id>").action(async (recordingId) => {
   const options = program.opts();
   const token = await loadCredential(options.apiUrl);
@@ -975,7 +1059,7 @@ program.command("upload").argument("<video-file>").option("--title <title>").opt
   const client = new ControlPlaneClient(options.apiUrl, token);
   const file = await stat2(videoFile);
   const recording = await client.createRecording({ title: commandOptions.title ?? basename(videoFile), sourceUrl: null });
-  const upload = await client.provisionVideo(recording.recordingId, { sizeBytes: file.size, filename: basename(videoFile) });
+  const upload = await client.provisionVideo(recording.recordingId, { sizeBytes: file.size, filename: basename(videoFile), uploadKind: "existing_video" });
   await client.uploadVideo(upload.uploadUrl, videoFile);
   const remote = commandOptions.wait === false ? null : await client.waitUntilPlayable(recording.recordingId);
   if (remote) process.stderr.write("\n");
@@ -1007,4 +1091,45 @@ drafts.command("purge").action(async () => {
   }
   emit({ schemaVersion: 1, purged }, options.pretty);
 });
-program.parseAsync().catch(fail);
+program.hook("preAction", async (_command, actionCommand) => {
+  const command = cliCommandCategory(commandPath(actionCommand));
+  if (!command) return;
+  const options = program.opts();
+  const token = await loadCredential(options.apiUrl).catch(() => null);
+  if (!token) return;
+  const client = new ControlPlaneClient(options.apiUrl, token);
+  const session = await client.agentSession().catch(() => null);
+  if (!session?.analyticsEnabled) return;
+  activeTelemetry = { client, command, startedAt: Date.now() };
+  await client.reportCliCommand({ phase: "started", command, cliVersion: CLI_VERSION, os: process.platform, arch: process.arch }).catch(() => void 0);
+});
+program.hook("postAction", async () => {
+  await finishCliTelemetry(process.exitCode ? new Error("command_reported_failure: Command returned a failure status.") : null);
+});
+program.parseAsync().catch(async (error) => {
+  await finishCliTelemetry(error);
+  fail(error);
+});
+function commandPath(actionCommand) {
+  const path = [];
+  let command = actionCommand;
+  while (command && command !== program) {
+    path.unshift(command.name());
+    command = command.parent;
+  }
+  return path;
+}
+async function finishCliTelemetry(error) {
+  const telemetry = activeTelemetry;
+  activeTelemetry = null;
+  if (!telemetry) return;
+  await telemetry.client.reportCliCommand({
+    phase: error ? "failed" : "completed",
+    command: telemetry.command,
+    cliVersion: CLI_VERSION,
+    os: process.platform,
+    arch: process.arch,
+    durationBucket: cliDurationBucket(Date.now() - telemetry.startedAt),
+    ...error ? { failureCode: cliFailureCode(error) } : {}
+  }).catch(() => void 0);
+}

package/package.json

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