@flowriki/agent 0.1.0-beta.10 → 0.1.0-beta.12

package/dist/{chunk-O5HHREII.js → chunk-YIZ6E6DB.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.10";
+var AGENT_VERSION = "0.1.0-beta.12";
 async function prepareBrowsers() {
   if (browsersReady()) {
     return { ok: true, already: true, message: "chromium is already installed" };
@@ -135,7 +135,7 @@ function forgetConnection(service, env = process.env) {
 }
 var fingerprint = (secret) => crypto2.createHash("sha256").update(secret).digest("hex").slice(0, 12);
 
-// ../contracts/dist/chunk-XE4AJTQE.js
+// ../contracts/dist/chunk-BU7BOLBB.js
 import { z } from "zod";
 var PROTOCOL_VERSION = 1;
 var PAIRING_CODE_TTL_MS = 5 * 60 * 1e3;
@@ -148,6 +148,7 @@ var CommandNameSchema = z.enum([
   "record.dialog",
   "flow.run",
   "case.run",
+  "case.debug",
   "flow.save",
   "flow.update",
   "flow.delete",
@@ -180,6 +181,7 @@ var EFFECTFUL = /* @__PURE__ */ new Set([
   "record.dialog",
   "flow.run",
   "case.run",
+  "case.debug",
   "flow.save",
   "flow.update",
   "flow.delete",
@@ -889,6 +891,7 @@ var TestCaseSchema = z22.object({
   /** Where the case itself begins. The first row continues from here unless it
    *  carries its own navigation. */
   startPath: z22.string().default("/"),
+  useStartPath: z22.boolean().default(false),
   baseUrl: z22.string().url().optional(),
   environment: ExecutionEnvironmentSchema.optional(),
   occurrences: z22.array(FlowOccurrenceSchema).default([]),
@@ -964,6 +967,63 @@ var SuiteSchema = z22.object({
     seen.add(entry.entryId);
   });
 });
+function caseOccurrences(testCase) {
+  return testCase.occurrences.map((item, index) => index === 0 && testCase.useStartPath && !item.navigateFirst ? { ...item, startPath: testCase.startPath, ...testCase.baseUrl ? { baseUrl: testCase.baseUrl } : {} } : item);
+}
+function caseDebugPlan(testCase, baseUrl) {
+  const owners = {};
+  const steps = [];
+  const occurrences = caseOccurrences(testCase);
+  for (const [index, item] of occurrences.entries()) {
+    if (index > 0 && item.navigateFirst) {
+      const id = `case-nav:${encodeURIComponent(item.occurrenceId)}`;
+      owners[id] = { occurrenceId: item.occurrenceId, stepId: null };
+      steps.push({ id, type: "navigate", role: "", name: `Go to ${item.name}`, scope: "", value: new URL(item.startPath ?? "/", item.baseUrl ?? testCase.baseUrl ?? baseUrl).href, secret: false, legacySelector: "", proposals: [] });
+    }
+    for (const step of item.steps) {
+      const id = `case-step:${encodeURIComponent(item.occurrenceId)}:${encodeURIComponent(step.id)}`;
+      owners[id] = { occurrenceId: item.occurrenceId, stepId: step.id };
+      steps.push({ ...step, id });
+    }
+  }
+  const first = occurrences[0];
+  const flow = FlowDocumentSchema.parse({
+    schemaVersion: 5,
+    id: testCase.id,
+    featureId: testCase.folderId,
+    slug: testCase.slug,
+    name: testCase.name,
+    revision: testCase.revision,
+    recordedAt: testCase.createdAt,
+    recordedBy: testCase.createdBy,
+    updatedAt: testCase.updatedAt,
+    steps,
+    startPath: new URL(first?.startPath ?? "/", first?.baseUrl ?? testCase.baseUrl ?? baseUrl).href,
+    ...testCase.environment ? { environment: testCase.environment } : {}
+  });
+  return { flow, owners };
+}
+function restoreDebugCase(testCase, owners, steps) {
+  const occurrences = testCase.occurrences.map((item) => ({ ...item, steps: [] }));
+  const byId = new Map(occurrences.map((item) => [item.occurrenceId, item]));
+  let current = occurrences[0];
+  const present = new Set(steps.map((step) => step.id));
+  for (const [id, owner] of Object.entries(owners)) {
+    if (owner.stepId === null && !present.has(id)) byId.get(owner.occurrenceId).navigateFirst = false;
+  }
+  for (const step of steps) {
+    const owner = owners[step.id];
+    if (owner) current = byId.get(owner.occurrenceId);
+    if (!current) throw new Error("debug step has no case occurrence");
+    if (owner?.stepId === null) {
+      if (step.type !== "navigate") throw new Error("a case boundary must remain a navigation step");
+      current.startPath = step.value;
+      continue;
+    }
+    current.steps.push({ ...step, id: owner?.stepId ?? step.id });
+  }
+  return { ...testCase, occurrences };
+}
 
 // ../recorder/dist/index.js
 function openShadowRoots() {
@@ -3785,7 +3845,7 @@ async function runStepsIn(session, steps, opts) {
         const evidence = await captureFailure({
           page,
           dir: evidenceDir,
-          ordinal: results.length + 1,
+          ordinal: (opts.stepOffset ?? 0) + results.length + 1,
           steps
         });
         if (evidence) result.evidence = evidence;
@@ -4010,6 +4070,7 @@ async function replayCase(opts) {
       const navigates = index === 0 || occurrence.navigateFirst;
       const at0 = Date.now();
       const { results, status: ran, error: failed } = await runStepsIn(session, occurrence.steps, {
+        stepOffset: outcomes.reduce((count, previous) => count + previous.stepsTotal, 0),
         ...opts.resolveSecret === void 0 ? {} : { resolveSecret: opts.resolveSecret },
         ...opts.resolveFile === void 0 ? {} : { resolveFile: opts.resolveFile },
         ...opts.evidenceDir === void 0 ? {} : { evidenceDir: opts.evidenceDir },
@@ -4041,6 +4102,10 @@ async function replayCase(opts) {
       passed: status2 === "passed"
     });
   }
+  if (opts.signal?.aborted) {
+    status2 = "errored";
+    error = "the run was cancelled";
+  }
   const steps = outcomes.flatMap((o) => o.steps);
   return {
     status: status2,
@@ -6344,6 +6409,7 @@ async function executeCase(opts) {
   const { testCase, config, secrets, storage = null, trigger, baseUrl } = opts;
   const headless = opts.watch ? false : opts.headless ?? config.headless ?? true;
   const stepsTotal = testCase.occurrences.reduce((n2, o) => n2 + o.steps.length, 0);
+  if (stepsTotal === 0) throw new Error("this test case has no recorded steps to run");
   const run = storage ? await storage.createRun({
     ...opts.projectId ? { projectId: opts.projectId } : {},
     kind: "test",
@@ -6388,44 +6454,70 @@ async function executeCase(opts) {
       );
     }
   }
-  const byStepId = new Map(testCase.occurrences.flatMap((o) => o.steps.map((s2) => [s2.id, s2])));
+  const stepsByOccurrence = new Map(testCase.occurrences.map((o) => [o.occurrenceId, new Map(o.steps.map((s2) => [s2.id, s2]))]));
   const ordinals = /* @__PURE__ */ new Map();
   const writes = [];
-  const outcome = await replayCase({
-    occurrences: testCase.occurrences,
-    baseUrl,
-    ...testCase.environment ? { environment: testCase.environment } : {},
-    headless,
-    ...opts.watch ? { slowMo: 400 } : {},
-    resolveSecret: (ref) => secrets[ref],
-    ...opts.resolveFile ? { resolveFile: opts.resolveFile } : {},
-    ...config.artifacts ? { artifacts: config.artifacts } : {},
-    ...runDir ? { evidenceDir: runDir } : {},
-    ...opts.signal ? { signal: opts.signal } : {},
-    onStepResult: (result, occurrenceId) => {
-      const taskId = taskFor.get(occurrenceId);
-      if (storage && taskId && run) {
-        const at = ordinals.get(occurrenceId) ?? 0;
-        ordinals.set(occurrenceId, at + 1);
+  let outcome;
+  try {
+    outcome = await replayCase({
+      occurrences: caseOccurrences(testCase),
+      baseUrl: testCase.baseUrl ?? baseUrl,
+      ...testCase.environment ? { environment: testCase.environment } : {},
+      headless,
+      ...opts.watch ? { slowMo: 400 } : {},
+      resolveSecret: (ref) => secrets[ref],
+      ...opts.resolveFile ? { resolveFile: opts.resolveFile } : {},
+      ...config.artifacts ? { artifacts: config.artifacts } : {},
+      ...runDir ? { evidenceDir: runDir } : {},
+      ...opts.signal ? { signal: opts.signal } : {},
+      onStepResult: (result, occurrenceId) => {
+        const taskId = taskFor.get(occurrenceId);
+        if (storage && taskId && run) {
+          const at = ordinals.get(occurrenceId) ?? 0;
+          ordinals.set(occurrenceId, at + 1);
+          writes.push(
+            storage.recordStep(taskId, toStepRow(at, result, stepsByOccurrence.get(occurrenceId)?.get(result.stepId))).then(async (stepRowId) => {
+              const shot = result.evidence?.screenshot;
+              if (!shot) return;
+              await storage.addArtifact(run.id, {
+                runStepId: stepRowId,
+                kind: "screenshot",
+                relPath: shot,
+                bytes: null,
+                masked: true
+              });
+            })
+          );
+        }
         writes.push(
-          storage.recordStep(taskId, toStepRow(at, result, byStepId.get(result.stepId))).then(async (stepRowId) => {
-            const shot = result.evidence?.screenshot;
-            if (!shot) return;
-            await storage.addArtifact(run.id, {
-              runStepId: stepRowId,
-              kind: "screenshot",
-              relPath: shot,
-              bytes: null,
-              masked: true
-            });
-          })
+          emit({ type: "case.step", runId: run?.id ?? "", caseId: testCase.id, occurrenceId, result })
         );
       }
-      writes.push(
-        emit({ type: "case.step", runId: run?.id ?? "", caseId: testCase.id, occurrenceId, result })
-      );
-    }
-  });
+    });
+  } catch (failure) {
+    const error = failure instanceof Error ? failure.message : String(failure);
+    outcome = {
+      status: "errored",
+      error,
+      artifacts: [],
+      durationMs: 0,
+      steps: [],
+      stepsRun: 0,
+      stepsTotal,
+      warnings: [],
+      occurrences: testCase.occurrences.map((item, index) => ({
+        occurrenceId: item.occurrenceId,
+        name: item.name,
+        status: index === 0 ? "errored" : "skipped",
+        error: index === 0 ? error : "browser could not start",
+        steps: [],
+        stepsRun: 0,
+        stepsTotal: item.steps.length,
+        durationMs: 0,
+        continued: false
+      }))
+    };
+  }
   await Promise.all(writes);
   if (storage && run) {
     for (const each of outcome.occurrences) {
@@ -6477,6 +6569,20 @@ var RecordingCoordinator = class {
   starting = null;
   draft = null;
   stopInFlight = null;
+  /** The last completed stop, kept so a caller that missed the answer can ask
+   *  again.
+   *
+   * IN MEMORY AND NEVER ON THE EVENT STREAM. The recording.stopped event is
+   * journalled and replayed to the browser, and this result carries the
+   * passwords the recording captured — so recovery reads it from here rather
+   * than rebuilding it from the event, which would either lose the values or
+   * publish them. */
+  lastResult = null;
+  /** What the last completed stop answered, for a caller that missed it —
+   *  a dropped socket, or a Stop pressed inside the recorded page. */
+  lastStop() {
+    return this.lastResult;
+  }
   active() {
     if (!this.session || !this.draft) return null;
     return { sessionId: this.draft.name, steps: this.draft.steps.length };
@@ -6629,7 +6735,13 @@ var RecordingCoordinator = class {
       this.draft = null;
       return { ok: false, error: "the feature this recording belongs to is gone" };
     }
+    const before = this.deps.store.readSecrets();
     this.deps.store.extractSecrets(slugify(draft.name), steps);
+    const after = this.deps.store.readSecrets();
+    const captured = {};
+    for (const [ref, value] of Object.entries(after)) {
+      if (before[ref] !== value) captured[ref] = value;
+    }
     const doc = {
       schemaVersion: CURRENT_SCHEMA_VERSION,
       id: `flw_${crypto3.randomUUID().slice(0, 8)}`,
@@ -6650,7 +6762,7 @@ var RecordingCoordinator = class {
     this.draft = null;
     const saved = { ...this.deps.store.getFlow(doc.id) ?? doc, path: file };
     this.deps.emit({ type: "recording.stopped", flow: saved, file });
-    return { ok: true, flow: saved };
+    return this.lastResult = { ok: true, flow: saved, secrets: captured };
   }
   /** Throw the recording away: close the browser, drop the draft, write
    *  nothing.
@@ -6708,14 +6820,20 @@ var DebugCoordinator = class {
     this.deps = deps;
   }
   deps;
+  retainCompleted = false;
+  lastState = null;
+  lastEnd = null;
   current = null;
   status() {
-    return this.current ? { flowId: this.current.flowId, state: this.current.session.state() } : { flowId: null, state: null };
+    return this.current ? { flowId: this.current.flowId, state: this.current.session.state() } : this.lastEnd?.ok && this.lastEnd.flow && this.lastState ? { flowId: this.lastEnd.flow.id, state: this.lastState } : { flowId: null, state: null };
   }
   active() {
     return this.current !== null;
   }
   async start(flowId, opts = {}) {
+    this.retainCompleted = opts.retainCompleted === true;
+    this.lastState = null;
+    this.lastEnd = null;
     const store = this.deps.store;
     const flow = store.getFlow(flowId);
     if (!flow) throw new FlowNotFound("flow not found");
@@ -6794,7 +6912,14 @@ var DebugCoordinator = class {
    *  panel's own buttons — so all of them take the same path, including secret
    *  extraction, which must never be skipped by one of several entry points. */
   async end(commit) {
-    if (!this.current) return { ok: false, error: "no debug session is running" };
+    if (!this.current) {
+      if (!commit && this.lastEnd) {
+        this.lastEnd = null;
+        this.lastState = null;
+        return { ok: true, committed: false };
+      }
+      return this.lastEnd ?? { ok: false, error: "no debug session is running" };
+    }
     const { flowId, session } = this.current;
     this.current = null;
     this.deps.lease?.beginRelease("debug");
@@ -6804,6 +6929,7 @@ var DebugCoordinator = class {
         this.deps.emit({ type: "debug.ended", flowId, committed: false });
         return { ok: true, committed: false };
       }
+      this.lastState = this.retainCompleted ? { ...session.state(), status: "finished" } : null;
       const steps = await session.finish();
       const flow = this.deps.store.getFlow(flowId);
       if (!flow) return { ok: false, error: "flow not found" };
@@ -6818,7 +6944,7 @@ var DebugCoordinator = class {
         }
         const updated2 = { ...flow, steps, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
         this.deps.emit({ type: "debug.ended", flowId, committed: true });
-        return { ok: true, committed: true, flow: updated2, secrets: captured };
+        return this.lastEnd = { ok: true, committed: true, flow: updated2, secrets: captured };
       }
       const { store } = this.deps.commit;
       store.extractSecrets(flow.slug, steps);
@@ -7875,6 +8001,8 @@ function executionHandlers(ctx) {
       onActivity?.({ kind: "run", projectId: project.id, detail: flow.name });
       const aborter = new AbortController();
       cancels.set(command.id, { projectId: project.id, cancel: () => aborter.abort() });
+      const cancelKey = command.args["cancelKey"];
+      if (typeof cancelKey === "string" && cancelKey.startsWith("suite:")) cancels.set(cancelKey, cancels.get(command.id));
       let runId = null;
       try {
         const outcome = await executeFlow({
@@ -7913,6 +8041,7 @@ function executionHandlers(ctx) {
         throw err;
       } finally {
         cancels.delete(command.id);
+        if (typeof cancelKey === "string" && cancelKey.startsWith("suite:")) cancels.delete(cancelKey);
         if (runId) cancels.delete(runId);
         onActivity?.(null);
         lease?.release("run");
@@ -7941,10 +8070,13 @@ function executionHandlers(ctx) {
       onActivity?.({ kind: "run", projectId: project.id, detail: testCase.name });
       const aborter = new AbortController();
       cancels.set(command.id, { projectId: project.id, cancel: () => aborter.abort() });
+      const cancelKey = command.args["cancelKey"];
+      if (typeof cancelKey === "string" && cancelKey.startsWith("suite:")) cancels.set(cancelKey, cancels.get(command.id));
       let runId = null;
       try {
         const { outcome, run } = await executeCase({
           testCase,
+          projectId: project.id,
           config: command.args["config"] ?? {},
           secrets: command.args["secrets"] ?? {},
           baseUrl: String(command.args["baseUrl"] ?? ""),
@@ -7976,6 +8108,7 @@ function executionHandlers(ctx) {
         };
       } finally {
         cancels.delete(command.id);
+        if (typeof cancelKey === "string" && cancelKey.startsWith("suite:")) cancels.delete(cancelKey);
         if (runId) cancels.delete(runId);
         onActivity?.(null);
         lease?.release("run");
@@ -8040,7 +8173,10 @@ function recordingHandlers({ recorder, onActivity }) {
       try {
         const saved = await recorder.stop(project.id);
         if (!saved.ok) return { ok: false, reason: "failed", detail: saved.error };
-        return { ok: true, result: { flow: saved.flow, projectId: project.id } };
+        return {
+          ok: true,
+          result: { flow: saved.flow, projectId: project.id, secrets: saved.secrets }
+        };
       } finally {
         onActivity?.(null);
       }
@@ -8083,6 +8219,8 @@ function recordingHandlers({ recorder, onActivity }) {
 }
 function debuggingHandlers(ctx) {
   const { debugging, onActivity, deps } = ctx;
+  let sessionProject = null;
+  let caseSession = null;
   return {
     "flow.verify": async (command, project, emit) => {
       const carried = command.args["flow"];
@@ -8120,14 +8258,17 @@ function debuggingHandlers(ctx) {
     // The browser opens on this machine and the panel lives inside that window,
     // so whoever is at the keyboard sees the same state the dashboard does.
     "debug.start": async (command, project) => {
-      const carried = command.args["flow"];
+      const document2 = command.args["case"] ? TestCaseSchema.parse(command.args["case"]) : null;
+      const plan = document2 ? caseDebugPlan(document2, String(command.args["baseUrl"] ?? "")) : null;
+      const carried = plan?.flow ?? command.args["flow"];
       if (!carried && !project.root) return NO_CHECKOUT;
       if (!debugging) {
         return { ok: false, reason: "failed", detail: "this agent cannot debug \u2014 no browser is configured" };
       }
       try {
-        const started = await debugging.start(String(command.args["flowId"] ?? ""), {
+        const started = await debugging.start(document2?.id ?? String(command.args["flowId"] ?? ""), {
           root: project.root,
+          retainCompleted: Boolean(document2),
           ...command.args["breakpoints"] ? { breakpoints: command.args["breakpoints"] } : {},
           ...command.args["watch"] === void 0 ? {} : { watch: Boolean(command.args["watch"]) },
           ...carried ? {
@@ -8139,6 +8280,8 @@ function debuggingHandlers(ctx) {
             }
           } : {}
         });
+        sessionProject = project.id;
+        caseSession = document2 && plan ? { document: document2, changeId: command.args["caseChangeId"], owners: plan.owners } : null;
         onActivity?.({ kind: "debugging", projectId: project.id, detail: started.flowId });
         return { ok: true, result: started };
       } catch (err) {
@@ -8150,11 +8293,12 @@ function debuggingHandlers(ctx) {
     },
     // A read, so it stays out of EFFECTFUL: it is how a dashboard opened
     // mid-session catches up rather than showing a stale half-run.
-    "debug.status": async () => ({
+    "debug.status": async (_command, project) => ({
       ok: true,
-      result: debugging?.status() ?? { flowId: null, state: null }
+      result: sessionProject === null || sessionProject === project.id ? debugging?.status() ?? { flowId: null, state: null } : { flowId: null, state: null }
     }),
-    "debug.command": async (command) => {
+    "debug.command": async (command, project) => {
+      if (sessionProject !== null && sessionProject !== project.id) return { ok: false, reason: "not_authorised", detail: "this debug session belongs to another project" };
       if (!debugging) return { ok: false, reason: "failed", detail: "no debug session is running" };
       try {
         const state = await debugging.command(String(command.args["command"] ?? ""), {
@@ -8168,11 +8312,17 @@ function debuggingHandlers(ctx) {
         return { ok: false, reason: "failed", detail: String(err.message) };
       }
     },
-    "debug.end": async (command) => {
+    "debug.end": async (command, project) => {
+      if (command.args["caseId"] !== void 0 && command.args["caseId"] !== caseSession?.document.id) return { ok: false, reason: "failed", detail: "this debug session belongs to another test" };
+      if (sessionProject !== null && sessionProject !== project.id) return { ok: false, reason: "not_authorised", detail: "this debug session belongs to another project" };
       if (!debugging) return { ok: false, reason: "failed", detail: "no debug session is running" };
       try {
         const res = await debugging.end(command.args["commit"] !== false);
         if (!res.ok) return { ok: false, reason: "failed", detail: res.error ?? "no debug session is running" };
+        if (caseSession && res.flow) {
+          const testCase = restoreDebugCase(caseSession.document, caseSession.owners, FlowDocumentSchema.parse(res.flow).steps);
+          return { ok: true, result: { ...res, flow: void 0, testCase, caseChangeId: caseSession.changeId } };
+        }
         return { ok: true, result: res };
       } finally {
         onActivity?.(null);
@@ -8194,13 +8344,15 @@ function buildHandlers(deps) {
     artifactLimit: deps.artifactLimitBytes ?? 25 * 1024 * 1024,
     cancels: /* @__PURE__ */ new Map()
   };
+  const debug = debuggingHandlers(context);
   return {
+    "case.debug": debug["debug.start"],
     ...repositoryHandlers(context),
     ...bindingHandlers(context),
     ...historyHandlers(context),
     ...executionHandlers(context),
     ...recordingHandlers(context),
-    ...debuggingHandlers(context)
+    ...debug
   };
 }
 function createAgentRuntime(options) {
@@ -8217,7 +8369,7 @@ function createAgentRuntime(options) {
         lease,
         store: new Store(projectRoot),
         emit: (event) => {
-          if (event.type === "recording.stopped") lastRecording = { ok: true, flow: event.flow };
+          if (event.type === "recording.stopped") lastRecording = { ok: true, flow: event.flow, secrets: {} };
           journal?.append({ name: `recording.${event.type.replace(/^recording\./, "")}`, data: event });
         }
       });
@@ -8274,7 +8426,6 @@ function createAgentRuntime(options) {
     end: async (commit) => {
       if (!debuggingIn) return { ok: false, error: "no debug session is running" };
       const res = await debuggingIn.end(commit);
-      debuggingIn = null;
       return res;
     },
     active: () => Boolean(debuggingIn?.active())
@@ -8305,8 +8456,9 @@ function createAgentRuntime(options) {
     },
     stop: async (projectId) => {
       if (projectId && recordingProject && projectId !== recordingProject) return { ok: false, error: "This recording belongs to another project" };
-      if (lastRecording?.ok) return lastRecording;
-      if (!recordingIn) return lastRecording ?? { ok: false, error: "no recording is in progress on this machine" };
+      const remembered = recordingIn?.lastStop() ?? lastRecording;
+      if (remembered?.ok) return remembered;
+      if (!recordingIn) return remembered ?? { ok: false, error: "no recording is in progress on this machine" };
       const result = await recordingIn.stop();
       lastRecording = result;
       return result;

package/dist/cli.js

@@ -8,7 +8,7 @@ import {
   resolveCheckouts,
   start,
   status
-} from "./chunk-O5HHREII.js";
+} from "./chunk-YIZ6E6DB.js";
 
 // src/cli.ts
 import { parseArgs } from "util";

package/dist/engine.js

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

package/package.json

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