@bugmole/cli 0.4.0

package/src/runner-worker/index.ts

@@ -0,0 +1,108 @@
+// valkyrie-runner: starts one Cloudflare Container per Bugmole Cloud job
+// (a test run or a discovery task).
+// Only the registry calls it, through a service binding; it has no public
+// route. The container runs `bugmole run-once` and exits when the run is done.
+import { Container } from "@cloudflare/containers";
+
+export type LaunchRequest = { kind: "run" | "task"; id: string; projectId: string; token: string; registryUrl: string };
+
+type RunnerEnv = {
+  CLOUD_RUNNER: DurableObjectNamespace<CloudRunner>;
+  /** Longest a container may live, in minutes; a little above the registry's run limit. */
+  RUNNER_HARD_LIMIT_MINUTES?: string;
+  /** Browsers one run drives at once; sized to the instance type. */
+  RUNNER_TARGET_CONCURRENCY?: string;
+};
+
+type LaunchRecord = LaunchRequest & { startedAt: number };
+
+const DEFAULT_HARD_LIMIT_MINUTES = 70;
+
+export function isLaunchRequest(value: unknown): value is LaunchRequest {
+  const body = value as Partial<LaunchRequest> | null;
+  return Boolean(
+    body
+      && (body.kind === "run" || body.kind === "task")
+      && typeof body.id === "string" && /^[A-Za-z0-9_-]{1,80}$/.test(body.id)
+      && typeof body.projectId === "string" && body.projectId.length > 0
+      && typeof body.token === "string" && body.token.startsWith("vrt_")
+      && typeof body.registryUrl === "string" && /^https:\/\//.test(body.registryUrl),
+  );
+}
+
+export class CloudRunner extends Container<RunnerEnv> {
+  // The run needs the customer's site and the registry.
+  enableInternet = true;
+  // Checked every couple of minutes while the run goes; see onActivityExpired.
+  sleepAfter = "2m";
+
+  async launch(request: LaunchRequest): Promise<void> {
+    const record: LaunchRecord = { ...request, startedAt: Date.now() };
+    await this.ctx.storage.put("launch", record);
+    await this.start({
+      envVars: {
+        BUGMOLE_REGISTRY_URL: request.registryUrl,
+        ...(request.kind === "run" ? { BUGMOLE_RUN_ID: request.id } : { BUGMOLE_TASK_ID: request.id }),
+        BUGMOLE_RUN_TOKEN: request.token,
+        BUGMOLE_TARGET_CONCURRENCY: this.env.RUNNER_TARGET_CONCURRENCY ?? "2",
+      },
+      labels: { job: `${request.kind}:${request.id}`, project: request.projectId },
+    });
+  }
+
+  /**
+   * A run makes no requests to its container, so the idle timer would stop it
+   * mid-run. Keep it alive until the process exits on its own, with a hard cap
+   * in case it never does.
+   */
+  override async onActivityExpired(): Promise<void> {
+    const record = await this.ctx.storage.get<LaunchRecord>("launch");
+    const limit = (Number(this.env.RUNNER_HARD_LIMIT_MINUTES) || DEFAULT_HARD_LIMIT_MINUTES) * 60_000;
+    if (!record || Date.now() - record.startedAt > limit) {
+      await this.destroy();
+      return;
+    }
+    this.renewActivityTimeout();
+  }
+
+  /**
+   * `bugmole run-once` reports its own result and exits 0 or 1. Any other exit
+   * (killed, out of memory) never reached the registry, so say so here rather
+   * than wait for the registry to notice the silence.
+   */
+  override async onStop({ exitCode }: { exitCode: number; reason: string }): Promise<void> {
+    const record = await this.ctx.storage.get<LaunchRecord>("launch");
+    await this.ctx.storage.delete("launch");
+    if (!record || exitCode === 0 || exitCode === 1) return;
+    const errorMessage = `The cloud runner stopped unexpectedly (exit code ${exitCode}).`;
+    const path = record.kind === "run" ? `runs/${encodeURIComponent(record.id)}` : `tasks/${encodeURIComponent(record.id)}`;
+    const body = record.kind === "run"
+      ? { workerId: `cloud:${record.id}`, status: "error", eventType: "failed", failureCode: "runner_crashed", errorMessage }
+      : { workerId: `cloud:task:${record.id}`, status: "error", errorMessage };
+    await fetch(`${record.registryUrl}/api/${path}`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${record.token}`, "content-type": "application/json" },
+      body: JSON.stringify(body),
+    }).catch(() => undefined);
+  }
+}
+
+export default {
+  async fetch(request: Request, env: RunnerEnv): Promise<Response> {
+    const url = new URL(request.url);
+    const match = url.pathname.match(/^\/jobs\/(run|task)\/([^/]+)\/start$/);
+    if (request.method !== "POST" || !match) return Response.json({ error: "Not found" }, { status: 404 });
+    const body = await request.json().catch(() => null);
+    if (!isLaunchRequest(body) || body.kind !== match[1] || body.id !== decodeURIComponent(match[2])) {
+      return Response.json({ error: "A job kind and id, project, runner token and registry URL are required" }, { status: 422 });
+    }
+    try {
+      // One container per job: the job names the instance.
+      await env.CLOUD_RUNNER.get(env.CLOUD_RUNNER.idFromName(`${body.kind}:${body.id}`)).launch(body);
+      return Response.json({ started: true }, { status: 202 });
+    } catch (error) {
+      console.error(`[runner] couldn't start ${body.kind} ${body.id}`, error);
+      return Response.json({ error: "The runner couldn't start" }, { status: 503 });
+    }
+  },
+};

