@bugmole/cli 0.4.0 → 0.6.0

package/src/runtime/playwright-driver.ts

@@ -1,3 +1,4 @@
+import { UNSAFE_LINK } from "./site-discovery.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import type { Browser, BrowserContext, Locator, Page } from "playwright";
@@ -19,11 +20,13 @@ import {
   describeStepLabel,
   isPatternText,
   parseMaestroStyleFlow,
+  referencedSecretNames,
   resolveFlowUrl,
   type FlowStep,
   type ParsedFlow,
 } from "./flow-language.js";
 import { analyzeFailure, rawFlowSteps, type FailureContext } from "./failure-analysis.js";
+import { redactSecrets } from "./secret-redaction.js";
 import { createTempEmailInbox, deleteTempEmailInbox, extractFirstLink, waitForTempEmailMessage, type TempEmailInbox } from "../integrations/temp-email.js";
 
 export { parseMaestroStyleFlow } from "./flow-language.js";
@@ -87,17 +90,30 @@ const visibilityProbe = `(pattern, isRegex) => {
   return false;
 }`;
 
+/** The page moved on while a probe ran in it: try again on the new page. */
+export function isNavigationError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return /Execution context was destroyed|Cannot find context with specified id|frame was detached|navigat/i.test(message);
+}
+
 async function waitForVisibility(page: Page, text: string, shouldBeVisible: boolean, timeoutMs: number): Promise<void> {
   const isRegex = isPatternText(text);
   const deadline = Date.now() + timeoutMs;
   for (;;) {
     // Compiled inside the page: Playwright evaluates a bare string as an
     // expression and drops the argument, so the probe is passed as data.
-    const visible = await page.evaluate(
-      (args: [string, string, boolean]) =>
-        (new Function(`return (${args[0]})`)() as (pattern: string, isRegex: boolean) => boolean)(args[1], args[2]),
-      [visibilityProbe, text, isRegex] as [string, string, boolean],
-    );
+    // A page that navigates mid-check (a sign-in redirecting to the app)
+    // destroys the context the probe ran in: that's "not yet", not a failure.
+    const visible = await page
+      .evaluate(
+        (args: [string, string, boolean]) =>
+          (new Function(`return (${args[0]})`)() as (pattern: string, isRegex: boolean) => boolean)(args[1], args[2]),
+        [visibilityProbe, text, isRegex] as [string, string, boolean],
+      )
+      .catch((error: unknown) => {
+        if (isNavigationError(error)) return null;
+        throw error;
+      });
     if (visible === shouldBeVisible) return;
     if (Date.now() >= deadline) {
       throw new Error(`Timed out after ${timeoutMs}ms waiting for "${text}" to be ${shouldBeVisible ? "visible" : "hidden"}.`);
@@ -179,9 +195,12 @@ const failureProbe = `() => {
  * mascot, a floating action button, a toast) sitting on top of a link or
  * button and silently swallowing the tap.
  */
-async function waitForClickable(page: Page, locator: Locator, text: string, timeoutMs: number): Promise<void> {
+export async function waitForClickable(page: Page, locator: Locator, text: string, timeoutMs: number): Promise<void> {
   const deadline = Date.now() + timeoutMs;
   for (;;) {
+    // A person scrolls to a button below the fold; only covered or hidden
+    // controls should fail. On a phone's short screen this is most of them.
+    await locator.scrollIntoViewIfNeeded({ timeout: 1_000 }).catch(() => undefined);
     const handle = await locator.elementHandle({ timeout: 1_000 }).catch(() => null);
     const reachable = handle
       ? await page
@@ -200,10 +219,232 @@ async function waitForClickable(page: Page, locator: Locator, text: string, time
   }
 }
 
+/**
+ * What a person notices first when a page doesn't fit the screen: it scrolls
+ * sideways, text runs out of the card it sits in, or text is cut off with no
+ * ellipsis. Runs in the page; returns problems in plain words.
+ */
+export const layoutProbe = `() => {
+  const W = document.documentElement.clientWidth;
+  const problems = [];
+  const skip = (e) => e.closest("svg, pre, code, [aria-hidden=true], dialog:not([open])");
+  const shown = (e, s) => {
+    const r = e.getBoundingClientRect();
+    return r.width > 2 && r.height > 2 && s.display !== "none" && s.visibility !== "hidden" && Number(s.opacity) !== 0;
+  };
+  // What a developer searches for: the text, then the element and its first classes.
+  const label = (e) => {
+    const t = (e.innerText || "").replace(/\\s+/g, " ").trim();
+    const cls = typeof e.className === "string" ? e.className.trim().split(/\\s+/).filter(Boolean).slice(0, 2) : [];
+    const where = e.tagName.toLowerCase() + cls.map((c) => "." + c).join("");
+    return (t ? "\u201c" + (t.length > 48 ? t.slice(0, 47) + "\u2026" : t) + "\u201d " : "") + "(" + where + ")";
+  };
+  // Pinned to the screen (a chat button, a banner): it can't make the page wider.
+  const pinned = (e) => {
+    for (let a = e; a && a !== document.body; a = a.parentElement) {
+      const p = getComputedStyle(a).position;
+      if (p === "fixed" || p === "sticky") return true;
+    }
+    return false;
+  };
+  // Inside something that scrolls or clips on purpose (a carousel, a code block, a marquee).
+  const contained = (e) => {
+    for (let a = e.parentElement; a && a !== document.body && a !== document.documentElement; a = a.parentElement) {
+      const s = getComputedStyle(a);
+      if (/(hidden|auto|scroll|clip)/.test(s.overflowX + " " + s.overflowY)) return true;
+    }
+    return false;
+  };
+  const boxed = (s) =>
+    (s.backgroundColor !== "rgba(0, 0, 0, 0)" && s.backgroundColor !== "transparent") ||
+    s.backgroundImage !== "none" || s.boxShadow !== "none" ||
+    parseFloat(s.borderTopWidth) + parseFloat(s.borderBottomWidth) + parseFloat(s.borderLeftWidth) + parseFloat(s.borderRightWidth) > 0;
+
+  if (document.documentElement.scrollWidth > W + 1) {
+    let culprit = null;
+    for (const e of document.body.querySelectorAll("*")) {
+      const s = getComputedStyle(e);
+      if (e.closest("svg, [aria-hidden=true]") || !shown(e, s) || contained(e) || pinned(e)) continue;
+      const r = e.getBoundingClientRect();
+      if (r.right > W + 1 && (e.innerText || "").trim()) culprit = e; // the deepest one wins
+    }
+    problems.push("The page scrolls sideways: it is " + document.documentElement.scrollWidth + "px wide on a " + W + "px screen" + (culprit ? ", because of " + label(culprit) : ""));
+  }
+  for (const e of document.body.querySelectorAll("*")) {
+    const s = getComputedStyle(e);
+    if (s.display === "inline" || skip(e) || !shown(e, s)) continue;
+    if (!(e.innerText || "").trim()) continue;
+    if (boxed(s) && s.overflowY === "visible" && e.scrollHeight > e.clientHeight + 1 && e.clientHeight > 0) {
+      problems.push("Text runs out of its box: " + label(e) + " overflows by " + (e.scrollHeight - e.clientHeight) + "px");
+      continue;
+    }
+    if (boxed(s) && s.overflowX === "visible" && e.scrollWidth > e.clientWidth + 1 && e.clientWidth > 0) {
+      problems.push("Text runs out of its box sideways: " + label(e) + " overflows by " + (e.scrollWidth - e.clientWidth) + "px");
+      continue;
+    }
+    const clips = /(hidden|clip)/.test(s.overflowX + " " + s.overflowY);
+    const clamped = s.textOverflow === "ellipsis" || (s.webkitLineClamp && s.webkitLineClamp !== "none");
+    if (clips && !clamped && e.children.length === 0 && e.clientWidth > 2 && e.clientHeight > 2 &&
+        (e.scrollWidth > e.clientWidth + 2 || e.scrollHeight > e.clientHeight + 2)) {
+      problems.push("Text is cut off: " + label(e));
+    }
+  }
+  return [...new Set(problems)];
+}`;
+
+/**
+ * Enlarges (or restores) every element's text by `factor`, the way a phone's
+ * font-size setting does: text grows, the boxes the page gave it don't. All
+ * sizes are read before any is changed, so nested sizes don't compound.
+ */
+const textScaleProbe = `(factor) => {
+  const key = "__bugmoleTextScale";
+  const elements = Array.from(document.querySelectorAll("body, body *"));
+  if (factor === 1) {
+    for (const e of elements) {
+      const saved = e[key];
+      if (!saved) continue;
+      e.style.fontSize = saved.fontSize;
+      e.style.lineHeight = saved.lineHeight;
+      delete e[key];
+    }
+    return;
+  }
+  const sizes = elements.map((e) => {
+    const s = getComputedStyle(e);
+    return [parseFloat(s.fontSize), s.lineHeight.endsWith("px") ? parseFloat(s.lineHeight) : null];
+  });
+  elements.forEach((e, i) => {
+    e[key] = { fontSize: e.style.fontSize, lineHeight: e.style.lineHeight };
+    const [font, line] = sizes[i];
+    if (font) e.style.fontSize = font * factor + "px";
+    if (line) e.style.lineHeight = line * factor + "px";
+  });
+}`;
+
+async function layoutProblems(page: Page): Promise<string[]> {
+  return page.evaluate((source: string) => (new Function(`return (${source})`)() as () => string[])(), layoutProbe);
+}
+
+async function scaleText(page: Page, factor: number): Promise<void> {
+  await page.evaluate(([source, value]: [string, number]) => (new Function(`return (${source})`)() as (f: number) => void)(value), [textScaleProbe, factor] as [string, number]);
+}
+
+/** Larger text, as set on many phones (Android's font size; WCAG asks pages to cope with up to 200%). */
+export const LARGE_TEXT = 1.3;
+
+/** Layout problems at normal text size, then those that appear only with larger text. */
+export async function checkLayout(page: Page, largeText = LARGE_TEXT): Promise<string[]> {
+  const normal = await layoutProblems(page);
+  if (!largeText || largeText === 1) return normal;
+  await scaleText(page, largeText);
+  try {
+    const large = await layoutProblems(page);
+    const label = `with text ${Math.round(largeText * 100)}% (a phone's larger font setting)`;
+    // The same box overflowing by more pixels isn't a new problem.
+    const same = (problem: string) => problem.replace(/\d+px/g, "");
+    const seen = new Set(normal.map(same));
+    return [...normal, ...large.filter((problem) => !seen.has(same(problem))).map((problem) => `${problem}, ${label}`)];
+  } finally {
+    await scaleText(page, 1);
+  }
+}
+
+/** A link a check must not follow: signing out, deleting, unsubscribing (by its text or address). */
+export function isUnsafeLink(href: string, text: string): boolean {
+  let path = href;
+  try {
+    const url = new URL(href);
+    path = `${url.pathname} ${url.search}`;
+  } catch {
+    // keep the raw href
+  }
+  return UNSAFE_LINK.test(text) || UNSAFE_LINK.test(path.replace(/[/_?=&.-]+/g, " "));
+}
+
+/** Answers that mean a link is broken, not that the site turned a robot away. */
+export function brokenStatus(status: number, sameSite: boolean): boolean {
+  if (sameSite) return status >= 400;
+  // 502-504 from someone else's site is their gateway having a bad moment
+  // (GitHub answers 504 to bots now and then), not a link the page got wrong.
+  if (status >= 502 && status <= 504) return false;
+  return status === 404 || status === 410 || status >= 500;
+}
+
+/**
+ * Makes the focused field's text invisible on screen (screenshots, video)
+ * without changing its value. Password fields are already masked.
+ */
+export async function hideFocusedFieldText(page: Page): Promise<void> {
+  await page.evaluate(`(() => {
+    const field = document.activeElement;
+    if (!field || field === document.body) return;
+    field.setAttribute("data-bugmole-secret", "");
+    if (!document.getElementById("bugmole-secret-style")) {
+      const style = document.createElement("style");
+      style.id = "bugmole-secret-style";
+      style.textContent = "[data-bugmole-secret]{color:transparent!important;-webkit-text-fill-color:transparent!important;text-shadow:none!important;caret-color:currentColor}";
+      (document.head || document.documentElement).appendChild(style);
+    }
+  })()`).catch(() => undefined);
+}
+
+/** Requests every link on the page (same-site only unless `external`). Returns the broken ones. */
+export async function checkLinks(page: Page, external: boolean, limit = 80): Promise<string[]> {
+  const origin = new URL(page.url()).origin;
+  const links = (await page.evaluate(
+    `Array.from(document.querySelectorAll("a[href]")).map((a) => [a.href, (a.innerText || a.getAttribute("aria-label") || "").trim()])`,
+  )) as Array<[string, string]>;
+  // Requesting a link is visiting it: never sign out, delete or unsubscribe
+  // on the way (the same links discovery steers clear of).
+  const safe = links.filter(([href, text]) => !isUnsafeLink(href, text)).map(([href]) => href);
+  const targets = [...new Set(safe.filter((h) => /^https?:/i.test(h)).map((h) => h.split("#")[0]!))]
+    .filter((h) => external || new URL(h).origin === origin)
+    .slice(0, limit);
+  const request = page.context().request;
+  const broken: string[] = [];
+  const queue = [...targets];
+  const worker = async () => {
+    for (let url = queue.shift(); url; url = queue.shift()) {
+      const sameSite = new URL(url).origin === origin;
+      try {
+        let response = await request.head(url, { timeout: 10_000, maxRedirects: 5, failOnStatusCode: false });
+        // Plenty of servers answer HEAD badly; a GET is what a visitor sends.
+        if (response.status() >= 400) response = await request.get(url, { timeout: 10_000, maxRedirects: 5, failOnStatusCode: false });
+        // A server error can be a blip: ask once more before calling it broken.
+        if (response.status() >= 500) {
+          await new Promise((resolve) => setTimeout(resolve, 1_500));
+          response = await request.get(url, { timeout: 10_000, maxRedirects: 5, failOnStatusCode: false });
+        }
+        if (brokenStatus(response.status(), sameSite)) broken.push(`${url} (${response.status()})`);
+      } catch (error) {
+        if (sameSite) broken.push(`${url} (no answer: ${error instanceof Error ? error.message.split("\n")[0] : String(error)})`);
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(6, targets.length) }, worker));
+  return broken.sort();
+}
+
 /**
  * Candidate locators in the order a person resolves a target: the control they
  * can name, then the field labelled that way, then anything reading that way.
  */
+/**
+ * A screenshot of the whole page, or of the screen when the page is taller
+ * than the browser can capture in one image (32,767px in WebKit): evidence
+ * must never turn a passing flow into a failure.
+ */
+export async function screenshotWholePage(page: Page, file: string, log?: string[]): Promise<void> {
+  try {
+    await page.screenshot({ path: file, fullPage: true });
+  } catch (error) {
+    if (!/larger than \d+ pixels|too large|maximum/i.test(error instanceof Error ? error.message : String(error))) throw error;
+    log?.push("The page is too tall for one screenshot; captured the screen instead.");
+    await page.screenshot({ path: file, fullPage: false });
+  }
+}
+
 /** Playwright needs its own ffmpeg build to write a video; nothing else does. */
 export function isMissingVideoEncoder(error: unknown): boolean {
   const message = error instanceof Error ? error.message : String(error);
@@ -289,6 +530,8 @@ export class PlaywrightDriver implements AppDriver {
     const videoDir = path.join(artifactsDir, "video");
     await fs.mkdir(videoDir, { recursive: true });
     const log: string[] = [];
+    const typesSecret = referencedSecretNames(flowContent).length > 0;
+    if (typesSecret) log.push("This flow types a secret, so no Playwright trace is recorded.");
     const steps: DriverStepResult[] = [];
     const pageErrors: string[] = [];
     const consoleErrors: string[] = [];
@@ -306,7 +549,7 @@ export class PlaywrightDriver implements AppDriver {
 
     const writeLog = async () => {
       const logPath = path.join(artifactsDir, "playwright.log");
-      await fs.writeFile(logPath, log.join("\n"), "utf8").catch(() => undefined);
+      await fs.writeFile(logPath, redactSecrets(log.join("\n")), "utf8").catch(() => undefined);
       return logPath;
     };
     const stopTrace = async (): Promise<string | undefined> => {
@@ -336,6 +579,7 @@ export class PlaywrightDriver implements AppDriver {
         };
       }
       const storageState = context.sessionStatePath && (await fileExists(context.sessionStatePath)) ? context.sessionStatePath : undefined;
+      if (storageState && !typesSecret) log.push("This flow starts signed in, so no Playwright trace is recorded (it would hold the session cookies).");
       // Record at the page's real size; Playwright's default shrinks to 800px.
       const videoSize = flow.viewport ?? emulation.options.viewport ?? { width: 1280, height: 720 };
       const contextOptions = {
@@ -348,7 +592,11 @@ export class PlaywrightDriver implements AppDriver {
           withVideo ? { ...contextOptions, recordVideo: { dir: videoDir, size: videoSize } } : contextOptions,
         );
         // The trace is the step-by-step record a person opens to debug a run.
-        await opened.tracing.start({ screenshots: true, snapshots: true }).catch(() => undefined);
+        // It records every typed character and field value, so a flow that
+        // types a secret gets no trace: redaction can't reach inside it.
+        // A flow that starts signed in has the session cookies in every
+        // request it records, so it gets no trace either.
+        if (!typesSecret && !storageState) await opened.tracing.start({ screenshots: true, snapshots: true }).catch(() => undefined);
         return opened;
       };
       browserContext = await openContext(true);
@@ -378,13 +626,13 @@ export class PlaywrightDriver implements AppDriver {
 
       const capture = async (name: string) => {
         const screenshotPath = path.join(artifactsDir, `${name.replace(/[^a-z0-9_-]+/gi, "-")}.png`);
-        await page.screenshot({ path: screenshotPath, fullPage: true });
+        await screenshotWholePage(page, screenshotPath, log);
         screenshots.push({ path: screenshotPath, name: path.basename(screenshotPath) });
         return screenshotPath;
       };
 
       const runStep = async (rawStep: FlowStep): Promise<void> => {
-        const step = interpolateStep(rawStep, flowContext);
+        const step = interpolateStep(rawStep, flowContext, { env: { ...process.env, ...context.environment } });
         switch (step.type) {
           case "launchApp":
             await page.goto(flow.url, { waitUntil: "load" });
@@ -409,6 +657,9 @@ export class PlaywrightDriver implements AppDriver {
             return;
           }
           case "inputText":
+            // A secret typed into a plain text field would show in every
+            // screenshot and the video. Hide that field's text before typing.
+            if (rawStep.type === "inputText" && referencedSecretNames(rawStep.text).length) await hideFocusedFieldText(page);
             await page.keyboard.type(step.text);
             return;
           case "eraseText":
@@ -431,6 +682,22 @@ export class PlaywrightDriver implements AppDriver {
             await waitForClickable(page, target, step.text, step.timeoutMs ?? stepTimeoutMs);
             return;
           }
+          case "assertLayout": {
+            const problems = await checkLayout(page);
+            if (problems.length) {
+              await capture(`layout-${String(Date.now()).slice(-6)}`).catch(() => undefined);
+              const shown = problems.slice(0, 6).map((problem) => `- ${problem}`).join("\n");
+              throw new Error(`The page doesn't fit a ${page.viewportSize()?.width ?? "?"}px-wide screen:\n${shown}${problems.length > 6 ? `\n…and ${problems.length - 6} more` : ""}`);
+            }
+            return;
+          }
+          case "assertLinks": {
+            const broken = await checkLinks(page, step.external);
+            if (broken.length) {
+              throw new Error(`${broken.length} broken link(s) on ${page.url()}:\n${broken.slice(0, 10).map((link) => `- ${link}`).join("\n")}`);
+            }
+            return;
+          }
           case "scrollUntilVisible": {
             const target = await resolveTapTarget(page, step.text, 0);
             if (!target) throw new Error(`No element matching "${step.text}" to scroll to.`);
@@ -497,7 +764,11 @@ export class PlaywrightDriver implements AppDriver {
       }
 
       const finalScreenshot = await capture("playwright-final");
-      if (context.sessionStatePath) await browserContext.storageState({ path: context.sessionStatePath });
+      if (context.sessionStatePath) {
+        // The session file holds the app's cookies: readable by this user only.
+        await browserContext.storageState({ path: context.sessionStatePath });
+        await fs.chmod(context.sessionStatePath, 0o600).catch(() => undefined);
+      }
       const tracePath = await stopTrace();
       const logPath = await writeLog();
       const videoPath = await page.video()?.path();
@@ -531,7 +802,7 @@ export class PlaywrightDriver implements AppDriver {
         steps,
       };
     } catch (error) {
-      const message = error instanceof Error ? error.message : "Playwright flow failed.";
+      const message = redactSecrets(error instanceof Error ? error.message : "Playwright flow failed.");
       log.push(`ERROR: ${message}`);
       // The step whose action threw failed; steps after it never ran and must
       // not be reported as either passed or failed.
@@ -568,12 +839,12 @@ export class PlaywrightDriver implements AppDriver {
             invalidFields: snapshot?.invalidFields ?? [],
           };
           const contextPath = path.join(artifactsDir, "failure-context.json");
-          await fs.writeFile(contextPath, `${JSON.stringify(failureContext, null, 2)}\n`, "utf8");
+          await fs.writeFile(contextPath, `${redactSecrets(JSON.stringify(failureContext, null, 2))}\n`, "utf8");
           artifacts.push({ path: contextPath, contentType: "application/json", name: "failure-context.json" });
           try {
             const analysis = analyzeFailure(flow.steps, rawFlowSteps(flowContent), failureContext);
             const analysisPath = path.join(artifactsDir, "analysis.json");
-            await fs.writeFile(analysisPath, `${JSON.stringify(analysis, null, 2)}\n`, "utf8");
+            await fs.writeFile(analysisPath, `${redactSecrets(JSON.stringify(analysis, null, 2))}\n`, "utf8");
             artifacts.push({ path: analysisPath, contentType: "application/json", name: "analysis.json" });
             log.push(`ANALYSIS: ${analysis.title}`);
           } catch (analysisError) {
@@ -582,7 +853,7 @@ export class PlaywrightDriver implements AppDriver {
         }
         if (failurePage) {
           const failurePath = path.join(artifactsDir, "playwright-failure.png");
-          await failurePage.screenshot({ path: failurePath, fullPage: true });
+          await screenshotWholePage(failurePage, failurePath);
           artifacts.push({ path: failurePath, contentType: "image/png", name: "playwright-failure.png" });
         }
       } catch {

package/src/runtime/project-identity.test.ts

@@ -0,0 +1,161 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { RegistryRequestError, projectInactiveMessage } from "../registry/control-plane-client.js";
+import { runInitWizard } from "./init-wizard.js";
+import { SCOPE_MESSAGE, describeDetection, detectProjectIdentity, discoverApps } from "./project-identity.js";
+import { announceProjectIdentity, isClaimConflict } from "./serve-worker.js";
+
+async function monorepo(remote = "https://ada:ghp_secret@github.com/Acme/Shop.git") {
+  const root = await mkdtemp(path.join(os.tmpdir(), "bugmole-identity-"));
+  execFileSync("git", ["init", "-q"], { cwd: root });
+  execFileSync("git", ["remote", "add", "origin", remote], { cwd: root });
+  await writeFile(path.join(root, "package.json"), JSON.stringify({ name: "shop", private: true, workspaces: ["apps/*", "packages/*"], devDependencies: { react: "19" } }));
+  await mkdir(path.join(root, "apps/web/src/app"), { recursive: true });
+  await writeFile(path.join(root, "apps/web/package.json"), JSON.stringify({ dependencies: { next: "16", react: "19" } }));
+  await mkdir(path.join(root, "apps/mobile"), { recursive: true });
+  await writeFile(path.join(root, "apps/mobile/package.json"), JSON.stringify({ dependencies: { expo: "54", "react-native": "0.81" } }));
+  await mkdir(path.join(root, "packages/ui"), { recursive: true });
+  await writeFile(path.join(root, "packages/ui/package.json"), JSON.stringify({ name: "ui", peerDependencies: { react: "19" } }));
+  await mkdir(path.join(root, "apps/web/node_modules/next"), { recursive: true });
+  await writeFile(path.join(root, "apps/web/node_modules/next/package.json"), JSON.stringify({ dependencies: { react: "19" } }));
+  return root;
+}
+
+function captureConsole() {
+  const lines: string[] = [];
+  const original = { log: console.log, warn: console.warn };
+  console.log = (...args: unknown[]) => lines.push(args.join(" "));
+  console.warn = (...args: unknown[]) => lines.push(args.join(" "));
+  return { lines, restore: () => Object.assign(console, original) };
+}
+
+test("a monorepo's apps are found separately, and a workspace root isn't one of them", async () => {
+  const root = await monorepo();
+  try {
+    assert.deepEqual(discoverApps(root), [
+      { path: "apps/mobile", kind: "mobile", framework: "Expo" },
+      { path: "apps/web", kind: "web", framework: "Next.js" },
+    ]);
+    const atRoot = detectProjectIdentity({ cwd: root });
+    assert.equal(atRoot.reason, "ambiguous", "never collapses two apps into one project");
+    assert.equal(atRoot.identity, null);
+    assert.match(describeDetection(atRoot).join("\n"), /has 2 apps: apps\/mobile \(Expo\), apps\/web \(Next\.js\)[\s\S]*--app-path/);
+
+    const inWeb = detectProjectIdentity({ cwd: path.join(root, "apps/web/src/app") });
+    assert.deepEqual(inWeb.identity, { kind: "repo", remote: "github.com/acme/shop", appPath: "apps/web" });
+    assert.equal(inWeb.preview?.key, "repo:github.com/acme/shop#apps/web");
+    assert.doesNotMatch(JSON.stringify(inWeb.identity), /ghp_secret|ada/, "the remote's credentials never leave the machine");
+
+    const chosen = detectProjectIdentity({ cwd: root, appPath: "apps/mobile", appUrl: "http://localhost:8081" });
+    assert.deepEqual(chosen.identity, { kind: "repo", remote: "github.com/acme/shop", appPath: "apps/mobile", appUrl: "http://localhost:8081" });
+    assert.equal(chosen.app?.kind, "mobile");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("without a remote, a public URL identifies the app by domain; data projects are out of scope", async () => {
+  const app = await mkdtemp(path.join(os.tmpdir(), "bugmole-identity-solo-"));
+  const data = await mkdtemp(path.join(os.tmpdir(), "bugmole-identity-data-"));
+  try {
+    execFileSync("git", ["init", "-q"], { cwd: app });
+    await writeFile(path.join(app, "package.json"), JSON.stringify({ dependencies: { vue: "3" } }));
+    assert.equal(detectProjectIdentity({ cwd: app }).reason, "unidentified");
+    assert.deepEqual(detectProjectIdentity({ cwd: app, appUrl: "https://www.shop.example.com/cart" }).preview?.key, "domain:shop.example.com");
+
+    await writeFile(path.join(data, "train.ipynb"), "{}");
+    await writeFile(path.join(data, "requirements.txt"), "pandas\ntorch\n");
+    const detection = detectProjectIdentity({ cwd: data });
+    assert.equal(detection.reason, "no_app");
+    assert.ok(describeDetection(detection).includes(SCOPE_MESSAGE));
+    assert.match(SCOPE_MESSAGE, /web apps and mobile apps \(Android and iOS\).*out of scope/);
+  } finally {
+    await rm(app, { recursive: true, force: true });
+    await rm(data, { recursive: true, force: true });
+  }
+});
+
+test("bugmole init says when there's no web or mobile app to test", async () => {
+  const cwd = await mkdtemp(path.join(os.tmpdir(), "bugmole-init-scope-"));
+  const output = captureConsole();
+  try {
+    await runInitWizard({ cwd, nonInteractive: true });
+  } finally {
+    output.restore();
+    await rm(cwd, { recursive: true, force: true });
+  }
+  assert.ok(output.lines.includes(SCOPE_MESSAGE), output.lines.join("\n"));
+});
+
+test("bugmole init sends the app's identity and joins the project that already exists for it", async () => {
+  const root = await monorepo();
+  const cwd = path.join(root, "apps/web");
+  const saved = { key: process.env.BUGMOLE_API_KEY, registry: process.env.BUGMOLE_REGISTRY_URL };
+  const realFetch = globalThis.fetch;
+  const sent: Array<Record<string, any>> = [];
+  process.env.BUGMOLE_API_KEY = "bm_live_test";
+  process.env.BUGMOLE_REGISTRY_URL = "https://registry.test";
+  globalThis.fetch = (async (_url: string, init: RequestInit) => {
+    sent.push(JSON.parse(String(init.body)));
+    return Response.json({ project: { id: "shop-web" }, existing: true }, { status: 200 });
+  }) as typeof fetch;
+  const output = captureConsole();
+  try {
+    const result = await runInitWizard({ cwd, nonInteractive: true, projectId: "my-copy" });
+    assert.equal(result.config.projectId, "shop-web");
+    assert.equal(result.config.appPath, "apps/web");
+    const config = await readFile(path.join(cwd, result.configPath), "utf8");
+    assert.match(config, /^project:\n  id: shop-web$/m);
+    assert.match(config, /app_path: "apps\/web"/);
+    assert.match(await readFile(path.join(cwd, result.envPath), "utf8"), /^BUGMOLE_PROJECT_ID=shop-web$/m);
+  } finally {
+    output.restore();
+    globalThis.fetch = realFetch;
+    for (const [name, value] of [["BUGMOLE_API_KEY", saved.key], ["BUGMOLE_REGISTRY_URL", saved.registry]] as const) {
+      if (value === undefined) delete process.env[name];
+      else process.env[name] = value;
+    }
+    await rm(root, { recursive: true, force: true });
+  }
+  assert.deepEqual(sent[0].identity, { kind: "repo", remote: "github.com/acme/shop", appPath: "apps/web" });
+  assert.match(output.lines.join("\n"), /Found a web app \(Next\.js\) at apps\/web/);
+  assert.match(output.lines.join("\n"), /already project shop-web in the workspace; joined it/);
+});
+
+test("a paused project is its own refusal: serve prints the activation link instead of treating it as a lost claim", async () => {
+  const paused = new RegistryRequestError(409, "project_inactive", "This project is paused", { activateUrl: "https://dash.test/?project=shop" });
+  assert.equal(isClaimConflict(paused), false);
+  assert.equal(isClaimConflict(new RegistryRequestError(409)), true);
+  assert.match(paused.message, /This project is paused \(409 project_inactive\)/);
+  assert.equal(
+    projectInactiveMessage("shop", "https://dash.test/?project=shop"),
+    "Project shop is paused because nobody used it for a while, so it won't run tests or tasks. A project member can activate it: https://dash.test/?project=shop.",
+  );
+
+  const root = await monorepo();
+  const logged: string[] = [];
+  const log = { log: (line: string) => logged.push(line), warn: (line: string) => logged.push(line) };
+  const reported: unknown[] = [];
+  try {
+    await announceProjectIdentity({
+      reportIdentity: async (identity) => {
+        reported.push(identity);
+        return { identity: null, inactiveAt: "2026-09-01T00:00:00Z", activateUrl: "https://dash.test/?project=shop" };
+      },
+    }, "shop", { cwd: root, appPath: "apps/web" }, log);
+    await announceProjectIdentity({
+      reportIdentity: async () => {
+        throw new RegistryRequestError(409, "identity_mismatch", "This project is github.com/acme/shop (apps/web), not github.com/acme/shop (apps/mobile).");
+      },
+    }, "shop", { cwd: root, appPath: "apps/mobile" }, log);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+  assert.deepEqual(reported, [{ kind: "repo", remote: "github.com/acme/shop", appPath: "apps/web" }]);
+  assert.match(logged[0], /Project shop is paused .* activate it: https:\/\/dash\.test\/\?project=shop/);
+  assert.match(logged[1], /not github\.com\/acme\/shop \(apps\/mobile\)/);
+});