@flowriki/agent 0.1.0-beta.46 → 0.1.0-beta.47

package/README.md

@@ -49,6 +49,14 @@ email"*. Claude reads your project's features, sign-in profiles and helpers,
 and uses them. You do not run `mcp` yourself — Claude starts it. It works
 alongside `start`, in a browser window of its own.
 
+**It keeps itself up to date.** `@latest` starts the newest Flowriki each time
+Claude connects, and while Claude stays connected Flowriki checks for a newer
+release every half hour and switches over to it between tasks — never while a
+flow is being written. The next answer says it was updated; if the new release
+brings new tools and Claude does not offer them yet, reconnect Flowriki in
+Claude (in Claude Code: `/mcp`, then Reconnect). The agent you run with `start`
+says when it is behind: `npm install -g @flowriki/agent@latest`, then restart it.
+
 ## What you do not need
 
 No checkout of Flowriki, and nothing to build. `connect` and `start` are the

package/dist/{chunk-LIURHWRP.js → chunk-AMXSHZYE.js}

@@ -6,7 +6,7 @@ import os from "os";
 import path from "path";
 import { createRequire } from "module";
 import { spawnSync } from "child_process";
-var AGENT_VERSION = "0.1.0-beta.46";
+var AGENT_VERSION = "0.1.0-beta.47";
 async function prepareBrowsers() {
   if (browsersReady()) {
     return { ok: true, already: true, message: "chromium is already installed" };
@@ -356,6 +356,29 @@ var ProjectMarkerSchema = z2.object({
   signature: z2.string()
 });
 var PRODUCTION_SERVICE = "https://flowriki-cloud.onrender.com";
+var AGENT_LATEST_URL = "https://registry.npmjs.org/@flowriki/agent/latest";
+function compareAgentVersions(a, b2) {
+  const split = (v) => {
+    const [core = "", pre = ""] = v.trim().replace(/^v/, "").split("-", 2);
+    return { core: core.split(".").map((n2) => Number(n2) || 0), pre: pre ? pre.split(".") : [] };
+  };
+  const x = split(a), y = split(b2);
+  for (let i = 0; i < Math.max(x.core.length, y.core.length); i++) {
+    const d = (x.core[i] ?? 0) - (y.core[i] ?? 0);
+    if (d) return Math.sign(d);
+  }
+  if (!x.pre.length || !y.pre.length) return x.pre.length === y.pre.length ? 0 : x.pre.length ? -1 : 1;
+  for (let i = 0; i < Math.max(x.pre.length, y.pre.length); i++) {
+    const p = x.pre[i], q = y.pre[i];
+    if (p === void 0) return -1;
+    if (q === void 0) return 1;
+    const np = Number(p), nq = Number(q);
+    const d = !Number.isNaN(np) && !Number.isNaN(nq) ? np - nq : p.localeCompare(q);
+    if (d) return Math.sign(d);
+  }
+  return 0;
+}
+var agentUpdateFor = (running2, latest) => Boolean(running2 && latest && running2 !== "test" && compareAgentVersions(latest, running2) > 0);
 
 // src/service.ts
 var BadServiceUrl = class extends Error {
@@ -482,11 +505,11 @@ async function verifyConnection(connection) {
 
 // src/engine/checkouts.ts
 import fs9 from "fs";
-import path11 from "path";
+import path12 from "path";
 
 // ../execution/dist/index.js
 import fs8 from "fs";
-import path10 from "path";
+import path11 from "path";
 
 // ../engine-playwright/dist/index.js
 import { randomBytes } from "crypto";
@@ -1431,11 +1454,13 @@ function sessionLanes(occurrences, defaultActorId) {
     return sessionId;
   };
   for (const occurrence of occurrences) {
-    const actorId = occurrence.actorId || defaultActorId || "default";
+    const person = occurrence.actorId || defaultActorId || "default";
+    const phone = occurrence.platform === "android" || occurrence.platform === "ios" ? occurrence.platform : void 0;
+    const actorId = phone ? `${phone}:${person}` : person;
     const continues = startOf(occurrence) === "continue";
     const asked = occurrence.start === "continue";
     const theirs = mine.get(actorId);
-    const adoptable = previous !== null && owner.get(previous) === "default" && actorId !== "default";
+    const adoptable = !phone && previous !== null && owner.get(previous) === "default" && actorId !== "default";
     let sessionId;
     if (continues && theirs) sessionId = theirs;
     else if (asked && adoptable) {
@@ -1447,7 +1472,8 @@ function sessionLanes(occurrences, defaultActorId) {
     const continuesFrom = last.get(sessionId) ?? null;
     rows.push({
       occurrenceId: occurrence.occurrenceId,
-      actorId,
+      actorId: person,
+      ...phone ? { phone } : {},
       incarnation: Number(sessionId.split("#")[1]),
       sessionId,
       lane: lanes.get(sessionId),
@@ -2647,8 +2673,8 @@ function installRecorder() {
     return Boolean(el?.closest?.("[data-flowriki],[data-flowriki-debug]"));
   }
   function actualTarget(e) {
-    const path14 = typeof e.composedPath === "function" ? e.composedPath() : [];
-    const first = path14[0];
+    const path15 = typeof e.composedPath === "function" ? e.composedPath() : [];
+    const first = path15[0];
     return (first && first.tagName ? first : e.target) ?? null;
   }
   w.__flSignature = () => {
@@ -7191,8 +7217,9 @@ import path33 from "path";
 import fs43 from "fs";
 import path42 from "path";
 import path5 from "path";
-import fs52 from "fs";
 import path6 from "path";
+import fs52 from "fs";
+import path7 from "path";
 import { spawn as spawn3 } from "child_process";
 var WebDriverError = class extends Error {
   constructor(message, error, status2) {
@@ -7204,10 +7231,10 @@ var WebDriverError = class extends Error {
   status;
 };
 var ELEMENT_KEY = "element-6066-11e4-a52e-4f735466cecc";
-async function call(endpoint, method, path72, body, timeoutMs = 12e4) {
+async function call(endpoint, method, path82, body, timeoutMs = 12e4) {
   const headers = { "content-type": "application/json; charset=utf-8" };
   if (endpoint.username) headers["authorization"] = `Basic ${Buffer.from(`${endpoint.username}:${endpoint.password ?? ""}`).toString("base64")}`;
-  const res = await fetch(`${endpoint.url.replace(/\/+$/, "")}${path72}`, {
+  const res = await fetch(`${endpoint.url.replace(/\/+$/, "")}${path82}`, {
     method,
     headers,
     ...method === "POST" ? { body: JSON.stringify(body ?? {}) } : {},
@@ -7246,11 +7273,11 @@ var WebDriverSession = class _WebDriverSession {
     return new _WebDriverSession(endpoint, value.sessionId, value.capabilities ?? {});
   }
   /** Any other command — Appium's own extensions live under /appium/. */
-  raw(method, path72, body, timeoutMs) {
-    return this.req(method, path72, body, timeoutMs);
+  raw(method, path82, body, timeoutMs) {
+    return this.req(method, path82, body, timeoutMs);
   }
-  req(method, path72, body, timeoutMs) {
-    return call(this.endpoint, method, `/session/${this.id}${path72}`, body, timeoutMs);
+  req(method, path82, body, timeoutMs) {
+    return call(this.endpoint, method, `/session/${this.id}${path82}`, body, timeoutMs);
   }
   source() {
     return this.req("GET", "/source");
@@ -8494,7 +8521,37 @@ var MobileSession = class _MobileSession {
     await this.tap(button);
     return button.name;
   }
+  // ── Video ──────────────────────────────────────────────────────────────
+  recording = false;
+  /** Start filming the screen. Android's own recorder stops at three minutes
+   *  unless Appium can join pieces with ffmpeg; iOS needs ffmpeg at all. A
+   *  phone in a cloud farm is filmed by the farm. Answers whether it started. */
+  async startVideo() {
+    if (this.cloud) return false;
+    const ffmpeg = Boolean(onPath("ffmpeg"));
+    if (this.platform === "ios" && !ffmpeg) return false;
+    const options = this.platform === "android" ? { timeLimit: ffmpeg ? "1800" : "180", bitRate: "3000000", forceRestart: true } : { timeLimit: "1800", videoType: "libx264", videoFps: 10, videoQuality: "medium", forceRestart: true };
+    try {
+      await this.driver.raw("POST", "/appium/start_recording_screen", { options });
+      this.recording = true;
+    } catch {
+      this.recording = false;
+    }
+    return this.recording;
+  }
+  /** Stop filming; keep the film at `file`, or throw it away. */
+  async stopVideo(file2) {
+    if (!this.recording) return null;
+    this.recording = false;
+    const b64 = await this.driver.raw("POST", "/appium/stop_recording_screen", { options: {} }, 12e4).catch(() => "");
+    if (!file2 || !b64) return null;
+    const bytes = Buffer.from(b64, "base64");
+    fs43.mkdirSync(path42.dirname(file2), { recursive: true });
+    fs43.writeFileSync(file2, bytes);
+    return { relPath: path42.basename(file2), bytes: bytes.length };
+  }
   async close() {
+    if (this.recording) await this.stopVideo(null);
     await this.driver.close();
   }
 };
@@ -8767,6 +8824,13 @@ async function runMobileSteps(session, steps, opts) {
   }
   return { results, status: status2, error };
 }
+var typesSecrets = (steps) => steps.some((s2) => s2.secret || Boolean(s2.secretRef) || s2.type === "signIn");
+var filmsThis = (policy, steps, evidenceDir) => Boolean(evidenceDir) && Boolean(policy) && policy.mode !== "off" && (policy.allowUnmasked === true || !typesSecrets(steps));
+async function finishVideo(session, policy, evidenceDir, passed, name = "phone") {
+  const keep = Boolean(evidenceDir) && (policy?.mode === "always" || policy?.mode === "on-failure" && !passed);
+  const saved = await session.stopVideo(keep ? path6.join(evidenceDir, `video-${name}.mp4`) : null).catch(() => null);
+  return saved ? [{ kind: "video", relPath: saved.relPath, bytes: saved.bytes }] : [];
+}
 async function chooseDevice(platform, mobile, asked) {
   const chosen = asked ?? mobile.devices[platform];
   if (chosen) return chosen;
@@ -8800,9 +8864,11 @@ async function replayMobileFlow(opts) {
       device: describeDevice(opts.device ?? null)
     };
   }
+  const filming = filmsThis(opts.video, opts.steps, opts.evidenceDir) && await session.startVideo();
+  let outcome = null;
   try {
     if (opts.startPath && /^[a-z][\w+.-]*:\/\//i.test(opts.startPath)) await session.openLink(opts.startPath);
-    const { results, status: status2, error } = await runMobileSteps(session, opts.steps, {
+    outcome = await runMobileSteps(session, opts.steps, {
       values: /* @__PURE__ */ new Map(),
       ...opts.resolveSecret ? { resolveSecret: opts.resolveSecret } : {},
       ...opts.resolveAuth ? { resolveAuth: opts.resolveAuth } : {},
@@ -8812,6 +8878,8 @@ async function replayMobileFlow(opts) {
       ...opts.screenshots ? { screenshots: opts.screenshots } : {},
       ...opts.signal ? { signal: opts.signal } : {}
     });
+    const { results, status: status2, error } = outcome;
+    const artifacts = filming ? await finishVideo(session, opts.video, opts.evidenceDir, status2 === "passed") : [];
     return {
       status: status2,
       error,
@@ -8819,7 +8887,8 @@ async function replayMobileFlow(opts) {
       stepsRun: results.filter((r) => r.status !== "skipped").length,
       stepsTotal: opts.steps.length,
       steps: results,
-      device: session.deviceName
+      device: session.deviceName,
+      ...artifacts.length ? { artifacts } : {}
     };
   } finally {
     await session.close();
@@ -8841,7 +8910,14 @@ async function mobileDoctor() {
   const drivers = await installedDrivers();
   const appiumVersion = appium ? (await run(appium.bin, ["--version"], 3e4, await toolEnv()).catch(() => "")).trim().split("\n").pop() ?? "" : "";
   const appiumLines = [
-    appium ? { item: "Appium", ok: true, detail: `${appiumVersion || "installed"} (${appium.bin.startsWith(APPIUM_DIR) ? "installed by Flowriki" : appium.bin})` } : { item: "Appium", ok: false, detail: "not installed", fix: "flowriki-agent mobile setup" }
+    appium ? { item: "Appium", ok: true, detail: `${appiumVersion || "installed"} (${appium.bin.startsWith(APPIUM_DIR) ? "installed by Flowriki" : appium.bin})` } : { item: "Appium", ok: false, detail: "not installed", fix: "flowriki-agent mobile setup" },
+    onPath("ffmpeg") ? { item: "ffmpeg", ok: true, detail: "phone runs can be filmed", optional: true } : {
+      item: "ffmpeg",
+      ok: false,
+      optional: true,
+      detail: "not installed \u2014 Android videos stop at 3 minutes, iOS runs cannot be filmed",
+      fix: process.platform === "darwin" ? "brew install ffmpeg" : process.platform === "win32" ? "winget install ffmpeg" : "install ffmpeg with your package manager"
+    }
   ];
   const sdk = androidHome();
   const adb = adbPath();
@@ -8865,7 +8941,7 @@ async function mobileDoctor() {
     const iphones = devices.filter((d) => d.platform === "ios");
     ios.push(iphones.length ? { item: "Devices", ok: true, detail: `${iphones.filter((d) => d.kind === "simulator").length} simulators${iphones.some((d) => d.kind === "device") ? `, ${iphones.filter((d) => d.kind === "device").map((d) => d.name).join(", ")}` : ""}` } : { item: "Devices", ok: false, detail: "none", fix: "Xcode \u2192 Settings \u2192 Platforms \u2192 add an iOS simulator" });
   }
-  const okAll = (lines) => lines.every((l) => l.ok);
+  const okAll = (lines) => lines.every((l) => l.ok || l.optional);
   return { appium: appiumLines, android, ios, androidReady: okAll(appiumLines) && okAll(android), iosReady: okAll(appiumLines) && okAll(ios) };
 }
 function stream(file2, args, env, cwd, say) {
@@ -8875,20 +8951,20 @@ function stream(file2, args, env, cwd, say) {
     child.stdout.on("data", each);
     child.stderr.on("data", each);
     child.on("error", reject);
-    child.on("close", (code) => code === 0 ? resolve2() : reject(new Error(`${path6.basename(file2)} ${args.join(" ")} failed (${code})`)));
+    child.on("close", (code) => code === 0 ? resolve2() : reject(new Error(`${path7.basename(file2)} ${args.join(" ")} failed (${code})`)));
   });
 }
 async function mobileSetup(say = console.log) {
   const npm = onPath("npm");
   if (!npm) throw new Error("npm was not found \u2014 install Node.js 20 or newer.");
-  fs52.mkdirSync(path6.join(APPIUM_DIR, "home"), { recursive: true });
-  if (!fs52.existsSync(path6.join(APPIUM_DIR, "package.json"))) {
-    fs52.writeFileSync(path6.join(APPIUM_DIR, "package.json"), JSON.stringify({ name: "flowriki-appium", private: true }, null, 2));
+  fs52.mkdirSync(path7.join(APPIUM_DIR, "home"), { recursive: true });
+  if (!fs52.existsSync(path7.join(APPIUM_DIR, "package.json"))) {
+    fs52.writeFileSync(path7.join(APPIUM_DIR, "package.json"), JSON.stringify({ name: "flowriki-appium", private: true }, null, 2));
   }
-  const env = { ...await toolEnv(), APPIUM_HOME: path6.join(APPIUM_DIR, "home") };
+  const env = { ...await toolEnv(), APPIUM_HOME: path7.join(APPIUM_DIR, "home") };
   say("Installing Appium\u2026");
   await stream(npm, ["install", "--no-audit", "--no-fund", "appium@2"], env, APPIUM_DIR, say);
-  const bin = path6.join(APPIUM_DIR, "node_modules", ".bin", process.platform === "win32" ? "appium.cmd" : "appium");
+  const bin = path7.join(APPIUM_DIR, "node_modules", ".bin", process.platform === "win32" ? "appium.cmd" : "appium");
   const have = await installedDrivers();
   const wanted = ["uiautomator2", ...process.platform === "darwin" ? ["xcuitest"] : []];
   for (const driver of wanted) {
@@ -8908,6 +8984,8 @@ var MobileLane = class {
   }
   opts;
   sessions = /* @__PURE__ */ new Map();
+  filming = /* @__PURE__ */ new Set();
+  failed = false;
   values;
   /** Run one phone row. `deviceKey` is the row's device — its actor id. */
   async run(occurrence, ctx) {
@@ -8927,6 +9005,7 @@ var MobileLane = class {
           ...this.opts.resolveSecret ? { resolveSecret: this.opts.resolveSecret } : {}
         });
         this.sessions.set(ctx.deviceKey, session);
+        if (filmsThis(this.opts.video, this.opts.allSteps ?? occurrence.steps, this.opts.evidenceDir) && await session.startVideo()) this.filming.add(ctx.deviceKey);
       } else if (start2 === "fresh" || start2 === "navigate") {
         await session.terminateApp().catch(() => void 0);
         await session.launchApp();
@@ -8949,12 +9028,23 @@ var MobileLane = class {
       ...this.opts.screenshots ? { screenshots: this.opts.screenshots } : {},
       ...this.opts.signal ? { signal: this.opts.signal } : {}
     });
+    if (done.status !== "passed") this.failed = true;
     return { status: done.status, error: done.error, steps: done.results };
   }
-  async close() {
-    const all = [...this.sessions.values()];
+  /** Close every phone; answers the films kept. `passed` is the whole
+   *  case's result — a film is about the case, not one row. */
+  async close(passed = !this.failed) {
+    const all = [...this.sessions.entries()];
     this.sessions.clear();
-    await Promise.all(all.map((s2) => s2.close().catch(() => void 0)));
+    const films = [];
+    let n2 = 0;
+    for (const [key, session] of all) {
+      n2++;
+      if (this.filming.has(key)) films.push(...await finishVideo(session, this.opts.video, this.opts.evidenceDir, passed, `phone-${n2}`));
+      await session.close().catch(() => void 0);
+    }
+    this.filming.clear();
+    return films;
   }
 };
 async function replayMobileCase(opts) {
@@ -8964,6 +9054,7 @@ async function replayMobileCase(opts) {
   const opened = /* @__PURE__ */ new Set();
   let status2 = "passed";
   let error = null;
+  let artifacts = [];
   try {
     for (const occurrence of opts.occurrences) {
       if (status2 !== "passed" || opts.signal?.aborted) {
@@ -9004,13 +9095,13 @@ async function replayMobileCase(opts) {
       }
     }
   } finally {
-    await lane.close();
+    artifacts = await lane.close(status2 === "passed");
   }
   const steps = outcomes.flatMap((o) => o.steps);
   return {
     status: status2,
     error,
-    artifacts: [],
+    artifacts,
     durationMs: Date.now() - started,
     occurrences: outcomes,
     steps,
@@ -9187,15 +9278,15 @@ var RunDetailSchema = RunSummarySchema.extend({
 
 // ../results/dist/chunk-IW3PJWP6.js
 import os5 from "os";
-import path7 from "path";
+import path8 from "path";
 function flowrikiHome() {
-  return process.env.FLOWRIKI_HOME || path7.join(os5.homedir(), ".flowriki");
+  return process.env.FLOWRIKI_HOME || path8.join(os5.homedir(), ".flowriki");
 }
 function defaultDbPath() {
-  return path7.join(flowrikiHome(), "flowriki.db");
+  return path8.join(flowrikiHome(), "flowriki.db");
 }
 function runArtifactsDir(runId, projectId = "default") {
-  return path7.join(flowrikiHome(), "projects", safe(projectId), "runs", safe(runId));
+  return path8.join(flowrikiHome(), "projects", safe(projectId), "runs", safe(runId));
 }
 function safe(segment) {
   if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(segment) || segment.includes("..")) {
@@ -9204,15 +9295,15 @@ function safe(segment) {
   return segment;
 }
 function isInside(root, candidate) {
-  const base = path7.resolve(root);
-  const target = path7.resolve(candidate);
-  return target === base || target.startsWith(base + path7.sep);
+  const base = path8.resolve(root);
+  const target = path8.resolve(candidate);
+  return target === base || target.startsWith(base + path8.sep);
 }
 
 // ../results/dist/node.js
 import fs6 from "fs";
 import { createRequire as createRequire3 } from "module";
-import path8 from "path";
+import path9 from "path";
 var MIGRATIONS2 = [
   // 1 — initial
   `
@@ -9424,7 +9515,7 @@ var SqliteStorage = class {
         `run history needs node:sqlite, which this Node (${process.version}) does not provide \u2014 Node 22.13 or newer is required (${err.message})`
       );
     }
-    if (this.file !== ":memory:") fs6.mkdirSync(path8.dirname(this.file), { recursive: true });
+    if (this.file !== ":memory:") fs6.mkdirSync(path9.dirname(this.file), { recursive: true });
     const db = new DatabaseSync2(this.file);
     if (this.file !== ":memory:") db.exec("PRAGMA journal_mode = WAL");
     db.exec("PRAGMA busy_timeout = 5000");
@@ -9977,7 +10068,7 @@ var FlowNotRunnable = class extends Error {
 import fs24 from "fs";
 import path24 from "path";
 import fs7 from "fs";
-import path9 from "path";
+import path10 from "path";
 import { execFileSync } from "child_process";
 import { execFileSync as execFileSync2 } from "child_process";
 import fs34 from "fs";
@@ -10002,7 +10093,7 @@ var LocalSecrets = class {
   }
   root;
   get secretsPath() {
-    return path9.join(this.root, ".flowriki", "secrets.local.json");
+    return path10.join(this.root, ".flowriki", "secrets.local.json");
   }
   readSecrets() {
     try {
@@ -10052,7 +10143,7 @@ var LocalSecrets = class {
       changed = true;
     }
     if (changed) {
-      fs7.mkdirSync(path9.dirname(this.secretsPath), { recursive: true });
+      fs7.mkdirSync(path10.dirname(this.secretsPath), { recursive: true });
       fs7.writeFileSync(this.secretsPath, JSON.stringify(secrets, null, 2) + "\n", { mode: 384 });
       this.ensureSecretsIgnored();
     }
@@ -10083,7 +10174,7 @@ var LocalSecrets = class {
     if (!/^[a-z0-9][a-z0-9_-]*$/.test(ref)) throw new Error(`invalid secret name: ${ref}`);
     const secrets = this.readSecrets();
     secrets[ref] = value;
-    fs7.mkdirSync(path9.dirname(this.secretsPath), { recursive: true });
+    fs7.mkdirSync(path10.dirname(this.secretsPath), { recursive: true });
     fs7.writeFileSync(this.secretsPath, JSON.stringify(secrets, null, 2) + "\n", { mode: 384 });
     this.ensureSecretsIgnored();
   }
@@ -10124,7 +10215,7 @@ var LocalSecrets = class {
       }
     }
     if (healed.length) {
-      fs7.mkdirSync(path9.dirname(this.secretsPath), { recursive: true });
+      fs7.mkdirSync(path10.dirname(this.secretsPath), { recursive: true });
       fs7.writeFileSync(this.secretsPath, JSON.stringify(secrets, null, 2) + "\n", { mode: 384 });
       this.ensureSecretsIgnored();
     }
@@ -10141,10 +10232,10 @@ var LocalSecrets = class {
   }
   /** Add one entry to .flowriki/.gitignore if it is not already there. */
   ensureIgnored(line, why) {
-    const ignore = path9.join(this.root, ".flowriki", ".gitignore");
+    const ignore = path10.join(this.root, ".flowriki", ".gitignore");
     const existing = fs7.existsSync(ignore) ? fs7.readFileSync(ignore, "utf8") : "";
     if (existing.split("\n").includes(line)) return;
-    fs7.mkdirSync(path9.dirname(ignore), { recursive: true });
+    fs7.mkdirSync(path10.dirname(ignore), { recursive: true });
     fs7.writeFileSync(
       ignore,
       `${existing}${existing && !existing.endsWith("\n") ? "\n" : ""}# ${why}
@@ -10804,9 +10895,9 @@ async function runSms(config, ctx) {
     await new Promise((r) => setTimeout(r, ctx.pollMs ?? 3e3));
   }
 }
-function atPath(value, path14) {
+function atPath(value, path15) {
   let at = value;
-  for (const key of path14.split(".").filter(Boolean)) {
+  for (const key of path15.split(".").filter(Boolean)) {
     if (at === null || at === void 0) return void 0;
     at = Array.isArray(at) && /^\d+$/.test(key) ? at[Number(key)] : at[key];
   }
@@ -10943,14 +11034,15 @@ async function executeFlow(opts) {
     onStepResult: o.onStepResult,
     evidenceDir: o.evidenceDir,
     screenshots: o.artifacts?.screenshot ?? "on-failure",
-    signal: o.signal
+    signal: o.signal,
+    video: { mode: o.artifacts?.video ?? "off", allowUnmasked: o.artifacts?.allowUnmaskedArtifacts === true }
   }) : replayFlow(o);
   const byId = new Map(flow.steps.map((s2) => [s2.id, s2]));
   const attempts = [];
   const perStep = /* @__PURE__ */ new Map();
   for (let attempt = 1; attempt <= repeat; attempt++) {
     if (opts.signal?.aborted) break;
-    const evidenceDir = runDir && repeat > 1 ? path10.join(runDir, `attempt-${String(attempt).padStart(3, "0")}`) : runDir;
+    const evidenceDir = runDir && repeat > 1 ? path11.join(runDir, `attempt-${String(attempt).padStart(3, "0")}`) : runDir;
     const relativeTo = (file2) => repeat > 1 ? `attempt-${String(attempt).padStart(3, "0")}/${file2}` : file2;
     const taskId = storage && run2 ? await storage.createTask(run2.id, {
       caseName: repeat > 1 ? `${flow.name} \xB7 attempt ${attempt}` : flow.name,
@@ -11137,7 +11229,7 @@ function report(attempts, perStep) {
 function sizeOf(dir, file2) {
   if (!dir) return null;
   try {
-    return fs8.statSync(path10.join(dir, file2)).size;
+    return fs8.statSync(path11.join(dir, file2)).size;
   } catch {
     return null;
   }
@@ -11303,7 +11395,9 @@ async function executeCase(opts) {
     ...helpers ? { runHelper: helpers } : {},
     ...runDir ? { evidenceDir: runDir } : {},
     ...config.artifacts?.screenshot ? { screenshots: config.artifacts.screenshot } : {},
-    ...opts.signal ? { signal: opts.signal } : {}
+    ...opts.signal ? { signal: opts.signal } : {},
+    video: { mode: config.artifacts?.video ?? "off", allowUnmasked: config.artifacts?.allowUnmaskedArtifacts === true },
+    allSteps: phoneRows.flatMap((o) => o.steps)
   };
   const lane = phoneRows.length && phoneRows.length < testCase.occurrences.length ? new MobileLane(laneOptions) : null;
   const opened = /* @__PURE__ */ new Set();
@@ -11367,7 +11461,7 @@ async function executeCase(opts) {
       }))
     };
   }
-  await lane?.close();
+  if (lane) outcome = { ...outcome, artifacts: [...outcome.artifacts ?? [], ...await lane.close(outcome.status === "passed")] };
   await Promise.all(writes);
   if (storage && run2) {
     for (const each of outcome.occurrences) {
@@ -11961,7 +12055,7 @@ function resolveCheckouts(dirs) {
   const projects = [];
   const skipped = [];
   for (const dir of dirs) {
-    const root = path11.resolve(dir);
+    const root = path12.resolve(dir);
     if (!fs9.existsSync(root)) {
       skipped.push({ root, why: "no such folder" });
       continue;
@@ -12080,7 +12174,7 @@ function dialWebSocket(opts) {
 
 // ../agent-core/dist/index.js
 import fs10 from "fs";
-import path12 from "path";
+import path13 from "path";
 import crypto4 from "crypto";
 import { createRequire as createRequire4 } from "module";
 var EventJournal = class {
@@ -12173,7 +12267,7 @@ var AgentState = class {
     this.commandLimit = commandLimit;
     if (!file2 || file2 === ":memory:") throw new Error("a persistent agent state file is required");
     if (!Number.isInteger(commandLimit) || commandLimit < 1) throw new Error("invalid command capacity");
-    fs10.mkdirSync(path12.dirname(file2), { recursive: true, mode: 448 });
+    fs10.mkdirSync(path13.dirname(file2), { recursive: true, mode: 448 });
     const fd = fs10.openSync(file2, "a", 384);
     fs10.closeSync(fd);
     fs10.chmodSync(file2, 384);
@@ -12592,7 +12686,7 @@ var AgentLink = class {
 // ../provider-local/dist/index.js
 import fs11 from "fs";
 import os6 from "os";
-import path13 from "path";
+import path14 from "path";
 import fs26 from "fs";
 import path25 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
@@ -12613,7 +12707,7 @@ var scratchRoots = /* @__PURE__ */ new Map();
 function scratchRoot(projectId) {
   let root = scratchRoots.get(projectId);
   if (!root) {
-    root = fs11.mkdtempSync(path13.join(os6.tmpdir(), `flowriki-record-${projectId.replace(/[^\w-]/g, "")}-`));
+    root = fs11.mkdtempSync(path14.join(os6.tmpdir(), `flowriki-record-${projectId.replace(/[^\w-]/g, "")}-`));
     scratchRoots.set(projectId, root);
   }
   return root;
@@ -14397,7 +14491,10 @@ export {
   AGENT_VERSION,
   prepareBrowsers,
   browsersReady,
+  dataDir,
   connectionFor,
+  AGENT_LATEST_URL,
+  agentUpdateFor,
   resolveService,
   connect,
   isMobile,

package/dist/cli.js

@@ -1,16 +1,19 @@
 #!/usr/bin/env node
 import {
+  AGENT_LATEST_URL,
   AGENT_VERSION,
   CLOUD_PROVIDERS,
   CLOUD_PROVIDER_NAME,
   MobileLane,
   RecordedStepSchema,
+  agentUpdateFor,
   authenticationResolver,
   checkAssertion,
   checkMobileAssertion,
   closeRunSession,
   connect,
   connectionFor,
+  dataDir,
   disconnect,
   doctor,
   executeStep,
@@ -41,7 +44,7 @@ import {
   status,
   stepRefusedOn,
   targetFor
-} from "./chunk-LIURHWRP.js";
+} from "./chunk-AMXSHZYE.js";
 
 // src/cli.ts
 import { parseArgs } from "util";
@@ -137,8 +140,8 @@ var ServiceClient = class {
   get origin() {
     return this.connection.service;
   }
-  async call(path, init = {}) {
-    const res = await this.fetcher(`${this.connection.service}${path}`, {
+  async call(path2, init = {}) {
+    const res = await this.fetcher(`${this.connection.service}${path2}`, {
       ...init,
       headers: {
         "x-flowriki-device": this.connection.deviceId,
@@ -280,9 +283,9 @@ var ServiceClient = class {
   }
   // ── Manual cycles and bugs: the dashboard's own routes, behind this
   // machine's credential, so the assistant can do what a person can. ──────
-  scoped(path, projectId, extra = {}) {
+  scoped(path2, projectId, extra = {}) {
     const query = new URLSearchParams({ projectId, ...extra });
-    return `/api/agent${path}?${query}`;
+    return `/api/agent${path2}?${query}`;
   }
   cycles(projectId) {
     return this.call(this.scoped("/cycles", projectId));
@@ -321,8 +324,8 @@ var ServiceClient = class {
   knowledgePages(projectId) {
     return this.call(this.scoped("/knowledge", projectId));
   }
-  knowledgePage(projectId, path) {
-    return this.call(this.scoped("/knowledge/page", projectId, { path }));
+  knowledgePage(projectId, path2) {
+    return this.call(this.scoped("/knowledge/page", projectId, { path: path2 }));
   }
   writeKnowledge(projectId, body) {
     return this.call(`/api/agent/knowledge?projectId=${encodeURIComponent(projectId)}`, { method: "POST", body: JSON.stringify(body) });
@@ -2003,7 +2006,7 @@ Use it with start_flow signIn {"profileId": "\u2026", "accountId": "${made.accou
       run: async (args) => {
         const projectId = await projectFor(args["projectId"]);
         const { pages } = await service.knowledgePages(projectId);
-        const read = async (path) => pages.some((p) => p.path === path) ? (await service.knowledgePage(projectId, path)).content : null;
+        const read = async (path2) => pages.some((p) => p.path === path2) ? (await service.knowledgePage(projectId, path2)).content : null;
         const [product, glossary, decisions] = await Promise.all(["product.md", "glossary.md", "memory/decisions.md"].map(read));
         const codebases = pages.filter((p) => p.path.startsWith("codebase/"));
         const headers = await Promise.all(codebases.map(async (p) => `- ${p.path}: ${(await read(p.path))?.split("\n").filter((l) => l.trim()).slice(0, 3).join(" \xB7 ") ?? ""}`));
@@ -2097,6 +2100,212 @@ ${pages.filter((p) => !shown.has(p.path)).map((p) => `- ${p.path}`).join("\n") |
   }));
 }
 
+// src/mcp/upgrade.ts
+import { spawn } from "child_process";
+import readline2 from "readline";
+var PRIVATE = "flowriki-upgrade";
+var startWithNpx = (version) => spawn(process.platform === "win32" ? "npx.cmd" : "npx", ["-y", `@flowriki/agent@${version}`, "mcp"], {
+  env: { ...process.env, FLOWRIKI_MCP_CHILD: "1" },
+  stdio: ["pipe", "pipe", "inherit"]
+});
+var toolShape = (tools) => JSON.stringify(tools.map((t) => [t.name, t.description ?? "", t.inputSchema ?? null]).sort());
+function serveWithUpgrades(tools, info, opts) {
+  const input = opts.input ?? process.stdin;
+  const output = opts.output ?? process.stdout;
+  const log = opts.log ?? ((line) => process.stderr.write(`flowriki: ${line}
+`));
+  const send = (m) => output.write(`${JSON.stringify(m)}
+`);
+  if (!opts.output) {
+    console.log = console.info = console.warn = console.debug = (...args) => {
+      process.stderr.write(`${args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}
+`);
+    };
+  }
+  let initialize = null;
+  let localCalls = 0;
+  let ready = null;
+  let active = null;
+  let preparing = false;
+  let notice = null;
+  const forwarded = /* @__PURE__ */ new Set();
+  let timer = null;
+  const withNotice = (answer) => {
+    if (!notice || !answer.result || typeof answer.result !== "object") return answer;
+    const result = answer.result;
+    if (!Array.isArray(result.content)) return answer;
+    const text2 = notice;
+    notice = null;
+    return { ...answer, result: { ...result, content: [{ type: "text", text: text2 }, ...result.content] } };
+  };
+  const prepare = async (version) => {
+    if (preparing || ready || active || !initialize) return;
+    preparing = true;
+    let child = null;
+    try {
+      child = (opts.start ?? startWithNpx)(version);
+      const c = child;
+      const lines2 = readline2.createInterface({ input: c.stdout, crlfDelay: Infinity });
+      const waiting = /* @__PURE__ */ new Map();
+      const exited = new Promise((_, reject) => c.once("exit", (code) => reject(new Error(`it stopped while starting (exit ${code})`))));
+      exited.catch(() => void 0);
+      c.once("error", (e) => waiting.forEach((resolve) => resolve({ jsonrpc: "2.0", error: { message: e.message } })));
+      lines2.on("line", (line) => {
+        let m;
+        try {
+          m = JSON.parse(line);
+        } catch {
+          return;
+        }
+        if (typeof m.id === "string" && m.id.startsWith(PRIVATE)) {
+          waiting.get(m.id)?.(m);
+          waiting.delete(m.id);
+          return;
+        }
+        if (active?.child !== c) return;
+        if (m.id !== void 0 && m.id !== null) forwarded.delete(m.id);
+        send(m.id !== void 0 && m.id !== null && "result" in m ? withNotice(m) : m);
+      });
+      const ask = (method, params, id) => new Promise((resolve, reject) => {
+        waiting.set(id, resolve);
+        c.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, ...params ? { params } : {} })}
+`);
+        setTimeout(() => reject(new Error("it did not answer in time")), opts.readyWithinMs ?? 18e4).unref();
+      });
+      const hello = await Promise.race([ask("initialize", initialize.params, `${PRIVATE}-init`), exited]);
+      if (hello.error) throw new Error(JSON.stringify(hello.error));
+      c.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })}
+`);
+      const listed = await Promise.race([ask("tools/list", void 0, `${PRIVATE}-tools`), exited]);
+      const theirs = listed.result?.tools ?? [];
+      ready = { child: c, version, lines: lines2, toolsChanged: toolShape(theirs) !== toolShape(tools) };
+      c.once("exit", () => {
+        if (ready?.child === c) ready = null;
+        if (active?.child === c) {
+          active = null;
+          for (const id of forwarded) send({ jsonrpc: "2.0", id, error: { code: -32603, message: "the updated Flowriki stopped \u2014 ask again" } });
+          forwarded.clear();
+          notice = `The updated Flowriki (${version}) stopped, so this connection carries on with ${opts.current}.`;
+          log(`updated server ${version} exited; back on ${opts.current}`);
+        }
+      });
+      log(`${version} is ready to take over from ${opts.current}`);
+    } catch (error) {
+      child?.kill();
+      log(`could not start ${version}: ${error.message}`);
+      notice ??= `Flowriki ${version} is out (this connection runs ${opts.current}) and could not switch over by itself: ${error.message}. Reconnect Flowriki in Claude to start the new version.`;
+    } finally {
+      preparing = false;
+    }
+  };
+  const maybeSwitch = async (incomingTool) => {
+    if (!ready || active || localCalls > 0) return false;
+    if (!opts.idle() && incomingTool !== "start_flow") return false;
+    const next = ready;
+    ready = null;
+    await opts.handOff().catch(() => void 0);
+    active = next;
+    if (timer) clearInterval(timer);
+    notice = `Flowriki updated itself from ${opts.current} to ${next.version} \u2014 the new version is answering now.` + (next.toolsChanged ? " It brings new or changed tools; if Claude does not offer them yet, reconnect Flowriki in Claude (in Claude Code: /mcp, then Reconnect)." : "");
+    send({ jsonrpc: "2.0", method: "notifications/tools/list_changed" });
+    log(`switched to ${next.version}`);
+    return true;
+  };
+  const look = async () => {
+    if (active || ready || preparing) return;
+    const version = await opts.check().catch(() => null);
+    if (version) {
+      await prepare(version);
+      await maybeSwitch();
+    }
+  };
+  setTimeout(() => void look(), opts.firstCheckMs ?? 15e3).unref();
+  timer = setInterval(() => void look(), opts.everyMs ?? 30 * 6e4);
+  timer.unref();
+  const lines = readline2.createInterface({ input, crlfDelay: Infinity });
+  const pending = /* @__PURE__ */ new Set();
+  lines.on("line", (line) => {
+    if (!line.trim()) return;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      send({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } });
+      return;
+    }
+    if (message.method === "initialize") initialize = message;
+    const task = (async () => {
+      const tool = message.method === "tools/call" ? String(message.params?.["name"] ?? "") : void 0;
+      if (!active && tool) await maybeSwitch(tool);
+      if (active) {
+        if (message.id !== void 0 && message.id !== null) forwarded.add(message.id);
+        active.child.stdin.write(`${line}
+`);
+        return;
+      }
+      if (tool) localCalls++;
+      try {
+        const answer = await handle(message, tools, info);
+        if (answer) send(tool ? withNotice(answer) : answer);
+        if (message.method === "notifications/initialized") send({ jsonrpc: "2.0", method: "notifications/tools/list_changed" });
+      } finally {
+        if (tool) localCalls--;
+      }
+      if (tool && ready) await maybeSwitch();
+    })();
+    pending.add(task);
+    void task.finally(() => pending.delete(task));
+  });
+  return new Promise((resolve) => lines.on("close", () => {
+    void Promise.allSettled([...pending]).then(() => {
+      if (timer) clearInterval(timer);
+      const child = active?.child ?? ready?.child;
+      if (!child) return resolve();
+      child.stdin?.end();
+      const done = () => resolve();
+      child.once("exit", done);
+      setTimeout(() => {
+        child.kill();
+        done();
+      }, 5e3).unref();
+    });
+  }));
+}
+
+// src/updates.ts
+import fs from "fs";
+import path from "path";
+var CACHE_MS = 30 * 60 * 1e3;
+async function latestPublished(opts = {}) {
+  const file = path.join(dataDir(), "latest-agent.json");
+  if (!opts.fresh) {
+    try {
+      const kept = JSON.parse(fs.readFileSync(file, "utf8"));
+      if (kept.version && kept.at && Date.now() - kept.at < CACHE_MS) return kept.version;
+    } catch {
+    }
+  }
+  try {
+    const res = await fetch(AGENT_LATEST_URL, { signal: AbortSignal.timeout(5e3), headers: { accept: "application/json" } });
+    if (!res.ok) return null;
+    const version = (await res.json()).version ?? null;
+    if (version) {
+      try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, JSON.stringify({ version, at: Date.now() }));
+      } catch {
+      }
+    }
+    return version;
+  } catch {
+    return null;
+  }
+}
+async function updateFor(running) {
+  const latest = await latestPublished();
+  return agentUpdateFor(running, latest) ? latest : null;
+}
+
 // src/mcp/index.ts
 async function runMcp(opts) {
   let service;
@@ -2120,7 +2329,20 @@ async function runMcp(opts) {
   };
   process.on("SIGINT", () => void closing());
   process.on("SIGTERM", () => void closing());
-  await serve(tools, { name: "flowriki", version: opts.version, instructions: INSTRUCTIONS });
+  const info = { name: "flowriki", version: opts.version, instructions: INSTRUCTIONS };
+  if (process.env["FLOWRIKI_MCP_CHILD"] === "1" || process.env["FLOWRIKI_NO_UPDATE"] === "1" || !/^\d+\.\d+\.\d+/.test(opts.version)) {
+    await serve(tools, info);
+  } else {
+    await serveWithUpgrades(tools, info, {
+      current: opts.version,
+      check: () => updateFor(opts.version),
+      idle: () => !session?.open,
+      handOff: async () => {
+        await session?.close();
+        if (session) session.draft = null;
+      }
+    });
+  }
   await session?.close();
   return 0;
 }
@@ -2270,6 +2492,17 @@ Run \`flowriki-agent --help\`.`);
         console.log(dim(`  project  ${project.name}  (${project.root})`));
       }
       console.log(dim("\n  Running in the foreground. Ctrl-C to stop.\n"));
+      let told = null;
+      const tellIfBehind = async () => {
+        const newer = await updateFor(AGENT_VERSION).catch(() => null);
+        if (!newer || newer === told) return;
+        told = newer;
+        console.log(yellow(`  ! Flowriki agent ${newer} is out \u2014 this is ${AGENT_VERSION}.`));
+        console.log(dim(`    Update: npm install -g @flowriki/agent@latest   then stop (Ctrl-C) and start again
+`));
+      };
+      void tellIfBehind();
+      setInterval(() => void tellIfBehind(), 6 * 60 * 6e4).unref();
       let stopping = false;
       const shutdown = async (signal) => {
         if (stopping) return;
@@ -2349,7 +2582,7 @@ Run \`flowriki-agent --help\`.`);
         for (const [title, lines] of [["Appium", found.appium], ["Android", found.android], ["iOS", found.ios]]) {
           console.log(bold(title));
           for (const line of lines) {
-            console.log(`  ${line.ok ? green("\u2713") : red("\u2717")} ${line.item.padEnd(15)} ${line.ok ? dim(line.detail) : line.detail}`);
+            console.log(`  ${line.ok ? green("\u2713") : line.optional ? yellow("\u2013") : red("\u2717")} ${line.item.padEnd(15)} ${line.ok ? dim(line.detail) : line.detail}`);
             if (!line.ok && line.fix) console.log(`    ${yellow("\u2192")} ${line.fix}`);
           }
         }

package/dist/engine.js

@@ -9,7 +9,7 @@ import {
   resolveCheckouts,
   start,
   status
-} from "./chunk-LIURHWRP.js";
+} from "./chunk-AMXSHZYE.js";
 export {
   AGENT_VERSION,
   browsersReady,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowriki/agent",
-  "version": "0.1.0-beta.46",
+  "version": "0.1.0-beta.47",
   "description": "Run Flowriki UI tests on your own computer. Connects this machine to your Flowriki account.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",