package/src/runtime/ai-analysis.ts

@@ -0,0 +1,97 @@
+import { callModel } from "./llm.js";
+import type { FailureAnalysis, FailureContext } from "./failure-analysis.js";
+
+type LlmConfig = { provider?: string; model?: string; api_key?: string; base_url?: string };
+
+const API_PROVIDERS = new Set(["openai", "anthropic", "ollama"]);
+
+/** The model a project configured for analysis, or null when none is usable. */
+export function analysisModel(cfg: { llm?: LlmConfig } | undefined): Required<Pick<LlmConfig, "provider" | "model">> & LlmConfig | null {
+  const llm = cfg?.llm;
+  const provider = llm?.provider?.toLowerCase();
+  if (!provider || !API_PROVIDERS.has(provider)) return null;
+  const apiKey = llm?.api_key?.trim();
+  if (provider !== "ollama" && (!apiKey || apiKey === "not-set")) return null;
+  return { ...llm, provider, model: llm?.model || (provider === "anthropic" ? "claude-sonnet-5" : "gpt-4o-mini") };
+}
+
+function parseJson(text: string): Record<string, unknown> | null {
+  const body = text.trim().replace(/^```(?:json)?\s*/i, "").replace(/```\s*$/, "");
+  const start = body.indexOf("{");
+  const end = body.lastIndexOf("}");
+  if (start < 0 || end <= start) return null;
+  try {
+    return JSON.parse(body.slice(start, end + 1)) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+const clip = (value: unknown, max: number) => (typeof value === "string" && value.trim() ? value.trim().slice(0, max) : undefined);
+
+export async function explainWithModel(
+  cfg: { llm?: LlmConfig } | undefined,
+  analysis: FailureAnalysis,
+  context: FailureContext,
+  call: typeof callModel = callModel,
+): Promise<FailureAnalysis> {
+  const model = analysisModel(cfg);
+  if (!model) return analysis;
+  return explainWith(async (prompt) => ({
+    text: await call(prompt, {
+      provider: model.provider,
+      model: model.model,
+      apiKey: model.api_key,
+      baseUrl: model.base_url,
+      timeout: 20_000,
+    }),
+    // The model name is what people recognise; the provider is only the API shape.
+    model: model.model,
+  }), analysis, context);
+}
+
+export function explanationPrompt(analysis: FailureAnalysis, context: FailureContext): string {
+  return [
+    "You are a QA engineer explaining why an end-to-end browser test failed.",
+    "Use only the evidence below. Be specific and brief. Do not invent steps or values.",
+    'Return JSON only: {"title": string (max 70 chars), "rootCause": string (max 2 sentences), "fixSummary": string (max 1 sentence, or "" if no fix)}.',
+    "",
+    `Failed step: ${context.failedStep ?? "(unknown)"}`,
+    `Error: ${context.error}`,
+    `Page: ${context.url ?? ""} ${context.title ?? ""}`,
+    `Visible messages: ${JSON.stringify(context.alerts)}`,
+    `Empty or invalid fields: ${JSON.stringify(context.invalidFields)}`,
+    `Controls and headings: ${JSON.stringify(context.candidates.slice(0, 40))}`,
+    `Uncaught page errors: ${JSON.stringify(context.pageErrors.slice(0, 3))}`,
+    `Rule-based finding: ${JSON.stringify({ category: analysis.category, title: analysis.title, rootCause: analysis.rootCause, fix: analysis.suggestedFix?.summary })}`,
+  ].join("\n");
+}
+
+/**
+ * Lets a model explain a failure in plain words. The model only rewrites the
+ * explanation: the evidence and any fix stay the rules' checked output, so a
+ * model can never propose an edit nobody verified here. Falls back to the
+ * rules' analysis on any error.
+ */
+export async function explainWith(
+  call: (prompt: string) => Promise<{ text: string; model: string }>,
+  analysis: FailureAnalysis,
+  context: FailureContext,
+): Promise<FailureAnalysis> {
+  try {
+    const answer = await call(explanationPrompt(analysis, context));
+    const reply = parseJson(answer.text);
+    if (!reply) return analysis;
+    const fixSummary = clip(reply.fixSummary, 200);
+    return {
+      ...analysis,
+      source: "ai",
+      model: answer.model,
+      title: clip(reply.title, 90) ?? analysis.title,
+      rootCause: clip(reply.rootCause, 400) ?? analysis.rootCause,
+      ...(analysis.suggestedFix && fixSummary ? { suggestedFix: { ...analysis.suggestedFix, summary: fixSummary } } : {}),
+    };
+  } catch {
+    return analysis;
+  }
+}

package/src/runtime/ai-exploration.test.ts

@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { explorationPrompt, parseExploration } from "./ai-exploration.js";
+import type { DiscoveryResult } from "./site-discovery.js";
+
+const result: DiscoveryResult = {
+  baseUrl: "https://shop.test",
+  pages: [{ route: "/", url: "https://shop.test/", title: "Shop", path: [], links: [], forms: [] }],
+  flows: [],
+  events: [],
+};
+
+test("the prompt names the persona and its instructions when one is given", () => {
+  const withPersona = explorationPrompt(result, { name: "Impatient power user", description: "Skip straight to checkout; ignore marketing pages." });
+  assert.match(withPersona, /Impatient power user: Skip straight to checkout; ignore marketing pages\./);
+
+  const withoutPersona = explorationPrompt(result);
+  assert.doesNotMatch(withoutPersona, /point of view/);
+});
+
+test("parseExploration only accepts well-formed journeys with at least two steps", () => {
+  const reply = JSON.stringify({
+    journeys: [
+      { name: "Sign up then buy", steps: [{ openLink: "/signup" }, { assertVisible: "Welcome" }] },
+      { name: "Too short", steps: [{ openLink: "/x" }] },
+    ],
+  });
+  const flows = parseExploration(reply, "https://shop.test", []);
+  assert.equal(flows.length, 1);
+  assert.equal(flows[0].name, "Sign up then buy");
+  assert.equal(flows[0].kind, "journey");
+});

package/src/runtime/ai-exploration.ts

@@ -0,0 +1,69 @@
+// AI exploration: after the crawler maps an app, a model writes the
+// multi-page journeys a person would actually take (sign up then buy, search
+// then filter). Every journey is parsed before it's saved.
+import YAML from "yaml";
+import { parseMaestroStyleFlow } from "./flow-language.js";
+import { extractJson } from "./platform-ai.js";
+import { slugify, type DiscoveredFlow, type DiscoveryResult } from "./site-discovery.js";
+
+const MAX_JOURNEYS = 8;
+const MAX_STEPS = 40;
+
+export type ExplorationPersona = { name: string; description: string };
+
+export function explorationPrompt(result: DiscoveryResult, persona?: ExplorationPersona): string {
+  const pages = result.pages.slice(0, 30).map((page) => ({
+    route: page.route,
+    title: page.title,
+    heading: page.heading,
+    reachedBy: page.path,
+    links: page.links.slice(0, 15).map((link) => link.label),
+    forms: page.forms.map((form) => ({ name: form.name, fields: form.fields.map((field) => `${field.label} (${field.type}${field.required ? ", required" : ""})`), submit: form.submit })),
+  }));
+  return [
+    "You are a QA engineer. Below is a map of a web app a crawler just explored.",
+    ...(persona ? [`Decide what's worth testing from this persona's point of view — ${persona.name}: ${persona.description}`] : []),
+    `Write up to ${MAX_JOURNEYS} end-to-end user journeys worth testing that span several pages (for example: sign up, then buy something).`,
+    "Only use pages, links, buttons and fields that appear in the map. Don't repeat single-page visits; those already exist.",
+    "Use obvious sample data (qa@example.com, Bugmole). Write passwords as \"{{secret.APP_PASSWORD}}\". Never submit destructive actions (delete, cancel, unsubscribe).",
+    "Steps: openLink: \"/path\"; tapOn: \"<visible text>\"; inputText: \"<text>\"; assertVisible: \"<text>\"; scrollUntilVisible: { element: \"<text>\" }.",
+    "Every journey starts with openLink and ends with an assertVisible that proves it worked.",
+    'Answer with JSON only: {"journeys": [{"name": "<short name>", "steps": [<step>, ...]}]}',
+    "",
+    `App: ${result.baseUrl}`,
+    JSON.stringify(pages),
+  ].join("\n");
+}
+
+export function parseExploration(reply: string, baseUrl: string, existing: readonly DiscoveredFlow[]): DiscoveredFlow[] {
+  const data = extractJson(reply) as { journeys?: unknown } | null;
+  if (!data || !Array.isArray(data.journeys)) return [];
+  const taken = new Set(existing.map((flow) => flow.id));
+  const flows: DiscoveredFlow[] = [];
+  for (const journey of (data.journeys as Array<Record<string, unknown>>).slice(0, MAX_JOURNEYS)) {
+    const name = typeof journey?.name === "string" ? journey.name.trim().slice(0, 80) : "";
+    const steps = Array.isArray(journey?.steps) ? journey.steps.slice(0, MAX_STEPS) : [];
+    if (!name || steps.length < 2) continue;
+    const content = `url: ${baseUrl}\nname: ${JSON.stringify(name)}\n---\n${YAML.stringify(steps)}`;
+    let parsed;
+    try {
+      parsed = parseMaestroStyleFlow(content, baseUrl);
+    } catch {
+      continue;
+    }
+    let id = `journey-${slugify(name)}`;
+    for (let suffix = 2; taken.has(id); suffix += 1) id = `journey-${slugify(name)}-${suffix}`;
+    taken.add(id);
+    const route = steps.find((step: unknown) => typeof (step as { openLink?: unknown })?.openLink === "string") as { openLink: string } | undefined;
+    flows.push({
+      id,
+      name,
+      kind: "journey",
+      route: route?.openLink.startsWith("/") ? route.openLink : "/",
+      file: `flows/discovered/${id}.yaml`,
+      content,
+      steps: parsed.steps.map((step) => step.type),
+    });
+  }
+  return flows;
+}

package/src/runtime/ai-repair.ts

@@ -0,0 +1,74 @@
+// AI test repair: when the rules can't propose a fix, ask a model for flow
+// edits. Its answer is only accepted as edits applyFlowChanges can check and
+// the flow parser accepts, so a wrong answer fails loudly instead of silently
+// rewriting the test.
+import YAML from "yaml";
+import { applyFlowChanges, rawFlowSteps, stepSignature, type FailureAnalysis, type FailureContext, type FlowChange } from "./failure-analysis.js";
+import { parseMaestroStyleFlow } from "./flow-language.js";
+import { extractJson } from "./platform-ai.js";
+
+const STEP_REFERENCE = `Steps (YAML objects): launchApp; openLink: "<url or /path>"; tapOn: "<visible text>"; inputText: "<text>";
+eraseText; pressKey: "Enter"; assertVisible: "<text>"; assertNotVisible: "<text>"; assertClickable: "<text>";
+scrollUntilVisible: { element: "<text>" }; wait: <ms>. Secrets are written as "{{secret.NAME}}".`;
+
+export function repairPrompt(flow: string, context: FailureContext, analysis?: FailureAnalysis): string {
+  const steps = rawFlowSteps(flow);
+  return [
+    "You repair end-to-end browser tests written as a list of steps. The app is probably fine; the test is out of date.",
+    "Propose the smallest edit to the step list that makes the failing step pass, using only what the page shows.",
+    "Never invent credentials or personal data. Use obvious sample values (qa@example.com) or existing {{secret.NAME}} references.",
+    STEP_REFERENCE,
+    'Answer with JSON only: {"summary": "<one sentence>", "changes": [ {"op": "replace", "index": <0-based>, "step": <step>} | {"op": "insert", "index": <0-based position>, "steps": [<step>, ...]} ]}',
+    'If the app itself is broken and the test is right, answer {"summary": "<why>", "changes": []}.',
+    "",
+    "Current steps (0-based index: step):",
+    ...steps.map((step, index) => `${index}: ${JSON.stringify(step)}`),
+    "",
+    `Failed step index: ${context.failedStepIndex}`,
+    `Error: ${context.error}`,
+    `Page: ${context.url ?? ""} ${context.title ?? ""}`,
+    `Visible messages: ${JSON.stringify(context.alerts)}`,
+    `Empty or invalid fields: ${JSON.stringify(context.invalidFields)}`,
+    `Controls and headings on the page: ${JSON.stringify(context.candidates.slice(0, 60))}`,
+    analysis ? `Earlier diagnosis: ${JSON.stringify({ category: analysis.category, title: analysis.title, rootCause: analysis.rootCause })}` : "",
+  ].join("\n");
+}
+
+function describeRaw(raw: unknown): string {
+  return YAML.stringify([raw]).trim().replace(/^- /, "");
+}
+
+/**
+ * Turns a model reply into a checked fix. Returns null when the reply isn't a
+ * usable edit (malformed, empty, or rejected by the flow checker).
+ */
+export function parseRepair(reply: string, flow: string): NonNullable<FailureAnalysis["suggestedFix"]> | null {
+  const data = extractJson(reply) as { summary?: unknown; changes?: unknown } | null;
+  if (!data || !Array.isArray(data.changes) || data.changes.length === 0 || data.changes.length > 10) return null;
+  const parsedSteps = parseMaestroStyleFlow(flow, "http://localhost").steps;
+  const raw = rawFlowSteps(flow);
+  const changes: FlowChange[] = [];
+  const preview: Array<{ kind: "add" | "remove"; text: string }> = [];
+  for (const item of data.changes as Array<Record<string, unknown>>) {
+    const index = Number(item?.index);
+    if (!Number.isInteger(index)) return null;
+    if (item.op === "replace" && item.step !== undefined) {
+      const current = parsedSteps[index];
+      if (!current) return null;
+      changes.push({ op: "replace", index, expect: stepSignature(current), step: item.step });
+      preview.push({ kind: "remove", text: describeRaw(raw[index]) }, { kind: "add", text: describeRaw(item.step) });
+    } else if (item.op === "insert" && Array.isArray(item.steps) && item.steps.length > 0 && item.steps.length <= 10) {
+      changes.push({ op: "insert", index, steps: item.steps });
+      preview.push(...item.steps.map((step) => ({ kind: "add" as const, text: describeRaw(step) })));
+    } else {
+      return null;
+    }
+  }
+  try {
+    applyFlowChanges(flow, changes);
+  } catch {
+    return null;
+  }
+  const summary = typeof data.summary === "string" && data.summary.trim() ? data.summary.trim().slice(0, 200) : "AI-proposed change to the failing steps.";
+  return { summary, changes, preview };
+}

package/src/runtime/ai-work.test.ts

@@ -0,0 +1,99 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { parseRepair, repairPrompt } from "./ai-repair.js";
+import { explorationPrompt, parseExploration } from "./ai-exploration.js";
+import { extractJson, modelCaller, platformModelCall } from "./platform-ai.js";
+import { anthropicMessagesUrl } from "./llm.js";
+import type { FailureContext } from "./failure-analysis.js";
+
+const flow = `url: https://shop.test\nname: Checkout\n---\n- launchApp\n- tapOn: "Buy now"\n- tapOn: "Continue to payment"\n- assertVisible: "Payment"\n`;
+const context: FailureContext = {
+  failedStepIndex: 3,
+  error: 'Timed out waiting for "Payment"',
+  pageErrors: [],
+  consoleErrors: [],
+  candidates: [{ role: "textbox", text: "Email" }, { role: "button", text: "Continue to payment" }],
+  alerts: ["Please enter a valid email"],
+  invalidFields: [{ label: "Email", type: "email", empty: true }],
+};
+
+test("the repair prompt shows the steps, the failure and the page", () => {
+  const prompt = repairPrompt(flow, context);
+  assert.match(prompt, /2: \{"tapOn":"Continue to payment"\}/);
+  assert.match(prompt, /Please enter a valid email/);
+  assert.match(prompt, /Failed step index: 3/);
+});
+
+test("an AI repair is accepted only as edits the flow checker accepts", () => {
+  const reply = "Here you go:\n```json\n" + JSON.stringify({
+    summary: "Fill in the email before continuing.",
+    changes: [{ op: "insert", index: 2, steps: [{ tapOn: "Email" }, { inputText: "qa@example.com" }] }],
+  }) + "\n```";
+  const fix = parseRepair(reply, flow);
+  assert.ok(fix);
+  assert.equal(fix.summary, "Fill in the email before continuing.");
+  assert.deepEqual(fix.changes, [{ op: "insert", index: 2, steps: [{ tapOn: "Email" }, { inputText: "qa@example.com" }] }]);
+  assert.deepEqual(fix.preview.map((line) => line.kind), ["add", "add"]);
+
+  const replace = parseRepair(JSON.stringify({ summary: "Renamed", changes: [{ op: "replace", index: 1, step: { tapOn: "Buy" } }] }), flow);
+  assert.equal(replace?.changes[0].op, "replace");
+  assert.equal(replace?.changes[0].op === "replace" && replace.changes[0].expect.length > 0, true);
+
+  assert.equal(parseRepair(JSON.stringify({ changes: [{ op: "insert", index: 99, steps: [{ tapOn: "x" }] }] }), flow), null);
+  assert.equal(parseRepair(JSON.stringify({ changes: [{ op: "insert", index: 1, steps: [{ explode: true }] }] }), flow), null);
+  assert.equal(parseRepair(JSON.stringify({ summary: "App bug", changes: [] }), flow), null);
+  assert.equal(parseRepair("not json", flow), null);
+});
+
+test("AI journeys are parsed, named uniquely and checked", () => {
+  const result = {
+    baseUrl: "https://shop.test/",
+    pages: [{ route: "/", url: "https://shop.test/", title: "Home", path: [], links: [{ label: "Shop", route: "/shop" }], forms: [] }],
+    flows: [{ id: "journey-buy-a-desk", name: "x", kind: "page" as const, route: "/", file: "", content: "", steps: [] }],
+    events: [],
+  };
+  assert.match(explorationPrompt(result), /"links":\["Shop"\]/);
+  const flows = parseExploration(JSON.stringify({
+    journeys: [
+      { name: "Buy a desk", steps: [{ openLink: "/shop" }, { tapOn: "Buy now" }, { assertVisible: "Payment" }] },
+      { name: "Broken", steps: [{ openLink: "/" }, { teleport: "x" }] },
+      { name: "Too short", steps: [{ openLink: "/" }] },
+    ],
+  }), result.baseUrl, result.flows);
+  assert.equal(flows.length, 1);
+  assert.equal(flows[0].id, "journey-buy-a-desk-2");
+  assert.equal(flows[0].kind, "journey");
+  assert.equal(flows[0].route, "/shop");
+  assert.match(flows[0].content, /^url: https:\/\/shop\.test\//);
+});
+
+test("platform AI goes through the registry with the worker's credential", async () => {
+  const requests: Array<{ url: string; auth: string | null; body: any }> = [];
+  const doFetch = (async (url: string, init: RequestInit) => {
+    requests.push({ url, auth: new Headers(init.headers).get("authorization"), body: JSON.parse(String(init.body)) });
+    return Response.json({ text: "ok", model: "claude-sonnet-5" });
+  }) as unknown as typeof fetch;
+  const env = { BUGMOLE_REGISTRY_URL: "https://registry.test/", BUGMOLE_API_KEY: "vk_1" };
+  const callModel = platformModelCall({ projectId: "shop", runId: "run_1", targetId: "chromium" }, env, doFetch);
+  assert.ok(callModel);
+  assert.deepEqual(await callModel("why?", "analysis"), { text: "ok", model: "claude-sonnet-5", source: "platform" });
+  assert.equal(requests[0].url, "https://registry.test/api/ai/complete");
+  assert.equal(requests[0].auth, "Bearer vk_1");
+  assert.deepEqual(requests[0].body, { purpose: "analysis", prompt: "why?", projectId: "shop", runId: "run_1", targetId: "chromium" });
+
+  assert.equal(platformModelCall({ projectId: "shop" }, { ...env, BUGMOLE_PLATFORM_AI: "off" }), null);
+  assert.equal(platformModelCall({ projectId: "shop" }, {}), null);
+  const own = modelCaller({ llm: { provider: "anthropic", api_key: "sk-own" } }, { projectId: "shop" }, env);
+  assert.ok(own, "a project's own key wins");
+  assert.equal(modelCaller({ llm: { provider: "manual", api_key: "not-set" } }, { projectId: "shop" }, {}), null);
+});
+
+test("helpers read model output and gateway URLs", () => {
+  assert.deepEqual(extractJson("sure: {\"a\": 1} thanks"), { a: 1 });
+  assert.deepEqual(extractJson("[1,2]"), [1, 2]);
+  assert.equal(extractJson("nothing"), null);
+  assert.equal(anthropicMessagesUrl(), "https://api.anthropic.com/v1/messages");
+  assert.equal(anthropicMessagesUrl("https://gw.test/v1"), "https://gw.test/v1/messages");
+  assert.equal(anthropicMessagesUrl("https://gw.test/"), "https://gw.test/v1/messages");
+  assert.equal(anthropicMessagesUrl("https://gw.test/v1/messages"), "https://gw.test/v1/messages");
+});

package/src/runtime/android-screen-record.test.ts

@@ -0,0 +1,75 @@
+import { strict as assert } from "node:assert";
+import test from "node:test";
+import {
+  clampChunkSeconds,
+  deviceChunkPath,
+  localChunkPath,
+  MAX_CHUNK_SECONDS,
+  mpdecimateArgs,
+  parseDeviceFileSize,
+  screenrecordArgs,
+  startAndroidScreenRecording,
+} from "./android-screen-record.js";
+
+test("returns undefined instead of throwing when adb is unavailable", async () => {
+  const recording = await startAndroidScreenRecording("emulator-5554", "definitely-not-a-real-adb-binary");
+  assert.equal(recording, undefined);
+});
+
+test("a chunk can never exceed what screenrecord accepts", () => {
+  // screenrecord refuses more than 180s, and asking for more used to mean the
+  // run was silently truncated to the first three minutes.
+  assert.equal(clampChunkSeconds(600), MAX_CHUNK_SECONDS);
+  assert.equal(clampChunkSeconds(undefined), MAX_CHUNK_SECONDS);
+  assert.equal(clampChunkSeconds(60), 60);
+});
+
+test("a nonsensical chunk length falls back rather than recording nothing", () => {
+  for (const bad of [0, -30, Number.NaN, Number.POSITIVE_INFINITY]) {
+    assert.equal(clampChunkSeconds(bad), MAX_CHUNK_SECONDS);
+  }
+});
+
+test("chunks sort in the order they were recorded", () => {
+  // Zero padded so a listing does not put chunk 10 before chunk 2.
+  const paths = [1, 2, 10].map((index) => localChunkPath("/runs/abc/run.mp4", index));
+  assert.deepEqual(paths, ["/runs/abc/run-001.mp4", "/runs/abc/run-002.mp4", "/runs/abc/run-010.mp4"]);
+  assert.deepEqual([...paths].sort(), paths);
+});
+
+test("the chunk suffix goes before the extension, not after it", () => {
+  assert.equal(localChunkPath("/runs/run.mp4", 3), "/runs/run-003.mp4");
+  // A base with no extension still gets a usable name.
+  assert.equal(localChunkPath("/runs/run", 3), "/runs/run-003");
+  // A dot in a directory name is not an extension.
+  assert.equal(localChunkPath("/runs/v1.2/run", 3), "/runs/v1.2/run-003");
+});
+
+test("each chunk is written to its own path on the device", () => {
+  assert.equal(deviceChunkPath(1), "/sdcard/bugmole-run-001.mp4");
+  assert.notEqual(deviceChunkPath(1), deviceChunkPath(2));
+});
+
+test("screenrecord is given a time limit, so a chunk always ends on its own", () => {
+  const args = screenrecordArgs("emulator-5554", "/sdcard/x.mp4", 90);
+  assert.deepEqual(args, ["-s", "emulator-5554", "shell", "screenrecord", "--time-limit=90", "/sdcard/x.mp4"]);
+});
+
+test("skipping idle also restamps, so the video actually gets shorter", () => {
+  // mpdecimate alone drops the frames but leaves their duration behind: the
+  // video stays the same length and merely stutters.
+  const args = mpdecimateArgs("in.mp4", "out.mp4");
+  const filter = args[args.indexOf("-vf") + 1];
+  assert.match(filter, /mpdecimate/);
+  assert.match(filter, /setpts/);
+});
+
+test("a settling file is read from stat, and noise is not mistaken for a size", () => {
+  // Pulling before screenrecord writes the mp4 trailer produces a file with no
+  // moov atom that no player will open, so stop() waits for this to settle.
+  assert.equal(parseDeviceFileSize("1842155\n"), 1842155);
+  assert.equal(parseDeviceFileSize("0"), 0);
+  for (const junk of ["", "stat: unknown file", "No such file or directory"]) {
+    assert.equal(parseDeviceFileSize(junk), null);
+  }
+});