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

package/dist/{chunk-5J5D7IIT.js → chunk-EBT7VSPY.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.24";
 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";
@@ -1177,6 +1215,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,6 +1493,85 @@ 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";
@@ -4388,6 +4564,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;
@@ -5441,6 +5637,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 +5708,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 +7977,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 +8535,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 +8984,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 +10054,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-EBT7VSPY.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-EBT7VSPY.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.24",
   "description": "Run Flowriki UI tests on your own computer. Connects this machine to your Flowriki account.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",