@tonys-software/mimic 0.0.0-stage → 0.1.0-stg.3.1

package/dist/cli.js

@@ -0,0 +1,1431 @@
+#!/usr/bin/env node
+
+// src/commands/list.ts
+import { parseArgs } from "node:util";
+
+// src/shared/output.ts
+var color = (code) => (text) => process.stdout.isTTY ? `\x1B[${code}m${text}\x1B[0m` : text;
+var green = color(32);
+var red = color(31);
+var gray = color(90);
+var seconds = (ms) => `${(ms / 1e3).toFixed(1)}s`;
+
+// src/shared/scenarioFiles.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+function slugify(name) {
+  return name.normalize("NFD").replace(new RegExp("\\p{Mn}", "gu"), "").toLowerCase().replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-|-$/g, "");
+}
+async function scenarioFiles(folder) {
+  const entries = await fs.readdir(folder, { withFileTypes: true, recursive: true });
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path.join(entry.parentPath, entry.name)).filter((file) => !path.relative(folder, file).split(path.sep).some((part) => part === "node_modules" || part.startsWith("."))).sort();
+}
+function withDefaults(locator) {
+  switch (locator.type) {
+    case "Text":
+      return { ...locator, text: locator.text ?? "" };
+    case "Anchored":
+      return { ...locator, anchor: withDefaults(locator.anchor), target: locator.target && withDefaults(locator.target) };
+    default:
+      return locator;
+  }
+}
+function requiredLocator(locator, where) {
+  if (!locator) throw new Error(`${where}: step has no locator`);
+  return withDefaults(locator);
+}
+function stepWithDefaults(step, baseUrl, where) {
+  switch (step.type) {
+    case "Navigate": {
+      const url = step.url ?? "";
+      return { ...step, url: baseUrl === null ? url : resolveUrl(url, baseUrl, where) };
+    }
+    case "Click":
+      return { ...step, locator: requiredLocator(step.locator, where), modifiers: step.modifiers ?? [] };
+    case "Fill":
+      return { ...step, locator: requiredLocator(step.locator, where), value: step.value ?? "", invalid: invalidValues(step.invalid, where) };
+    case "Assertion":
+      return assertionWithDefaults(step);
+    default:
+      throw new Error(`${where}: unknown step type "${step.type}"`);
+  }
+}
+function assertionWithDefaults(step) {
+  return { ...step, locator: step.locator && withDefaults(step.locator) };
+}
+function expectSteps(expect, where) {
+  if (!Array.isArray(expect) || expect.some((step) => typeof step !== "object" || step === null || (step.type ?? "Assertion") !== "Assertion")) {
+    throw new Error(`${where}: "expect" must be a list of Assertion steps`);
+  }
+  return expect.map((step) => assertionWithDefaults({ ...step, type: "Assertion" }));
+}
+function invalidValues(invalid, where) {
+  if (invalid === void 0) return [];
+  if (!Array.isArray(invalid)) throw new Error(`${where}: "invalid" must be a list of { "value", "expect" }`);
+  return invalid.map((entry) => {
+    const { value, expect } = entry ?? {};
+    if (typeof value !== "string") throw new Error(`${where}: each "invalid" entry needs a string "value"`);
+    const steps = expectSteps(expect, where);
+    if (steps.length === 0) throw new Error(`${where}: invalid value "${value}" needs a non-empty "expect"`);
+    return { value, expect: steps };
+  });
+}
+function resolveUrl(url, baseUrl, where) {
+  if (URL.canParse(url)) return url;
+  if (baseUrl === void 0) throw new Error(`${where}: Navigate URL "${url}" is relative; pass --base-url`);
+  return new URL(url, baseUrl).href;
+}
+async function loadFolders(folders, baseUrl) {
+  const found = (await Promise.all(folders.map(async (folder) => {
+    const stat = await fs.stat(folder).catch(() => void 0);
+    if (!stat?.isDirectory()) throw new Error(`Folder "${folder}" not found`);
+    return scenarioFiles(folder);
+  }))).flat();
+  const seen = /* @__PURE__ */ new Set();
+  const paths = found.filter((file) => !seen.has(path.resolve(file)) && seen.add(path.resolve(file)));
+  const scenarios = /* @__PURE__ */ new Map();
+  const groups = /* @__PURE__ */ new Map();
+  const files = /* @__PURE__ */ new Map();
+  for (const file of paths) {
+    let data;
+    try {
+      data = JSON.parse(await fs.readFile(file, "utf8"));
+    } catch (error) {
+      throw new Error(`${file}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const entries = Array.isArray(data) ? data : [data];
+    for (const [index, entry] of entries.entries()) {
+      const where = Array.isArray(data) ? `${file}[${index}]` : file;
+      const { name, steps, prerequisiteName, groupNames = [], expect = [] } = entry ?? {};
+      if (typeof name !== "string" || !name.trim() || !Array.isArray(steps)) {
+        throw new Error(`${where}: not a scenario (needs "name" and "steps")`);
+      }
+      if (prerequisiteName !== void 0 && typeof prerequisiteName !== "string") {
+        throw new Error(`${where}: "prerequisiteName" must be a scenario name`);
+      }
+      if (!Array.isArray(groupNames) || groupNames.some((group) => typeof group !== "string" || !slugify(group))) {
+        throw new Error(`${where}: "groupNames" must be a list of group names`);
+      }
+      const parsedSteps = steps.map((step) => stepWithDefaults(step, baseUrl, where));
+      const parsedExpect = expectSteps(expect, where);
+      if (parsedExpect.length === 0 && parsedSteps.some((step) => step.type === "Fill" && step.invalid.length > 0)) {
+        throw new Error(`${where}: a scenario with "invalid" values needs a non-empty "expect"`);
+      }
+      if (scenarios.has(name)) throw new Error(`${where}: ${files.get(name)} already has the scenario "${name}"`);
+      for (const group of groupNames) {
+        const slug = slugify(group);
+        if (!groups.has(slug)) groups.set(slug, { id: slug, name: group, slug });
+      }
+      scenarios.set(name, {
+        id: name,
+        name,
+        prerequisite: prerequisiteName,
+        groups: [...new Set(groupNames.map(slugify))],
+        steps: parsedSteps,
+        expect: parsedExpect
+      });
+      files.set(name, file);
+    }
+  }
+  return { scenarios: [...scenarios.values()], groups: [...groups.values()], files };
+}
+
+// ../extension/src/scenarioVariants.ts
+var NAME_VALUE_LENGTH = 30;
+var cut = (value) => value.length > NAME_VALUE_LENGTH ? `${value.slice(0, NAME_VALUE_LENGTH - 1)}\u2026` : value;
+function invalidSets(scenario) {
+  const fills = scenario.steps.filter((step) => step.type === "Fill" && step.invalid.length > 0);
+  const longest = Math.max(0, ...fills.map((fill) => fill.invalid.length));
+  return Array.from({ length: longest }, (_, k) => fills.filter((fill) => fill.invalid.length > k).map((fill) => [fill, fill.invalid[k]]));
+}
+function variantRun(scenario, name, values, expect) {
+  return {
+    ...scenario,
+    name,
+    steps: scenario.steps.map((step) => step.type === "Fill" ? { ...step, value: values.get(step) ?? step.value, invalid: [] } : step),
+    expect
+  };
+}
+function expandVariants(scenario) {
+  const invalid = invalidSets(scenario).map((set, index) => {
+    const name = `${scenario.name} \u203A invalid ${index + 1}: ${set.map(([, value]) => `"${cut(value.value)}"`).join(", ")}`;
+    const values = new Map(set.map(([fill, value]) => [fill, value.value]));
+    return {
+      variant: index + 1,
+      scenario: { ...variantRun(scenario, name, values, set.flatMap(([, value]) => value.expect)), id: name }
+    };
+  });
+  return [{ variant: 0, scenario: variantRun(scenario, scenario.name, /* @__PURE__ */ new Map(), scenario.expect) }, ...invalid];
+}
+
+// src/commands/list.ts
+async function execute(args) {
+  const { values } = parseArgs({
+    args,
+    options: {
+      folder: { type: "string", short: "f", multiple: true },
+      help: { type: "boolean", short: "h", default: false }
+    }
+  });
+  if (values.help) {
+    console.log(list.usage);
+    return 0;
+  }
+  const folders = values.folder ?? [];
+  if (folders.length === 0) {
+    throw new Error("Pass the scenario folder with -f");
+  }
+  const { scenarios, files } = await loadFolders(folders, null);
+  if (scenarios.length === 0) {
+    console.log("No scenarios found.");
+    return 0;
+  }
+  const byFile = Map.groupBy(scenarios, (scenario) => files.get(scenario.id));
+  for (const [file, inFile] of byFile) {
+    console.log(file);
+    for (const scenario of inFile) {
+      const { name, prerequisite, groups } = scenario;
+      const invalidRuns = expandVariants(scenario).length - 1;
+      const details = [
+        prerequisite === void 0 ? void 0 : `after "${prerequisite}"`,
+        groups.length === 0 ? void 0 : `groups: ${groups.join(", ")}`,
+        invalidRuns === 0 ? void 0 : `+${invalidRuns} invalid ${invalidRuns === 1 ? "run" : "runs"}`
+      ].filter(Boolean).join("; ");
+      console.log(`  ${name}${details ? gray(` (${details})`) : ""}`);
+    }
+  }
+  return 0;
+}
+var list = {
+  name: "list",
+  summary: "list the scenarios in scenario files, by file",
+  usage: `Usage: mimic list -f <folder>
+
+Prints each scenario file under the folder with the scenarios it holds: their names, the prerequisite they continue
+from and their groups (by slug, as -g takes them).
+
+Options:
+  -f, --folder <path>    the scenario files in this folder (recursively); can repeat
+  -h, --help             show this help`,
+  execute
+};
+
+// src/commands/login.ts
+import { parseArgs as parseArgs2 } from "node:util";
+
+// src/shared/auth.ts
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path2 from "node:path";
+
+// src/shared/config.ts
+var API_URL = "https://app.stg.mimicus.dev";
+var WORKOS_CLIENT_ID = "client_01M4VM6E40X8NEXB778AQTE9KC";
+
+// src/shared/auth.ts
+var WORKOS_URL = "https://api.workos.com";
+var REFRESH_MARGIN_SECONDS = 60;
+var DEVICE_CODE_GRANT = "urn:ietf:params:oauth:grant-type:device_code";
+var WorkOSError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+function sessionFile() {
+  const configDir = process.platform === "win32" ? process.env.APPDATA ?? path2.join(os.homedir(), "AppData", "Roaming") : process.env.XDG_CONFIG_HOME ?? path2.join(os.homedir(), ".config");
+  return path2.join(configDir, "mimic", "session.json");
+}
+function claims(token) {
+  return JSON.parse(Buffer.from(token.split(".")[1], "base64url").toString("utf8"));
+}
+async function loadSession() {
+  try {
+    return JSON.parse(await readFile(sessionFile(), "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function saveSession(session) {
+  const file = sessionFile();
+  await mkdir(path2.dirname(file), { recursive: true });
+  await writeFile(file, JSON.stringify(session), { mode: 384 });
+}
+function deleteSession() {
+  return rm(sessionFile(), { force: true });
+}
+async function workOS(endpoint, body) {
+  const response = await fetch(`${WORKOS_URL}/user_management/${endpoint}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({ client_id: WORKOS_CLIENT_ID, ...body })
+  });
+  const json = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new WorkOSError(json.error, json.error_description ?? json.message ?? `WorkOS returned ${response.status}`);
+  }
+  return json;
+}
+function toSession(json, previous) {
+  return {
+    accessToken: json.access_token,
+    refreshToken: json.refresh_token,
+    email: json.user?.email ?? previous?.email ?? null
+  };
+}
+async function login(onCode) {
+  const device = await workOS("authorize/device", {});
+  onCode({
+    userCode: device.user_code,
+    verificationUri: device.verification_uri,
+    verificationUriComplete: device.verification_uri_complete
+  });
+  let intervalMs = (device.interval ?? 5) * 1e3;
+  const deadline = Date.now() + (device.expires_in ?? 300) * 1e3;
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    try {
+      const session = toSession(await workOS("authenticate", { grant_type: DEVICE_CODE_GRANT, device_code: device.device_code }));
+      await saveSession(session);
+      return session;
+    } catch (e) {
+      if (e instanceof WorkOSError && e.code === "authorization_pending") continue;
+      if (e instanceof WorkOSError && e.code === "slow_down") {
+        intervalMs += 5e3;
+        continue;
+      }
+      throw e;
+    }
+  }
+  throw new Error('The sign-in code expired. Run "mimic login" again.');
+}
+async function getAccessToken() {
+  const session = await loadSession();
+  if (!session) {
+    return void 0;
+  }
+  if (claims(session.accessToken).exp - REFRESH_MARGIN_SECONDS > Date.now() / 1e3) {
+    return session.accessToken;
+  }
+  try {
+    const next = toSession(await workOS("authenticate", { grant_type: "refresh_token", refresh_token: session.refreshToken }), session);
+    await saveSession(next);
+    return next.accessToken;
+  } catch (e) {
+    if (e instanceof WorkOSError && e.code === "invalid_grant") {
+      await deleteSession();
+      return void 0;
+    }
+    throw e;
+  }
+}
+
+// src/commands/login.ts
+async function execute2(args) {
+  const { values } = parseArgs2({
+    args,
+    options: {
+      help: { type: "boolean", short: "h", default: false }
+    }
+  });
+  if (values.help) {
+    console.log(login2.usage);
+    return 0;
+  }
+  const session = await login((code) => {
+    console.log(`Open ${code.verificationUriComplete}`);
+    console.log(gray(`or go to ${code.verificationUri} and enter the code ${code.userCode}`));
+    console.log("Waiting for you to confirm the sign-in...");
+  });
+  console.log(green(`Signed in as ${session.email ?? "unknown user"}`));
+  if (!claims(session.accessToken).org_id) {
+    console.log('Your account is not in an organization yet. Create one in the dashboard, then run "mimic login" again.');
+  }
+  return 0;
+}
+var login2 = {
+  name: "login",
+  summary: "sign in to the config API with your account",
+  usage: `Usage: mimic login
+
+Signs in with a code you confirm in the browser. The session is stored for your user and refreshed automatically,
+so commands that call the config API keep working until you run "mimic logout".`,
+  execute: execute2
+};
+
+// src/commands/logout.ts
+import { parseArgs as parseArgs3 } from "node:util";
+async function execute3(args) {
+  const { values } = parseArgs3({
+    args,
+    options: {
+      help: { type: "boolean", short: "h", default: false }
+    }
+  });
+  if (values.help) {
+    console.log(logout.usage);
+    return 0;
+  }
+  await deleteSession();
+  console.log("Signed out.");
+  return 0;
+}
+var logout = {
+  name: "logout",
+  summary: "remove the stored sign-in session",
+  usage: `Usage: mimic logout
+
+Deletes the session stored by "mimic login".`,
+  execute: execute3
+};
+
+// src/commands/setPrerequisite.ts
+import fs2 from "node:fs/promises";
+import { parseArgs as parseArgs4 } from "node:util";
+
+// src/shared/groups.ts
+function findGroups(slugs, groups) {
+  const bySlug = new Map(groups.map((g) => [g.slug, g]));
+  const unknown = slugs.filter((slug) => !bySlug.has(slug));
+  if (unknown.length > 0) {
+    const known = groups.map((g) => g.slug);
+    throw new Error(`No group ${unknown.map((slug) => `"${slug}"`).join(", ")}${known.length ? ` (groups: ${known.join(", ")})` : ""}`);
+  }
+  return slugs.map((slug) => bySlug.get(slug));
+}
+function parseGroups(tokens) {
+  const slugs = [];
+  let collecting = false;
+  for (const token of tokens) {
+    if (token.kind === "option") {
+      collecting = token.name === "group";
+      if (collecting && token.value !== void 0) slugs.push(token.value);
+    } else if (token.kind === "positional") {
+      if (!collecting) throw new Error(`Unexpected argument "${token.value}"`);
+      slugs.push(token.value);
+    } else {
+      collecting = false;
+    }
+  }
+  const normalized = slugs.map((slug) => slug.trim().toLowerCase());
+  if (normalized.some((slug) => !slug)) {
+    throw new Error("--group needs group slugs");
+  }
+  return [...new Set(normalized)];
+}
+
+// src/commands/setPrerequisite.ts
+function selectTops(scenarios, groupIds, names) {
+  const selected = new Set(scenarios.filter((s) => names.has(s.name) || s.groups.some((id) => groupIds.has(id))).map((s) => s.id));
+  return scenarios.filter((s) => selected.has(s.id) && !(s.prerequisite !== void 0 && selected.has(s.prerequisite)));
+}
+function descendants(scenarios, roots) {
+  const children = Map.groupBy(scenarios.filter((s) => s.prerequisite !== void 0), (s) => s.prerequisite);
+  const found = /* @__PURE__ */ new Set();
+  const pending = roots.map((s) => s.id);
+  for (let id = pending.pop(); id !== void 0; id = pending.pop()) {
+    if (found.has(id)) continue;
+    found.add(id);
+    pending.push(...(children.get(id) ?? []).map((s) => s.id));
+  }
+  return found;
+}
+function withPrerequisite(entry, prerequisite) {
+  const { name, prerequisiteName: _, ...rest } = entry;
+  return { name, prerequisiteName: prerequisite, ...rest };
+}
+var LINE_WIDTH = 120;
+function inline(value) {
+  if (Array.isArray(value)) return `[${value.map(inline).join(", ")}]`;
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value).filter(([, v]) => v !== void 0);
+    return entries.length === 0 ? "{}" : `{ ${entries.map(([k, v]) => `${JSON.stringify(k)}: ${inline(v)}`).join(", ")} }`;
+  }
+  return JSON.stringify(value);
+}
+function format(value, indent, current, prefix = "") {
+  const flat = inline(value);
+  if (value === null || typeof value !== "object" || current.length + prefix.length + flat.length <= LINE_WIDTH) return flat;
+  const inner = current + indent;
+  const items = Array.isArray(value) ? value.map((v) => inner + format(v, indent, inner)) : Object.entries(value).filter(([, v]) => v !== void 0).map(([k, v]) => {
+    const key = `${JSON.stringify(k)}: `;
+    return inner + key + format(v, indent, inner, key);
+  });
+  const [open, close] = Array.isArray(value) ? ["[", "]"] : ["{", "}"];
+  return items.length === 0 ? open + close : `${open}
+${items.join(",\n")}
+${current}${close}`;
+}
+async function rewrite(file, names, prerequisite) {
+  const text = await fs2.readFile(file, "utf8");
+  const data = JSON.parse(text);
+  const update = (entry) => names.has(entry.name) ? withPrerequisite(entry, prerequisite) : entry;
+  const updated = Array.isArray(data) ? data.map(update) : update(data);
+  const indent = /^[ \t]+/m.exec(text)?.[0] ?? "  ";
+  await fs2.writeFile(file, format(updated, indent, "") + "\n");
+}
+async function execute4(args) {
+  const { values, tokens } = parseArgs4({
+    args,
+    allowPositionals: true,
+    tokens: true,
+    options: {
+      folder: { type: "string", short: "f", multiple: true },
+      group: { type: "string", short: "g", multiple: true },
+      scenario: { type: "string", short: "s", multiple: true },
+      prerequisite: { type: "string", short: "p" },
+      help: { type: "boolean", short: "h", default: false }
+    }
+  });
+  if (values.help) {
+    console.log(setPrerequisite.usage);
+    return 0;
+  }
+  const slugs = parseGroups(tokens);
+  const folders = values.folder ?? [];
+  const prerequisite = values.prerequisite?.trim();
+  if (folders.length === 0) {
+    throw new Error("Pass the scenario folder with -f");
+  }
+  if (!prerequisite) {
+    throw new Error("Pass the prerequisite scenario's name with -p");
+  }
+  if (slugs.length === 0 && !values.scenario?.length) {
+    throw new Error("Pick the scenarios with -g and/or -s");
+  }
+  const { scenarios, groups, files } = await loadFolders(folders, null);
+  const target = scenarios.find((s) => s.name === prerequisite);
+  if (!target) {
+    throw new Error(`No scenario named "${prerequisite}"`);
+  }
+  const names = new Set(values.scenario ?? []);
+  const unknown = [...names].filter((name) => !files.has(name));
+  if (unknown.length > 0) {
+    throw new Error(`No scenario ${unknown.map((name) => `"${name}"`).join(", ")}`);
+  }
+  const groupIds = new Set(findGroups(slugs, groups).map((g) => g.id));
+  const byId = new Map(scenarios.map((s) => [s.id, s]));
+  const ancestors = /* @__PURE__ */ new Set();
+  for (let s = target; s && !ancestors.has(s.id); s = s.prerequisite === void 0 ? void 0 : byId.get(s.prerequisite)) {
+    ancestors.add(s.id);
+  }
+  const ownChain = [...names].filter((name) => ancestors.has(name));
+  if (ownChain.length > 0) {
+    throw new Error(`"${prerequisite}" continues from ${ownChain.map((name) => `"${name}"`).join(", ")}; it can't be their prerequisite`);
+  }
+  const tops = selectTops(scenarios, groupIds, names).filter((s) => !ancestors.has(s.id));
+  const changes = tops.filter((s) => s.prerequisite !== target.id);
+  if (changes.length === 0) {
+    console.log(`Nothing to change: they already continue from "${prerequisite}".`);
+    return 0;
+  }
+  const byFile = Map.groupBy(changes, (s) => files.get(s.id));
+  await Promise.all([...byFile].map(([file, inFile]) => rewrite(file, new Set(inFile.map((s) => s.name)), prerequisite)));
+  for (const [file, inFile] of byFile) {
+    console.log(file);
+    for (const s of inFile) {
+      console.log(`  ${green("\u2713")} ${s.name}${gray(s.prerequisite === void 0 ? "" : ` (was after "${s.prerequisite}")`)}`);
+    }
+  }
+  const inherited = descendants(scenarios, changes).size - changes.length;
+  console.log(`${changes.length} changed${inherited > 0 ? gray(`; ${inherited} more continue from them and now run after "${prerequisite}" too`) : ""}`);
+  return 0;
+}
+var setPrerequisite = {
+  name: "set-prerequisite",
+  summary: "make scenarios in scenario files continue from another scenario",
+  usage: `Usage: mimic set-prerequisite -f <folder> -p <scenario name> (-g <slug...> | -s <name>)...
+
+Sets "prerequisiteName" in the scenario files, e.g. to make a feature's scenarios start signed in:
+  mimic set-prerequisite -f scenarios -g todos -p "Auth: sign in"
+Only the selected scenarios that don't already continue from another selected one change; the others keep
+continuing from them, so they run after the prerequisite too. The prerequisite itself and its own prerequisites are
+never changed. Files are rewritten as JSON, short objects and arrays on one line.
+
+Options:
+  -f, --folder <path>         the scenario files in this folder (recursively); can repeat
+  -p, --prerequisite <name>   the scenario they continue from
+  -g, --group <slug...>       select the scenarios in these groups
+  -s, --scenario <name>       select this scenario; can repeat
+  -h, --help                  show this help`,
+  execute: execute4
+};
+
+// src/commands/run.ts
+import { spawn, spawnSync } from "node:child_process";
+import os2 from "node:os";
+import { parseArgs as parseArgs5 } from "node:util";
+
+// src/shared/api.ts
+import https from "node:https";
+import http from "node:http";
+import tls from "node:tls";
+
+// ../jsclient/src/http.ts
+var ApiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+};
+async function send(handler, method, path4, payload) {
+  const init = { method };
+  if (payload !== void 0) {
+    init.headers = { "Content-Type": "application/json" };
+    init.body = JSON.stringify(payload);
+  }
+  const response = await handler(path4, init);
+  if (!response.ok) {
+    const problem = await response.json().catch(() => void 0);
+    throw new ApiError(response.status, problem?.detail || problem?.title || `${method} ${path4} failed: ${response.status}`);
+  }
+  return response.json();
+}
+
+// ../jsclient/src/gen/client/Endpoints/Auth/GetCurrentUserEndpoint.ts
+var GetCurrentUserEndpoint_default = (handler) => () => send(handler, "GET", `api/me`);
+
+// ../jsclient/src/gen/client/Endpoints/Groups/AddScenarioToGroupEndpoint.ts
+var AddScenarioToGroupEndpoint_default = (handler) => (id, scenarioId) => send(handler, "POST", `api/group/${encodeURIComponent(id)}/scenario/${encodeURIComponent(scenarioId)}`);
+
+// ../jsclient/src/gen/client/Endpoints/Groups/CreateGroupEndpoint.ts
+var CreateGroupEndpoint_default = (handler) => (payload) => send(handler, "POST", `api/group`, payload);
+
+// ../jsclient/src/gen/client/Endpoints/Groups/DeleteGroupEndpoint.ts
+var DeleteGroupEndpoint_default = (handler) => (id) => send(handler, "DELETE", `api/group/${encodeURIComponent(id)}`);
+
+// ../jsclient/src/gen/client/Endpoints/Groups/ListGroupsEndpoint.ts
+var ListGroupsEndpoint_default = (handler) => () => send(handler, "GET", `api/group`);
+
+// ../jsclient/src/gen/client/Endpoints/Groups/RemoveScenarioFromGroupEndpoint.ts
+var RemoveScenarioFromGroupEndpoint_default = (handler) => (id, scenarioId) => send(handler, "DELETE", `api/group/${encodeURIComponent(id)}/scenario/${encodeURIComponent(scenarioId)}`);
+
+// ../jsclient/src/gen/client/Endpoints/Groups/UpdateGroupEndpoint.ts
+var UpdateGroupEndpoint_default = (handler) => (id, payload) => send(handler, "PUT", `api/group/${encodeURIComponent(id)}`, payload);
+
+// ../jsclient/src/gen/client/Endpoints/Organizations/CreateOrganizationEndpoint.ts
+var CreateOrganizationEndpoint_default = (handler) => (payload) => send(handler, "POST", `api/organizations`, payload);
+
+// ../jsclient/src/gen/client/Endpoints/Runs/GetRunEndpoint.ts
+var GetRunEndpoint_default = (handler) => (id) => send(handler, "GET", `api/run/${encodeURIComponent(id)}`);
+
+// ../jsclient/src/gen/client/Endpoints/Runs/StartRunEndpoint.ts
+var StartRunEndpoint_default = (handler) => (payload) => send(handler, "POST", `api/run`, payload);
+
+// ../jsclient/src/gen/client/Endpoints/Scenarios/CreateScenarioEndpoint.ts
+var CreateScenarioEndpoint_default = (handler) => (payload) => send(handler, "POST", `api/scenario`, payload);
+
+// ../jsclient/src/gen/client/Endpoints/Scenarios/DeleteScenarioEndpoint.ts
+var DeleteScenarioEndpoint_default = (handler) => (id) => send(handler, "DELETE", `api/scenario/${encodeURIComponent(id)}`);
+
+// ../jsclient/src/gen/client/Endpoints/Scenarios/GetScenarioEndpoint.ts
+var GetScenarioEndpoint_default = (handler) => (id) => send(handler, "GET", `api/scenario/${encodeURIComponent(id)}`);
+
+// ../jsclient/src/gen/client/Endpoints/Scenarios/ListScenariosEndpoint.ts
+var ListScenariosEndpoint_default = (handler) => () => send(handler, "GET", `api/scenario`);
+
+// ../jsclient/src/gen/client/Endpoints/Scenarios/UpdateScenarioEndpoint.ts
+var UpdateScenarioEndpoint_default = (handler) => (id, payload) => send(handler, "PUT", `api/scenario/${encodeURIComponent(id)}`, payload);
+
+// ../jsclient/src/gen/client/Endpoints/Users/InviteUserEndpoint.ts
+var InviteUserEndpoint_default = (handler) => (payload) => send(handler, "POST", `api/invitation`, payload);
+
+// ../jsclient/src/gen/client/Endpoints/Users/ListInvitationsEndpoint.ts
+var ListInvitationsEndpoint_default = (handler) => () => send(handler, "GET", `api/invitation`);
+
+// ../jsclient/src/gen/client/Endpoints/Users/ListMembersEndpoint.ts
+var ListMembersEndpoint_default = (handler) => () => send(handler, "GET", `api/member`);
+
+// ../jsclient/src/gen/client/Endpoints/Users/RemoveMemberEndpoint.ts
+var RemoveMemberEndpoint_default = (handler) => (userId) => send(handler, "DELETE", `api/member/${encodeURIComponent(userId)}`);
+
+// ../jsclient/src/gen/client/Endpoints/Users/RevokeInvitationEndpoint.ts
+var RevokeInvitationEndpoint_default = (handler) => (id) => send(handler, "DELETE", `api/invitation/${encodeURIComponent(id)}`);
+
+// ../jsclient/src/gen/client/index.ts
+function createClient(handler) {
+  return {
+    getCurrentUser: GetCurrentUserEndpoint_default(handler),
+    addScenarioToGroup: AddScenarioToGroupEndpoint_default(handler),
+    createGroup: CreateGroupEndpoint_default(handler),
+    deleteGroup: DeleteGroupEndpoint_default(handler),
+    listGroups: ListGroupsEndpoint_default(handler),
+    removeScenarioFromGroup: RemoveScenarioFromGroupEndpoint_default(handler),
+    updateGroup: UpdateGroupEndpoint_default(handler),
+    createOrganization: CreateOrganizationEndpoint_default(handler),
+    getRun: GetRunEndpoint_default(handler),
+    startRun: StartRunEndpoint_default(handler),
+    createScenario: CreateScenarioEndpoint_default(handler),
+    deleteScenario: DeleteScenarioEndpoint_default(handler),
+    getScenario: GetScenarioEndpoint_default(handler),
+    listScenarios: ListScenariosEndpoint_default(handler),
+    updateScenario: UpdateScenarioEndpoint_default(handler),
+    inviteUser: InviteUserEndpoint_default(handler),
+    listInvitations: ListInvitationsEndpoint_default(handler),
+    listMembers: ListMembersEndpoint_default(handler),
+    removeMember: RemoveMemberEndpoint_default(handler),
+    revokeInvitation: RevokeInvitationEndpoint_default(handler)
+  };
+}
+
+// src/shared/api.ts
+function trustedCertificates() {
+  const getCertificates = tls.getCACertificates;
+  if (!getCertificates) return void 0;
+  return [...getCertificates("default"), ...getCertificates("system")];
+}
+var SIGN_IN_HINT = 'Run "mimic login" to sign in.';
+var nodeHandler = async (path4, init) => {
+  const url = `${API_URL.replace(/\/$/, "")}/${path4}`;
+  const method = init.method ?? "GET";
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error(`Not signed in. ${SIGN_IN_HINT}`);
+  }
+  const headers = { authorization: `Bearer ${token}` };
+  new Headers(init.headers).forEach((value, key) => {
+    headers[key] = value;
+  });
+  const client = url.startsWith("https:") ? https : http;
+  const { status, body } = await new Promise((resolve, reject) => {
+    const request = client.request(url, { method, headers, ca: trustedCertificates() }, (response) => {
+      const chunks = [];
+      response.on("data", (chunk) => chunks.push(chunk));
+      response.on("end", () => resolve({ status: response.statusCode, body: Buffer.concat(chunks).toString("utf8") }));
+    });
+    request.on("error", (error) => reject(new Error(`${method} ${url} failed: ${error.message}`)));
+    request.end(init.body);
+  });
+  if (status === 401) {
+    throw new Error(`The config API rejected your session. ${SIGN_IN_HINT}`);
+  }
+  if (status === 403) {
+    throw new Error('Your account is not in an organization yet. Create one in the dashboard, then run "mimic login" again.');
+  }
+  return new Response(body, { status });
+};
+var api = createClient(nodeHandler);
+
+// src/shared/runner.ts
+import path3 from "node:path";
+import { fileURLToPath } from "node:url";
+import { chromium, errors } from "playwright";
+var LOCATE_TIMEOUT_MS = 4e3;
+var RELOCATE_TIMEOUT_MS = 1e3;
+var POLL_INTERVAL_MS = 150;
+var PAGE_LOAD_TIMEOUT_MS = 15e3;
+var NO_LOAD_MS = 1500;
+var INJECT_PATH = path3.join(path3.dirname(fileURLToPath(import.meta.url)), "inject.js");
+var PAGE_LOAD_ERROR = `page did not finish loading in ${PAGE_LOAD_TIMEOUT_MS / 1e3}s`;
+var MODIFIER_KEYS = {
+  Alt: "Alt",
+  Ctrl: "Control",
+  Meta: "Meta",
+  Shift: "Shift"
+};
+function isNavigationError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /Execution context was destroyed|Cannot find context|navigation/i.test(message);
+}
+async function loading(promise) {
+  try {
+    return await promise;
+  } catch (error) {
+    if (error instanceof errors.TimeoutError) throw new Error(PAGE_LOAD_ERROR);
+    throw error;
+  }
+}
+function isMainFrameNavigation(page, request) {
+  try {
+    return request.isNavigationRequest() && request.frame() === page.mainFrame();
+  } catch {
+    return false;
+  }
+}
+var PendingNavigation = class {
+  startedAt;
+  waiters = [];
+  constructor(page) {
+    page.on("request", (request) => {
+      if (isMainFrameNavigation(page, request)) this.startedAt ??= Date.now();
+    });
+    page.on("requestfailed", (request) => {
+      if (isMainFrameNavigation(page, request)) this.end();
+    });
+    page.on("load", () => this.end());
+  }
+  async wait() {
+    if (this.startedAt === void 0) return;
+    let timeoutId;
+    const loaded = await Promise.race([
+      new Promise((resolve) => this.waiters.push(() => resolve(true))),
+      new Promise((resolve) => {
+        timeoutId = setTimeout(() => resolve(false), this.startedAt + PAGE_LOAD_TIMEOUT_MS - Date.now());
+      })
+    ]);
+    clearTimeout(timeoutId);
+    if (!loaded) throw new Error(PAGE_LOAD_ERROR);
+  }
+  end() {
+    this.startedAt = void 0;
+    for (const waiter of this.waiters.splice(0)) waiter();
+  }
+};
+var pendingNavigations = /* @__PURE__ */ new WeakMap();
+function restoreSessionStorage(data) {
+  const values = data[location.origin];
+  if (!values) return;
+  for (const [key, value] of Object.entries(values)) sessionStorage.setItem(key, value);
+}
+async function settle(page) {
+  try {
+    await page.evaluate(() => window.__scenarioRunner.settle());
+  } catch (error) {
+    if (!isNavigationError(error)) throw error;
+  }
+  await pendingNavigations.get(page)?.wait();
+  await loading(page.waitForLoadState("load", { timeout: PAGE_LOAD_TIMEOUT_MS }));
+}
+async function find(page, step, kind, timeoutMs = LOCATE_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    let error;
+    try {
+      await loading(page.waitForLoadState("domcontentloaded", { timeout: PAGE_LOAD_TIMEOUT_MS }));
+      const handle = await page.evaluateHandle(
+        ({ locator, kind: kind2 }) => window.__scenarioRunner.find(locator, kind2),
+        { locator: step.locator, kind }
+      );
+      const element = handle.asElement();
+      if (element) return element;
+      error = await handle.jsonValue();
+      await handle.dispose();
+    } catch (e) {
+      if (!isNavigationError(e)) throw e;
+      error = "page navigated while locating the element";
+    }
+    if (Date.now() >= deadline) throw new Error(error);
+    await page.waitForTimeout(POLL_INTERVAL_MS);
+  }
+}
+async function isConnected(element) {
+  try {
+    return await element.evaluate((el) => el.isConnected);
+  } catch {
+    return false;
+  }
+}
+async function inputField(page, step, previous) {
+  if (await isConnected(previous)) return previous;
+  try {
+    return await find(page, step, "fill", RELOCATE_TIMEOUT_MS);
+  } catch {
+    throw new Error("input element was replaced and could not be found again");
+  }
+}
+async function typeInto(page, step, element) {
+  const target = await inputField(page, step, element);
+  const problem = await target.evaluate((el) => window.__scenarioRunner.editProblem(el));
+  if (problem) {
+    throw new Error(problem);
+  }
+  await target.fill("");
+  await page.keyboard.type(step.value);
+  await settle(page);
+  return target;
+}
+async function pickOption(page, step, element) {
+  const moves = await element.evaluate((el, option) => window.__scenarioRunner.optionMoves(el, option), step.value);
+  if (typeof moves === "string") throw new Error(moves);
+  await element.click({ force: true, noWaitAfter: true });
+  for (let i = 0; i < Math.abs(moves); i++) await page.keyboard.press(moves < 0 ? "ArrowUp" : "ArrowDown");
+  await page.keyboard.press("Enter");
+  await settle(page);
+}
+async function playFill(page, step, element) {
+  const tag = await element.evaluate((el) => el.tagName.toLowerCase());
+  if (tag === "select") {
+    await pickOption(page, step, element);
+    return;
+  }
+  if (tag !== "input" && tag !== "textarea") throw new Error("target is not an input-capable element");
+  if (!await element.evaluate((el) => el === document.activeElement)) {
+    await element.focus();
+    await settle(page);
+  }
+  const target = await typeInto(page, step, element);
+  if (!await isConnected(target)) await typeInto(page, step, target);
+}
+async function playAssertion(page, step) {
+  const deadline = Date.now() + LOCATE_TIMEOUT_MS;
+  for (; ; ) {
+    let problem;
+    try {
+      await loading(page.waitForLoadState("domcontentloaded", { timeout: PAGE_LOAD_TIMEOUT_MS }));
+      problem = await page.evaluate((s) => window.__scenarioRunner.assertionProblem(s), step);
+    } catch (e) {
+      if (!isNavigationError(e)) throw e;
+      problem = `${step.assertionType} assertion failed: page navigated while checking`;
+    }
+    if (!problem) return;
+    if (Date.now() >= deadline) throw new Error(problem);
+    await page.waitForTimeout(POLL_INTERVAL_MS);
+  }
+}
+async function playExpect(page, expect) {
+  const pending = expect.map((step, i) => ({ index: i + 1, step, problem: void 0 }));
+  const deadline = Date.now() + LOCATE_TIMEOUT_MS;
+  for (; ; ) {
+    for (const assertion of [...pending]) {
+      try {
+        await loading(page.waitForLoadState("domcontentloaded", { timeout: PAGE_LOAD_TIMEOUT_MS }));
+        assertion.problem = await page.evaluate((s) => window.__scenarioRunner.assertionCheck(s), assertion.step);
+      } catch (e) {
+        if (!isNavigationError(e)) throw e;
+        assertion.problem = "page navigated while checking";
+      }
+      if (!assertion.problem) pending.splice(pending.indexOf(assertion), 1);
+    }
+    if (pending.length === 0) return;
+    if (Date.now() >= deadline) {
+      throw new Error(pending.map((a, i) => `expect ${a.index} (${a.step.assertionType}): ${a.problem}${i === 0 ? ` (on ${page.url()})` : ""}`).join("\n"));
+    }
+    await page.waitForTimeout(POLL_INTERVAL_MS);
+  }
+}
+async function playStep(page, step) {
+  switch (step.type) {
+    case "Navigate":
+      await loading(page.goto(step.url, { waitUntil: "load", timeout: PAGE_LOAD_TIMEOUT_MS }));
+      return;
+    case "Click": {
+      const element = await find(page, step, "click");
+      await element.click({ force: true, noWaitAfter: true, modifiers: step.modifiers.map((m) => MODIFIER_KEYS[m]) });
+      await settle(page);
+      return;
+    }
+    case "Fill":
+      await playFill(page, step, await find(page, step, "fill"));
+      return;
+    case "Assertion":
+      await playAssertion(page, step);
+      return;
+    default: {
+      const unhandled = step;
+      throw new Error(`unknown step type: ${unhandled.type}`);
+    }
+  }
+}
+async function waitForNoLoad(page) {
+  let lastLoad = Date.now();
+  const onRequest = (request) => {
+    if (request.isNavigationRequest() && request.frame() === page.mainFrame()) {
+      lastLoad = Date.now();
+    }
+  };
+  page.on("request", onRequest);
+  try {
+    const deadline = Date.now() + PAGE_LOAD_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      await loading(page.waitForLoadState("load", { timeout: PAGE_LOAD_TIMEOUT_MS }));
+      const quietMs = Date.now() - lastLoad;
+      if (quietMs >= NO_LOAD_MS) {
+        return;
+      }
+      await page.waitForTimeout(NO_LOAD_MS - quietMs);
+    }
+  } finally {
+    page.off("request", onRequest);
+  }
+}
+async function captureState(context, page, parent) {
+  await waitForNoLoad(page);
+  const url = page.url();
+  const session = await page.evaluate(() => Object.fromEntries(
+    Array.from({ length: sessionStorage.length }, (_, i) => sessionStorage.key(i)).map((key) => [key, sessionStorage.getItem(key) ?? ""])
+  ));
+  return {
+    url,
+    storageState: await context.storageState(),
+    sessionStorage: { ...parent?.sessionStorage, [new URL(url).origin]: session }
+  };
+}
+var Runner = class _Runner {
+  constructor(browser) {
+    this.browser = browser;
+  }
+  static async launch(headless) {
+    return new _Runner(await chromium.launch({ headless }));
+  }
+  async run(scenario, parent) {
+    const context = await this.browser.newContext({ storageState: parent?.storageState });
+    try {
+      await context.addInitScript({ path: INJECT_PATH });
+      const page = await context.newPage();
+      pendingNavigations.set(page, new PendingNavigation(page));
+      const [first] = scenario.steps;
+      const startUrl = first?.type === "Navigate" ? first.url : parent?.url;
+      if (!startUrl) {
+        throw new Error("scenario has no prerequisite and does not start with a Navigate step");
+      }
+      const restore = parent && await page.addInitScript(restoreSessionStorage, parent.sessionStorage);
+      await loading(page.goto(startUrl, { waitUntil: "load", timeout: PAGE_LOAD_TIMEOUT_MS }));
+      await restore?.dispose();
+      for (const [index, step] of scenario.steps.entries()) {
+        if (index === 0 && step.type === "Navigate") {
+          continue;
+        }
+        try {
+          await playStep(page, step);
+        } catch (error) {
+          const message = error instanceof Error ? error.message.split("\n")[0] : String(error);
+          const where = step.type === "Navigate" ? "" : ` (on ${page.url()})`;
+          throw new Error(`step ${index + 1} (${step.type}): ${message}${where}`);
+        }
+      }
+      if (scenario.expect.length > 0) await playExpect(page, scenario.expect);
+      return await captureState(context, page, parent);
+    } finally {
+      await context.close();
+    }
+  }
+  async close() {
+    await this.browser.close();
+  }
+};
+
+// src/commands/run.ts
+var MEMORY_PER_WORKER = 400 * 1024 * 1024;
+var CLOUD_POLL_INTERVAL_MS = 1e3;
+var WAITING_NOTICE_MS = 15e3;
+var APP_WAIT_MS = 3e4;
+var APP_POLL_INTERVAL_MS = 250;
+var APP_LOG_TAIL_LINES = 30;
+function buildForest(scenarios) {
+  const nodes = new Map(scenarios.map((scenario) => [scenario.id, { scenario, children: [], height: 0, descendants: 0 }]));
+  const roots = [];
+  const orphans = /* @__PURE__ */ new Map();
+  for (const node of nodes.values()) {
+    const prerequisite = node.scenario.prerequisite;
+    if (!prerequisite) {
+      roots.push(node);
+    } else if (nodes.has(prerequisite)) {
+      nodes.get(prerequisite).children.push(node);
+    } else {
+      orphans.set(node, `prerequisite "${prerequisite}" not found`);
+    }
+  }
+  const reached = /* @__PURE__ */ new Set();
+  const measure = (node) => {
+    reached.add(node);
+    for (const child of node.children) {
+      measure(child);
+      node.height = Math.max(node.height, child.height + 1);
+      node.descendants += child.descendants + 1;
+    }
+  };
+  for (const root of [...roots, ...orphans.keys()]) measure(root);
+  for (const node of nodes.values()) {
+    if (!reached.has(node)) {
+      node.children = [];
+      orphans.set(node, "prerequisite cycle");
+    }
+  }
+  return { roots, orphans };
+}
+function byPriority(a, b) {
+  return b.node.height - a.node.height || b.node.descendants - a.node.descendants;
+}
+function schedule(scenarios, workers, run2, onResult) {
+  const { roots, orphans } = buildForest(scenarios);
+  const results = [];
+  const report = (result) => {
+    results.push(result);
+    onResult(result);
+  };
+  const skipTree = (node, reason) => {
+    report({ scenario: node.scenario, status: "skipped", reason });
+    for (const child of node.children) skipTree(child, reason);
+  };
+  for (const [node, reason] of orphans) skipTree(node, reason);
+  const ready = roots.map((node) => ({ node, parentState: void 0 }));
+  let running = 0;
+  return new Promise((resolve) => {
+    const pump = () => {
+      ready.sort(byPriority);
+      while (running < workers && ready.length > 0) {
+        const { node, parentState } = ready.shift();
+        running++;
+        const started = Date.now();
+        run2(node.scenario, parentState).then(
+          (state) => {
+            report({ scenario: node.scenario, status: "passed", state, durationMs: Date.now() - started });
+            ready.push(...node.children.map((child) => ({ node: child, parentState: state })));
+          },
+          (error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            report({ scenario: node.scenario, status: "failed", error: message, durationMs: Date.now() - started });
+            for (const child of node.children) skipTree(child, `prerequisite "${node.scenario.name}" failed`);
+          }
+        ).finally(() => {
+          running--;
+          pump();
+        });
+      }
+      if (running === 0 && ready.length === 0) resolve(results);
+    };
+    pump();
+  });
+}
+function inGroups(scenarios, groups) {
+  const groupIds = new Set(groups.map((g) => g.id));
+  const byId = new Map(scenarios.map((scenario) => [scenario.id, scenario]));
+  const members = scenarios.filter((s) => s.groups.some((id) => groupIds.has(id)));
+  const memberIds = new Set(members.map((s) => s.id));
+  const included = /* @__PURE__ */ new Set();
+  const prerequisiteOnly = /* @__PURE__ */ new Set();
+  for (const scenario of members) {
+    let next = scenario;
+    while (next && !included.has(next.id)) {
+      included.add(next.id);
+      if (!memberIds.has(next.id)) prerequisiteOnly.add(next.id);
+      next = next.prerequisite ? byId.get(next.prerequisite) : void 0;
+    }
+  }
+  return { scenarios: scenarios.filter((s) => included.has(s.id)), prerequisiteOnly };
+}
+var inGroupsLabel = (slugs) => slugs.length === 0 ? "" : ` in ${slugs.length === 1 ? "group" : "groups"} ${slugs.join(", ")}`;
+function defaultWorkers() {
+  const byCpu = Math.max(1, os2.availableParallelism() - 1);
+  const byMemory = Math.max(1, Math.floor(os2.freemem() / MEMORY_PER_WORKER));
+  return Math.min(byCpu, byMemory);
+}
+function parseWorkers(value) {
+  if (value === void 0) {
+    return defaultWorkers();
+  }
+  const workers = Number(value);
+  if (!Number.isInteger(workers) || workers < 1) {
+    throw new Error(`--workers must be a positive integer, got "${value}"`);
+  }
+  return workers;
+}
+var CLOUD_STATUS = {
+  Pending: void 0,
+  Passed: "passed",
+  Failed: "failed",
+  PrerequisiteFailed: "skipped",
+  PrerequisiteMissing: "skipped"
+};
+function printLine({ name, status, prerequisiteOnly, durationMs, browser, message, file }) {
+  const details = [
+    prerequisiteOnly ? "prerequisite" : void 0,
+    durationMs === void 0 ? void 0 : seconds(durationMs),
+    browser
+  ].filter(Boolean).join(", ");
+  const suffix = details ? ` ${gray(`(${details})`)}` : "";
+  switch (status) {
+    case "passed":
+      console.log(prerequisiteOnly ? gray(`\u2713 ${name}${suffix}`) : `${green("\u2713")} ${name}${suffix}`);
+      break;
+    case "failed":
+      console.log(`${red("\u2717")} ${name}${suffix}
+    ${red((message ?? "failed").replaceAll("\n", "\n    "))}${file ? gray(` (${file})`) : ""}`);
+      break;
+    case "skipped":
+      console.log(`${gray("-")} ${name} ${gray(`skipped: ${message ?? ""}`)}`);
+      break;
+  }
+}
+function printSummary(lines, started) {
+  const count = (status, prerequisiteOnly) => lines.filter((l) => l.status === status && l.prerequisiteOnly === prerequisiteOnly).length;
+  const failed = count("failed", false);
+  const skipped = count("skipped", false);
+  const prerequisites = ["passed", "failed", "skipped"].map((status) => [status, count(status, true)]).filter(([, n]) => n > 0).map(([status, n]) => status === "failed" ? red(`${n} failed`) : `${n} ${status}`);
+  const prerequisitesNote = prerequisites.length ? `; prerequisites: ${prerequisites.join(", ")}` : "";
+  console.log(`
+${green(`${count("passed", false)} passed`)}, ${failed ? red(`${failed} failed`) : "0 failed"}, ${skipped} skipped${prerequisitesNote} ${gray(`(${seconds(Date.now() - started)})`)}`);
+  return lines.some((l) => l.status !== "passed") ? 1 : 0;
+}
+function reportLine(result, prerequisiteOnly) {
+  const { name } = result.scenario;
+  switch (result.status) {
+    case "passed":
+      return { name, prerequisiteOnly, status: "passed", durationMs: result.durationMs };
+    case "failed":
+      return { name, prerequisiteOnly, status: "failed", durationMs: result.durationMs, message: result.error };
+    case "skipped":
+      return { name, prerequisiteOnly, status: "skipped", message: result.reason };
+  }
+}
+async function runLocally(workers, windows, slugs, source) {
+  const { scenarios: all, groups: known, files } = await source();
+  const groups = findGroups(slugs, known);
+  const selected = groups.length === 0 ? { scenarios: all, prerequisiteOnly: /* @__PURE__ */ new Set() } : inGroups(all, groups);
+  const { prerequisiteOnly } = selected;
+  const sources = /* @__PURE__ */ new Map();
+  const scenarios = selected.scenarios.flatMap((scenario) => expandVariants(scenario).filter(({ variant }) => variant === 0 || !prerequisiteOnly.has(scenario.id)).map(({ scenario: run2 }) => {
+    sources.set(run2.id, scenario.id);
+    return run2;
+  }));
+  if (scenarios.length === 0) {
+    console.log("No scenarios found.");
+    return 0;
+  }
+  console.log(gray(`Running ${scenarios.length} scenarios${inGroupsLabel(slugs)} locally with ${workers} workers
+`));
+  const started = Date.now();
+  const runner = await Runner.launch(!windows);
+  const lines = [];
+  try {
+    await schedule(scenarios, workers, (scenario, parent) => runner.run(scenario, parent), (result) => {
+      const line = { ...reportLine(result, prerequisiteOnly.has(result.scenario.id)), file: files?.get(sources.get(result.scenario.id)) };
+      lines.push(line);
+      printLine(line);
+    });
+  } finally {
+    await runner.close();
+  }
+  return printSummary(lines, started);
+}
+async function runInCloud(slugs) {
+  const started = Date.now();
+  const groups = findGroups(slugs, slugs.length === 0 ? [] : await api.listGroups());
+  let run2 = await api.startRun({ groups: groups.map((g) => g.id) });
+  if (run2.scenarios.length === 0) {
+    console.log("No scenarios found.");
+    return 0;
+  }
+  console.log(gray(`Started run ${run2.id}: ${run2.scenarios.length} scenarios${inGroupsLabel(slugs)} on the cloud workers
+`));
+  const reported = /* @__PURE__ */ new Set();
+  let lastProgress = Date.now();
+  let waitingShown = false;
+  for (; ; ) {
+    for (const scenario of run2.scenarios) {
+      const status = CLOUD_STATUS[scenario.status];
+      const key = `${scenario.scenarioId}:${scenario.variant}`;
+      if (!status || reported.has(key)) continue;
+      reported.add(key);
+      lastProgress = Date.now();
+      waitingShown = false;
+      printLine({
+        name: scenario.name,
+        status,
+        prerequisiteOnly: scenario.prerequisiteOnly === true,
+        durationMs: scenario.durationMs,
+        browser: scenario.browser,
+        message: scenario.error
+      });
+    }
+    if (run2.status === "Completed") break;
+    if (!waitingShown && Date.now() - lastProgress >= WAITING_NOTICE_MS) {
+      const pending = run2.scenarios.filter((s) => s.status === "Pending").length;
+      console.log(gray(`Waiting for workers (${pending} pending)...`));
+      waitingShown = true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, CLOUD_POLL_INTERVAL_MS));
+    run2 = await api.getRun(run2.id);
+  }
+  return printSummary(run2.scenarios.map((s) => ({
+    status: CLOUD_STATUS[s.status] ?? "skipped",
+    prerequisiteOnly: s.prerequisiteOnly === true
+  })), started);
+}
+async function answers(baseUrl, timeoutMs) {
+  try {
+    await fetch(baseUrl, { redirect: "manual", signal: AbortSignal.timeout(Math.max(timeoutMs, 1)) });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function startApp(command, baseUrl) {
+  if (await answers(baseUrl, 1e3)) {
+    throw new Error(`${baseUrl} already answers before --start ran; stop what is running there, or leave out --start to test it`);
+  }
+  const url = new URL(baseUrl);
+  const port = url.port || (url.protocol === "https:" ? "443" : "80");
+  const child = spawn(command, {
+    shell: true,
+    detached: process.platform !== "win32",
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, PORT: port }
+  });
+  const lines = [];
+  let partial = "";
+  const collect = (chunk) => {
+    const parts = (partial + chunk.toString()).split(/\r?\n/);
+    partial = parts.pop() ?? "";
+    lines.push(...parts);
+    lines.splice(0, Math.max(lines.length - APP_LOG_TAIL_LINES, 0));
+  };
+  child.stdout.on("data", collect);
+  child.stderr.on("data", collect);
+  const exited = new Promise((resolve) => {
+    child.once("exit", (code) => resolve(code));
+    child.once("error", () => resolve(null));
+  });
+  let stopped = false;
+  const stop = () => {
+    if (stopped || child.pid === void 0 || child.exitCode !== null) {
+      return;
+    }
+    stopped = true;
+    if (process.platform === "win32") {
+      spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+    } else {
+      try {
+        process.kill(-child.pid, "SIGTERM");
+      } catch {
+        child.kill("SIGTERM");
+      }
+    }
+  };
+  process.once("exit", stop);
+  for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.once(signal, () => process.exit(130));
+  }
+  return { exited, logTail: () => [...lines, partial].filter((line) => line.trim() !== "").join("\n") };
+}
+async function waitForApp(baseUrl, app) {
+  const deadline = Date.now() + APP_WAIT_MS;
+  let exitCode;
+  void app?.exited.then((code) => {
+    exitCode = code;
+  });
+  const withLog = (message) => {
+    const tail = app?.logTail();
+    return tail ? `${message}
+Last app output:
+${tail}` : message;
+  };
+  for (; ; ) {
+    if (await answers(baseUrl, Math.min(deadline - Date.now(), 2e3))) {
+      return;
+    }
+    if (exitCode !== void 0) {
+      throw new Error(withLog(`the app exited (code ${exitCode}) before ${baseUrl} answered`));
+    }
+    if (Date.now() >= deadline) {
+      throw new Error(withLog(`no response from ${baseUrl} in ${APP_WAIT_MS / 1e3}s; ${app ? "did the app start on PORT?" : "is the app running?"}`));
+    }
+    await new Promise((resolve) => setTimeout(resolve, APP_POLL_INTERVAL_MS));
+  }
+}
+async function execute5(args) {
+  const { values, tokens } = parseArgs5({
+    args,
+    allowPositionals: true,
+    tokens: true,
+    options: {
+      cloud: { type: "boolean", default: false },
+      folder: { type: "string", short: "f", multiple: true },
+      "base-url": { type: "string" },
+      start: { type: "string" },
+      group: { type: "string", short: "g", multiple: true },
+      workers: { type: "string", short: "w" },
+      windows: { type: "boolean", default: false },
+      help: { type: "boolean", short: "h", default: false }
+    }
+  });
+  if (values.help) {
+    console.log(run.usage);
+    return 0;
+  }
+  const slugs = parseGroups(tokens);
+  const folders = values.folder ?? [];
+  const baseUrl = values["base-url"];
+  if (baseUrl !== void 0 && !URL.canParse(baseUrl)) {
+    throw new Error(`--base-url must be an absolute URL, got "${baseUrl}"`);
+  }
+  if (baseUrl !== void 0 && folders.length === 0) {
+    throw new Error("--base-url only applies with --folder");
+  }
+  if (values.start !== void 0 && baseUrl === void 0) {
+    throw new Error("--start needs --folder and --base-url");
+  }
+  if (values.cloud) {
+    if (values.workers !== void 0 || values.windows || folders.length > 0 || values.start !== void 0) {
+      throw new Error("--workers, --windows, --folder and --start only apply to local runs, not --cloud");
+    }
+    return runInCloud(slugs);
+  }
+  const source = folders.length > 0 ? async () => {
+    const loaded = await loadFolders(folders, baseUrl);
+    if (baseUrl !== void 0) {
+      const app = values.start === void 0 ? void 0 : await startApp(values.start, baseUrl);
+      await waitForApp(baseUrl, app);
+    }
+    return loaded;
+  } : async () => {
+    const [scenarios, groups] = await Promise.all([api.listScenarios(), slugs.length === 0 ? [] : api.listGroups()]);
+    return { scenarios, groups };
+  };
+  return runLocally(parseWorkers(values.workers), values.windows, slugs, source);
+}
+var run = {
+  name: "run",
+  summary: "run all scenarios or some groups, locally or on the cloud workers",
+  usage: `Usage: mimic run [options]
+
+Runs every scenario from the config API (${API_URL}); branches run after their prerequisite passes.
+By default they run on this machine in parallel Chromium contexts. With --cloud the config API schedules them on its
+workers and this command reports their results until the run completes.
+With --group only the scenarios in those groups run, plus the prerequisites they continue from; a scenario in
+several of them runs once. Groups are named by slug, as the extension shows them (e.g. -g smoke focus).
+With --folder the scenarios come from the JSON files in that folder and its subfolders instead of the API (local
+runs only). Each file holds a scenario or an array of them: "name", "steps", optionally "prerequisiteName" (another file's scenario name)
+and "groupNames" (-g takes their slugs: lowercase, non-alphanumerics as "-"). "expect" holds the assertions
+checked after the steps; each "invalid" value on a Fill step adds a run that types it and checks its own "expect"
+instead (run k types every field's k-th invalid value). Relative Navigate URLs resolve against --base-url, and the run waits up to 30s for it to answer, so it can start right after the app.
+With --start the run starts the app itself (a shell command, with PORT set to --base-url's port), waits for it,
+and stops it when the run ends; if it doesn't come up, its last output is printed.
+
+Options:
+  -g, --group <slug...>  run only the scenarios in these groups (and their prerequisites)
+  -f, --folder <path>    run the scenario files in this folder (recursively) instead of the API's; can repeat
+      --base-url <url>   with --folder: base for relative Navigate URLs (e.g. http://localhost:5173); waits up
+                         to 30s for it to answer
+      --start <command>  with --base-url: start the app with this command (PORT set) and stop it afterwards
+      --cloud            run on the cloud workers instead of locally
+  -w, --workers <n>      local only: parallel browser contexts (default: based on CPUs and free memory)
+      --windows          local only: show the browser windows
+  -h, --help             show this help`,
+  execute: execute5
+};
+
+// src/cli.ts
+var COMMANDS = [login2, logout, run, list, setPrerequisite];
+var USAGE = `Usage: mimic <command> [options]
+
+Commands:
+${COMMANDS.map((command) => `  ${command.name.padEnd(17)} ${command.summary}`).join("\n")}
+
+Run "mimic <command> --help" for a command's options.`;
+async function main() {
+  const [name, ...args] = process.argv.slice(2);
+  const command = COMMANDS.find((c) => c.name === name);
+  if (command) {
+    return command.execute(args);
+  }
+  if (name === "-h" || name === "--help") {
+    console.log(USAGE);
+    return 0;
+  }
+  if (name === void 0) {
+    console.log(USAGE);
+    return 1;
+  }
+  console.error(`Unknown command "${name}"
+
+${USAGE}`);
+  return 1;
+}
+main().then(
+  (code) => process.exit(code),
+  (error) => {
+    console.error(red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+);