@flowriki/agent 0.1.0-beta.23 → 0.1.0-beta.25

package/dist/{chunk-5J5D7IIT.js → chunk-WJ643WHC.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.23";
+var AGENT_VERSION = "0.1.0-beta.25";
 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-BZ2CJR5T.js
+// ../contracts/dist/chunk-MQTBBCDK.js
 import { z } from "zod";
 var PROTOCOL_VERSION = 1;
 var PAIRING_CODE_TTL_MS = 5 * 60 * 1e3;
@@ -290,7 +290,10 @@ var AGENT_FEATURES = /* @__PURE__ */ new Set([
   "authentication.v1",
   /** More than one participant, each with a browser session of its own —
    *  which also covers starting one over and sharing a captured output. */
-  "actors.v1"
+  "actors.v1",
+  /** Replaying other flows' steps before a recording starts capturing, so a
+   *  flow can be recorded from where its prerequisites leave the browser. */
+  "prerequisites.v1"
 ]);
 var AgentMessageSchema = z.discriminatedUnion("type", [
   AckSchema,
@@ -458,7 +461,7 @@ import path7 from "path";
 // ../engine-playwright/dist/index.js
 import path3 from "path";
 
-// ../test-model/dist/chunk-X4X4KGMA.js
+// ../test-model/dist/chunk-TSFRTYLG.js
 import { z as z3 } from "zod";
 var LocatorOverrideSchema = z3.object({
   strategy: z3.enum(["css", "xpath", "id", "testId", "text", "label", "placeholder", "altText", "title"]),
@@ -759,6 +762,12 @@ var ActorDefinitionSchema = z3.object({
   name: z3.string().min(1),
   startSignedIn: z3.object({ profileId: z3.string().min(1), accountId: z3.string().optional() }).strict().optional()
 }).strict();
+var FlowSignInSchema = z3.object({
+  profileId: z3.string().min(1),
+  accountId: z3.string().optional(),
+  from: z3.enum(["loginPage", "here"]).optional()
+}).strict();
+var FlowPrerequisitesSchema = z3.array(z3.object({ flowId: z3.string().min(1) }).strict());
 var CURRENT_SCHEMA_VERSION = 5;
 var FlowDocumentSchema = z3.object({
   schemaVersion: z3.literal(CURRENT_SCHEMA_VERSION),
@@ -800,6 +809,24 @@ var FlowDocumentSchema = z3.object({
   path: z3.string().optional(),
   actors: z3.array(ActorDefinitionSchema).optional(),
   defaultActorId: z3.string().optional(),
+  /** SIGN IN FIRST: the account this flow starts as, before anything else runs.
+   *
+   * A setting rather than step one, which is what it used to be saved as. As a
+   * step it could not be switched off without deleting it, and a flow reused
+   * as somebody else's prerequisite could not tell "my own sign-in" from a
+   * sign-in that is part of what it tests. `parseFlowDocument` lifts an old
+   * step one into this field, so both spellings read the same. A reference to
+   * a profile, never a copy of its steps. */
+  signIn: FlowSignInSchema.optional(),
+  /** Flows replayed, in this order, after signing in and before this flow's
+   *  own steps — to reach the state it starts from.
+   *
+   *  LINKS, NOT COPIES: re-record "Save basic info" once and every flow that
+   *  starts after it follows. Each runs WITHOUT its own sign-in; this flow's
+   *  is the only one. Explicit and flat — nothing here pulls in a
+   *  prerequisite's prerequisites at run time, so what runs is exactly this
+   *  list. The editor fills those in when a flow is added. */
+  prerequisites: FlowPrerequisitesSchema.optional(),
   /** Bumped on every save. An edit carries the revision it was made against,
    *  so a save built on a stale copy is refused instead of overwriting work
    *  somebody else — or a debug session on the same machine — has since done.
@@ -895,8 +922,19 @@ function parseFlowDocument(input) {
     version += 1;
     raw.schemaVersion = version;
   }
+  liftSignInFirst(raw);
   return FlowDocumentSchema.parse(raw);
 }
+var SIGN_IN_FIRST_STEP_ID = "sign-in-first";
+function liftSignInFirst(raw) {
+  const first = raw.steps?.[0];
+  const auth = first?.auth;
+  if (!first || first.type !== "signIn" || first.disabled === true || first.actorId !== void 0) return;
+  if (!auth || typeof auth.profileId !== "string" || !auth.profileId) return;
+  if (raw["signIn"] !== void 0 || Array.isArray(raw["actors"]) && raw["actors"].length > 0) return;
+  raw["signIn"] = auth;
+  raw.steps = raw.steps.slice(1);
+}
 
 // ../test-model/dist/index.js
 import { z as z4 } from "zod";
@@ -1015,7 +1053,25 @@ var FlowOccurrenceSchema = z22.object({
      *  against the source can line the two up; nothing depends on it to run. */
     stepIds: z22.record(z22.string(), z22.string()).default({}),
     copiedAt: z22.string()
-  })
+  }),
+  /** WHICH OF THIS ROW'S STEPS ARE WHAT RUNS BEFORE ITS FLOW — the flow's
+   *  sign-in and the prerequisites copied in with it — so the row can be shown
+   *  folded, the way the Flows screen shows the same flow.
+   *
+   *  A description of steps the row already holds, and nothing more: they are
+   *  ordinary copies in `steps` and run in order whatever this says. Kept by
+   *  id, so editing or deleting one of them leaves the rest still grouped.
+   *  Absent on every row copied before this existed, which simply show flat.
+   *  Never sent to a machine — see `withoutFolding`. */
+  before: z22.object({
+    /** The flow's own sign-in, when the copy brought one. */
+    signInStepId: z22.string().optional(),
+    flows: z22.array(z22.object({
+      flowId: z22.string(),
+      name: z22.string(),
+      stepIds: z22.array(z22.string())
+    }).strict()).default([])
+  }).strict().optional()
 }).strict();
 var CASE_SCHEMA_VERSION = 1;
 var TestCaseSchema = z22.object({
@@ -1177,6 +1233,65 @@ function sessionLanes(occurrences, defaultActorId) {
   }
   return rows;
 }
+function randomUUID() {
+  const crypto5 = globalThis.crypto;
+  if (crypto5?.randomUUID) return crypto5.randomUUID();
+  return `${Date.now().toString(16)}-${Math.random().toString(16).slice(2, 14)}`;
+}
+var mintPage = (remap, pageId) => {
+  if (pageId === "main") return "main";
+  const existing = remap.pages.get(pageId);
+  if (existing) return existing;
+  const fresh = `pg_${randomUUID().replace(/-/g, "").slice(0, 12)}`;
+  remap.pages.set(pageId, fresh);
+  return fresh;
+};
+function retarget(target, remap) {
+  if (!target.pageId) return target;
+  return { ...target, pageId: mintPage(remap, target.pageId) };
+}
+function copyStep(step, remap) {
+  const copied = retarget({ ...step, id: remap.steps.get(step.id) }, remap);
+  if (copied.opensPage) copied.opensPage = mintPage(remap, copied.opensPage);
+  if (copied.to) copied.to = retarget({ ...copied.to }, remap);
+  if (copied.scroll?.container) {
+    copied.scroll = { ...copied.scroll, container: retarget({ ...copied.scroll.container }, remap) };
+  }
+  copied.proposals = step.proposals.map((assertion) => ({ ...assertion }));
+  return copied;
+}
+function copyFlowIntoCase(flow, context) {
+  const remap = { steps: /* @__PURE__ */ new Map(), pages: /* @__PURE__ */ new Map() };
+  for (const step of flow.steps) {
+    remap.steps.set(step.id, `st_${randomUUID().replace(/-/g, "").slice(0, 12)}`);
+  }
+  const steps = flow.steps.map((step) => copyStep(step, remap));
+  return {
+    occurrenceId: `occ_${randomUUID().replace(/-/g, "").slice(0, 12)}`,
+    name: flow.name,
+    // WHO RUNS THIS COPY. The flow said which of its participants it belongs
+    // to; dropping that here made every copy run as the main participant, so a
+    // flow recorded as the approver silently became the buyer doing approvals.
+    // The case has to be given the participant too — see `mergeParticipants`.
+    ...flow.defaultActorId && flow.defaultActorId !== "default" ? { actorId: flow.defaultActorId } : {},
+    ...flow.baseUrl ? { baseUrl: flow.baseUrl } : {},
+    startPath: flow.startPath,
+    navigateFirst: false,
+    steps,
+    ...flow.environment ? { environment: flow.environment } : {},
+    origin: {
+      flowId: flow.id,
+      schemaVersion: flow.schemaVersion,
+      revision: flow.revision,
+      ...context.commit ? { commit: context.commit } : {},
+      featureId: flow.featureId,
+      featureName: context.featureName,
+      flowName: flow.name,
+      stepIds: Object.fromEntries(remap.steps),
+      copiedAt: (context.at ?? /* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
 function caseDebugPlan(testCase, baseUrl) {
   const owners = {};
   const steps = [];
@@ -1396,10 +1511,89 @@ function sameIdentity(a, b2) {
   if (a.accountId && b2.accountId) return a.accountId === b2.accountId;
   return true;
 }
+var PrerequisiteProblem = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PrerequisiteProblem";
+  }
+};
+function signInFirstStep(flow, id = SIGN_IN_FIRST_STEP_ID) {
+  if (!flow.signIn) return null;
+  return {
+    id,
+    type: "signIn",
+    auth: flow.signIn,
+    name: "Sign in first",
+    role: "",
+    scope: "",
+    value: "",
+    secret: false,
+    legacySelector: "",
+    proposals: []
+  };
+}
+function stepsWithoutSignIn(flow) {
+  const first = flow.steps[0];
+  return first && first.type === "signIn" && !first.disabled ? flow.steps.slice(1) : flow.steps;
+}
+var idsOf = (flow) => (flow.prerequisites ?? []).map((p) => p.flowId);
+function prerequisiteProblems(flow, lookup) {
+  const problems = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of idsOf(flow)) {
+    if (id === flow.id) {
+      problems.push(`"${flow.name}" cannot run before itself`);
+      continue;
+    }
+    if (seen.has(id)) {
+      problems.push(`"${lookup(id)?.name ?? id}" is listed twice before "${flow.name}"`);
+      continue;
+    }
+    seen.add(id);
+    const prerequisite = lookup(id);
+    if (!prerequisite) {
+      problems.push(`a flow "${flow.name}" runs after no longer exists \u2014 remove it from the list`);
+      continue;
+    }
+    if (reaches(prerequisite, flow.id, lookup, /* @__PURE__ */ new Set())) {
+      problems.push(`"${prerequisite.name}" already runs after "${flow.name}", so it cannot also run before it`);
+    }
+  }
+  return problems;
+}
+function reaches(from, target, lookup, visited) {
+  if (visited.has(from.id)) return false;
+  visited.add(from.id);
+  return idsOf(from).some((id) => {
+    if (id === target) return true;
+    const next = lookup(id);
+    return next ? reaches(next, target, lookup, visited) : false;
+  });
+}
+function prerequisitesOf(flow, lookup) {
+  const problems = prerequisiteProblems(flow, lookup);
+  if (problems.length > 0) throw new PrerequisiteProblem(problems.join("; "));
+  return idsOf(flow).map((id) => lookup(id));
+}
+function stepsForHost(prerequisite) {
+  return copyFlowIntoCase({ ...prerequisite, steps: stepsWithoutSignIn(prerequisite) }, { featureName: "" }).steps;
+}
+function preparationFor(flow, lookup) {
+  return {
+    signIn: signInFirstStep(flow),
+    steps: prerequisitesOf(flow, lookup).flatMap(stepsForHost)
+  };
+}
+function expandForRun(flow, lookup) {
+  const { signIn: _signIn, prerequisites: _prerequisites, ...rest } = flow;
+  if (!flow.signIn && idsOf(flow).length === 0) return rest;
+  const { signIn, steps } = preparationFor(flow, lookup);
+  return { ...rest, steps: [...signIn ? [signIn] : [], ...steps, ...flow.steps] };
+}
 
 // ../engine-playwright/dist/index.js
 import { createHmac, randomBytes } from "crypto";
-import { errors } from "playwright";
+import { errors as errors2 } from "playwright";
 
 // ../core/dist/index.js
 function proposeAssertions(before, after) {
@@ -1720,7 +1914,7 @@ var STEP_PRESENTATION = {
 // ../engine-playwright/dist/index.js
 import fs4 from "fs";
 import path22 from "path";
-import { chromium, firefox, webkit } from "playwright";
+import { chromium, errors, firefox, webkit } from "playwright";
 
 // ../recorder/dist/index.js
 function openShadowRoots() {
@@ -3747,38 +3941,63 @@ function resolveCapture(options = {}) {
   };
 }
 var forcedHeadless = () => process.env["FLOWRIKI_FORCE_HEADLESS"] === "1";
+var LAUNCH_ATTEMPT_MS = () => Number(process.env["FLOWRIKI_LAUNCH_TIMEOUT_MS"] ?? 45e3);
+var isStartupFailure = (error) => error instanceof errors.TimeoutError || /Target page, context or browser has been closed|Browser has been closed|browser has disconnected/i.test(String(error?.message ?? error));
+async function launchWithRetry(launch, setUp, { attempts = 2, pauseMs = 1e3 } = {}) {
+  let last;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    let browser = null;
+    try {
+      browser = await launch(LAUNCH_ATTEMPT_MS());
+      return { browser, value: await setUp(browser) };
+    } catch (error) {
+      last = error;
+      await browser?.close().catch(() => {
+      });
+      if (!isStartupFailure(error)) throw error;
+      if (attempt < attempts) await new Promise((r) => setTimeout(r, pauseMs));
+    }
+  }
+  const seconds = Math.round(LAUNCH_ATTEMPT_MS() / 1e3);
+  const why = String(last?.message ?? last).split("\n")[0];
+  throw new Error(
+    `the browser did not start after ${attempts} attempts of ${seconds}s each (${why}) \u2014 on a Mac this is usually a visible browser that could not open a window; run it again, or run it headless`
+  );
+}
 async function launchSession(environment = {}, headlessRequested = true, slowMo = 0, capture = {}, existingBrowser, storageState) {
   const headless = headlessRequested || forcedHeadless();
   const config = { ...DEFAULT_ENVIRONMENT, ...ExecutionEnvironmentSchema.parse(environment) };
   const fullWindow = config.fullWindow === true && !headless;
   const engine = { chromium, firefox, webkit }[config.browser];
-  const browser = existingBrowser ?? await engine.launch({
+  const launch = (timeout) => engine.launch({
     headless,
     slowMo,
+    timeout,
     // Chromium's flag. Firefox and WebKit have no equivalent, and `viewport:
     // null` still gives them a page that fills their default window — bigger
     // than the fixed box, if not maximised.
     ...fullWindow && config.browser === "chromium" ? { args: ["--start-maximized"] } : {}
   });
+  const { viewport, locale, timezoneId, colorScheme } = config;
+  const artifacts = resolveCapture(capture);
+  const makeContext = (browser2) => browser2.newContext({
+    viewport: fullWindow ? null : viewport,
+    locale,
+    timezoneId,
+    colorScheme,
+    ...storageState ? { storageState } : {},
+    // Playwright can only be told to record at context creation, so a video
+    // wanted "on failure" is recorded for every run and thrown away when the
+    // run passes. There is no way to start one after the fact.
+    //
+    // The video still needs a fixed size even when the page has none —
+    // `size` is what the file is encoded at, and Playwright scales the frame
+    // to fit it. The configured viewport is the closest thing to an intended
+    // aspect ratio we have.
+    ...artifacts.video !== "off" && capture.dir ? { recordVideo: { dir: capture.dir, size: viewport } } : {}
+  });
+  const { browser, value: context } = existingBrowser ? { browser: existingBrowser, value: await makeContext(existingBrowser) } : await launchWithRetry(launch, makeContext);
   try {
-    const { viewport, locale, timezoneId, colorScheme } = config;
-    const artifacts = resolveCapture(capture);
-    const context = await browser.newContext({
-      viewport: fullWindow ? null : viewport,
-      locale,
-      timezoneId,
-      colorScheme,
-      ...storageState ? { storageState } : {},
-      // Playwright can only be told to record at context creation, so a video
-      // wanted "on failure" is recorded for every run and thrown away when the
-      // run passes. There is no way to start one after the fact.
-      //
-      // The video still needs a fixed size even when the page has none —
-      // `size` is what the file is encoded at, and Playwright scales the frame
-      // to fit it. The configured viewport is the closest thing to an intended
-      // aspect ratio we have.
-      ...artifacts.video !== "off" && capture.dir ? { recordVideo: { dir: capture.dir, size: viewport } } : {}
-    });
     if (artifacts.trace !== "off" && capture.dir) {
       await context.tracing.start({ screenshots: true, snapshots: true, sources: false });
     }
@@ -4388,6 +4607,26 @@ var checkStep = (id, proposals) => ({
   legacySelector: "",
   proposals
 });
+async function replayInto(target, steps, opts) {
+  const session = {
+    ownsBrowser: false,
+    browser: target.browser,
+    context: target.context,
+    page: target.page,
+    pages: new ExecutionPages(target.context, target.page),
+    config: target.config,
+    artifacts: resolveCapture({ policy: { screenshot: "off", video: "off", trace: "off", console: false } }),
+    consoleLines: [],
+    runArtifacts: []
+  };
+  const outcome = await runStepsIn(session, steps, {
+    startUrl: null,
+    ...opts.resolveSecret ? { resolveSecret: opts.resolveSecret } : {},
+    ...opts.resolveAuth ? { resolveAuth: opts.resolveAuth } : {},
+    ...opts.baseUrl ? { baseUrl: opts.baseUrl } : {}
+  });
+  return outcome.status === "passed" ? { ok: true } : { ok: false, error: outcome.error ?? "a step before recording did not complete" };
+}
 function opensItsOwnEntry(steps, opts) {
   const first = steps.find((step) => !step.disabled);
   if (!first || first.type !== "signIn" || !first.auth) return false;
@@ -4643,7 +4882,7 @@ async function runStepsIn(session, steps, opts) {
         }
       } catch (err) {
         result.status = "failed";
-        result.failureKind = err.kind ?? (/strict mode violation/.test(String(err)) ? "ambiguous" : err instanceof errors.TimeoutError ? "timeout" : "unknown");
+        result.failureKind = err.kind ?? (/strict mode violation/.test(String(err)) ? "ambiguous" : err instanceof errors2.TimeoutError ? "timeout" : "unknown");
         result.detail = firstLine2(err);
       }
       const wantsShot = artifacts.screenshot === "always" || artifacts.screenshot === "on-failure" && result.status === "failed";
@@ -5441,6 +5680,25 @@ async function startRecordingSession(opts) {
       throw new Error(`${firstLine2(error)} \u2014 the browser was on ${landed || "/"}${title ? ` ("${title}")` : ""}`);
     }
   }
+  const prepared = Boolean(opts.preparation?.steps.length);
+  if (opts.preparation && prepared) {
+    try {
+      if (!opts.authentication) await page.goto(url, { waitUntil: "domcontentloaded" });
+      const replayed = await replayInto({ browser, context, page, config }, opts.preparation.steps, {
+        resolveSecret: opts.preparation.resolveSecret,
+        ...opts.preparation.resolveAuth ? { resolveAuth: opts.preparation.resolveAuth } : {},
+        baseUrl: url
+      });
+      if (!replayed.ok) throw new Error(replayed.error);
+    } catch (error) {
+      const landed = page.url().replace(/^https?:\/\/[^/]+/, "");
+      const title = await page.title().catch(() => "");
+      stopped = true;
+      await browser.close().catch(() => {
+      });
+      throw new Error(`the flows this one starts after did not finish: ${firstLine2(error)} \u2014 the browser was on ${landed || "/"}${title ? ` ("${title}")` : ""}`);
+    }
+  }
   await context.addInitScript({ content: INIT_SCRIPT });
   const ensureInstalled = async (p) => {
     try {
@@ -5493,7 +5751,7 @@ async function startRecordingSession(opts) {
     });
   });
   try {
-    if (!opts.authentication) await page.goto(url, { waitUntil: "domcontentloaded", timeout: 45e3 });
+    if (!opts.authentication && !prepared) await page.goto(url, { waitUntil: "domcontentloaded", timeout: 45e3 });
     else await ensureInstalled(page);
   } catch (err) {
     stopped = true;
@@ -7762,8 +8020,15 @@ var LOCAL_CHROMIUM = { id: "chromium", provider: "local", engine: "chromium" };
 async function executeFlow(opts) {
   const { store, storage = null, flowId, trigger, watch = false, onEvent } = opts;
   const headless = watch ? false : opts.headless ?? store.readConfig().headless;
-  const flow = store.getFlow(flowId);
-  if (!flow) throw new FlowNotRunnable(`flow not found: ${flowId}`, "not_found");
+  const found = store.getFlow(flowId);
+  if (!found) throw new FlowNotRunnable(`flow not found: ${flowId}`, "not_found");
+  let flow = found;
+  try {
+    flow = expandForRun(found, (id) => store.getFlow(id));
+  } catch (problem) {
+    if (problem instanceof PrerequisiteProblem) throw new FlowNotRunnable(problem.message, "empty");
+    throw problem;
+  }
   if (opts.expectedRevision !== void 0 && flow.revision !== opts.expectedRevision) {
     throw new FlowConflict("the flow changed before execution \u2014 reload it before running", flow.revision);
   }
@@ -8313,6 +8578,11 @@ var RecordingCoordinator = class {
           resolveAuth: authenticationResolver(opts.authentications),
           resolveSecret: (ref) => opts.secrets?.[ref]
         } } : {},
+        ...opts.preparation?.length ? { preparation: {
+          steps: opts.preparation,
+          resolveAuth: authenticationResolver(opts.authentications),
+          resolveSecret: (ref) => opts.secrets?.[ref]
+        } } : {},
         // The project's saved defaults, unless this recording asks for
         // something else. Without the fallback the settings screen would write
         // a file nothing ever read.
@@ -8757,7 +9027,7 @@ function resolveCheckouts(dirs) {
   return { projects, skipped };
 }
 
-// ../agent-core/dist/chunk-EJDGHASQ.js
+// ../agent-core/dist/chunk-4MOK25KG.js
 import { WebSocket, WebSocketServer } from "ws";
 var HEARTBEAT_MS = 3e4;
 function adapt(socket) {
@@ -9827,8 +10097,10 @@ function recordingHandlers({ recorder, onActivity }) {
           // returned on stop for the service to commit to the repository. A
           // machine that has the project checked out still records into it.
           root,
-          ...command.args["authentication"] ? {
-            authentication: AuthReferenceSchema.parse(command.args["authentication"]),
+          ...command.args["authentication"] ? { authentication: AuthReferenceSchema.parse(command.args["authentication"]) } : {},
+          // The flows this recording starts after, replayed before capturing.
+          ...Array.isArray(command.args["preparation"]) && command.args["preparation"].length > 0 ? { preparation: RecordedStepSchema.array().parse(command.args["preparation"]) } : {},
+          ...command.args["authentication"] || command.args["preparation"] ? {
             authentications: command.args["authentications"],
             secrets: command.args["secrets"] ?? {}
           } : {},

package/dist/cli.js

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

package/dist/engine.js

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

package/package.json

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