@tandryukha/aidemo 0.15.1 → 0.16.0

package/src/cursor.ts

@@ -1,4 +1,4 @@
-import { chromium } from "playwright";
+import { launchChrome } from "./browser.js";
 
 /**
  * The classic arrow pointer, shared by both cursor render paths so they look
@@ -30,7 +30,7 @@ export async function renderCursorPng(
   // Logical canvas is 32 units (24 arrow + shadow headroom); scale to sizePx.
   const LOGICAL = 32;
   const dsf = Math.max(1, sizePx / LOGICAL);
-  const browser = await chromium.launch({ channel: "chrome", headless: true });
+  const browser = await launchChrome({ headless: true });
   const context = await browser.newContext({
     viewport: { width: LOGICAL, height: LOGICAL },
     deviceScaleFactor: dsf,

package/src/distribute.ts

@@ -17,7 +17,15 @@ import { resolve, dirname, basename } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { platform, release } from "node:os";
-import { ENGINE_ROOT, engineVersion, openAiBaseUrl, ttsProvider } from "./config.js";
+import {
+  ENGINE_ROOT,
+  engineVersion,
+  openAiBaseUrl,
+  ttsProvider,
+  chromeLaunchOptions,
+  type ChromeLaunchTarget,
+} from "./config.js";
+import { describeChromeTarget, probeConfiguredBrowser } from "./browser.js";
 import { localTtsStatus } from "./voice-local.js";
 import { Project } from "./project.js";
 import { STARTER_BRIEF, STARTER_STORYBOARD, briefFromInspect, storyboardFromInspect } from "./starter.js";
@@ -266,6 +274,9 @@ export async function scaffoldDemo(
       screenshotPath: project.p("logs", "inspect-init.png"),
     });
     await fs.writeFile(project.p("logs", "inspect-init.json"), JSON.stringify(res, null, 2));
+    if (res.target.status === "blocked") {
+      throw new Error(`Cannot draft from ${opts.fromUrl}: ${res.target.reason}. See logs/inspect-init.json and inspect-init.png.`);
+    }
     await fs.writeFile(project.p("input", "brief.md"), briefFromInspect(name, res));
     await fs.writeFile(project.storyboardPath, storyboardFromInspect(name, res));
     ok(
@@ -368,6 +379,43 @@ async function probeChrome(): Promise<string | null> {
   return null;
 }
 
+/** Resolve + probe the browser every launch uses (see chromeLaunchOptions). */
+async function probeBrowserTarget(chrome: string | null): Promise<DoctorReport["browser"]> {
+  let target: ChromeLaunchTarget;
+  try {
+    target = chromeLaunchOptions();
+  } catch (err) {
+    return {
+      source: "channel",
+      channel: process.env.AIDEMO_CHROME_CHANNEL,
+      description: `channel ${process.env.AIDEMO_CHROME_CHANNEL} (AIDEMO_CHROME_CHANNEL)`,
+      found: false,
+      error: (err as Error).message,
+    };
+  }
+  const description = describeChromeTarget(target);
+  const isDefault = "channel" in target && !process.env.AIDEMO_CHROME_CHANNEL?.trim();
+  if (isDefault) {
+    // Unchanged default: system Chrome, detected without launching it.
+    return {
+      source: "default",
+      channel: "chrome",
+      description,
+      found: Boolean(chrome),
+      ...(chrome ? { version: chrome } : { error: "Google Chrome not found" }),
+    };
+  }
+  const probe = await probeConfiguredBrowser();
+  return {
+    ...("executablePath" in target
+      ? { source: "executable" as const, executablePath: target.executablePath }
+      : { source: "channel" as const, channel: target.channel }),
+    description,
+    found: "version" in probe,
+    ...("version" in probe ? { version: probe.version } : { error: probe.error }),
+  };
+}
+
 /** Tail the most recent logs/*.log under a demo dir (best-effort). */
 async function recentLogTail(demoDir: string, lines = 40): Promise<string | null> {
   const logsDir = resolve(demoDir, "logs");
@@ -576,7 +624,24 @@ export interface DoctorReport {
   engineVersion: string;
   node: string;
   ffmpeg: string | null;
+  /** System Google Chrome (version or path) — what the default channel launches. */
   chrome: string | null;
+  /**
+   * The browser every launch will actually use (issue #80):
+   * AIDEMO_CHROME_EXECUTABLE > AIDEMO_CHROME_CHANNEL > default channel chrome.
+   */
+  browser: {
+    source: "default" | "channel" | "executable";
+    channel?: string;
+    executablePath?: string;
+    /** e.g. "channel chromium (AIDEMO_CHROME_CHANNEL)". */
+    description: string;
+    found: boolean;
+    /** Version / path when found. */
+    version?: string;
+    /** Actionable reason when not found (or the env var is invalid). */
+    error?: string;
+  };
   gh: string | null;
   endpoint: { url: string; custom: boolean; warning?: string };
   apiKey: "set" | "not-required" | "missing";
@@ -627,11 +692,14 @@ export async function doctorReport(dir: string | undefined): Promise<DoctorRepor
   const manifest = await readManifest(target);
   const latest = engineVersion();
   const localTts = ttsProvider() === "local" ? await localTtsStatus() : null;
+  const chrome = await probeChrome();
+  const browser = await probeBrowserTarget(chrome);
   const report: DoctorReport = {
     engineVersion: latest,
     node: process.version,
     ffmpeg: await probeCmd("ffmpeg", ["-version"]),
-    chrome: await probeChrome(),
+    chrome,
+    browser,
     gh: await probeCmd("gh", ["--version"]),
     endpoint: {
       url: base ?? "https://api.openai.com/v1",
@@ -671,7 +739,7 @@ export async function doctorReport(dir: string | undefined): Promise<DoctorRepor
   };
   report.ok = Boolean(
     report.ffmpeg &&
-      report.chrome &&
+      report.browser.found &&
       report.playwright &&
       // Local TTS needs no key: voice is in-process, captions auto-fall-back
       // to the offline derivation in `render`.
@@ -692,7 +760,14 @@ export async function doctor(dir: string | undefined): Promise<void> {
 
   line("node", r.node);
   line("ffmpeg", r.ffmpeg);
-  line("chrome", r.chrome);
+  if (r.browser.source === "default") {
+    line("chrome", r.chrome);
+    ok(`browser: ${r.browser.description}`);
+  } else {
+    if (r.browser.found) ok(`browser: ${r.browser.description} — ${r.browser.version}`);
+    else fail(`browser: ${r.browser.description} — ${r.browser.error ?? "NOT FOUND"}`);
+    log(`system chrome (unused): ${r.chrome ?? "not found"}`);
+  }
   line("gh (feedback)", r.gh);
   ok(
     `voice/captions endpoint: ${r.endpoint.custom ? `${r.endpoint.url} (custom)` : "api.openai.com (default)"}`

package/src/ffmpeg.ts

@@ -83,43 +83,56 @@ export function probeDurationMs(file: string): Promise<number> {
 }
 
 /**
- * Length (ms) of the *flat* tail of a video — the trailing run of frames that
- * are a single solid color.
+ * Thresholds for "this frame shows nothing" — a blank pre-paint, a solid
+ * splash — as opposed to a page whose content is merely sparse (issue #78: a
+ * dark terminal with one prompt line). A frame is blank only when BOTH hold:
  *
- * Compose freeze-holds a scene's last frame when the narration outruns the
- * recorded action. When the scene ends right before a `goto`, that last frame
- * is the browser's white pre-paint, and the hold clones *white* for as long as
- * the narration runs (issue #36: 37 near-blank seconds out of 209). Trimming
- * the flat tail first makes the hold clone the last frame that actually shows
- * the app.
+ * 1. `FLAT_SPREAD` — `YHIGH - YLOW` from `signalstats` (luma 90th minus 10th
+ *    percentile) is at most 4: one colour covers ≥ 80% of the frame.
+ *    Percentiles, not min/max, so a cursor arrow or a stray antialiased pixel
+ *    doesn't read as content; `YDEV` would be the natural measure but many
+ *    ffmpeg builds don't emit it. On its own this is NOT a blank test: sparse
+ *    text never reaches the 10%/90% tails, so a terminal prompt (or a login
+ *    box on a big solid background) measured exactly like a white page.
+ * 2. `BLANK_EDGE_PX` — `edgedetect` (Canny, binary 0/255 output) +
+ *    `signalstats` YAVG gives the fraction of edge pixels; times the frame
+ *    area and divided by the device-pixel scale, that is the length of
+ *    visible outlines in CSS px. Glyphs are all outline, so this counts text
+ *    the percentiles miss. Measured (Chrome screenshots → x264 crf 20, at
+ *    1280x720@1x, 1920x1080@1x, 1280x720@2x): the engine's 24 px cursor over
+ *    white/grey/black ≈ 54–142; a blank page 0; `user@box:~$ ▌` 14 px on
+ *    black ≈ 288–522; `root@ttyd:~# ▌` 16 px ≈ 447–630; a heading + one
+ *    sentence ≈ 1210–1560. 200 sits between the cursor and a one-line prompt
+ *    with ~1.4x margin each side. Below it — a lone `$ ▌` (≈ 75–150), a bare
+ *    32 px spinner (≈ 115–135) — still counts as blank, which for an opening
+ *    frame is what a viewer sees too.
  *
- * Flatness is `YHIGH - YLOW` from `signalstats` — the spread between the luma
- * 90th and 10th percentiles. Percentiles rather than min/max so a cursor arrow
- * or a stray antialiased pixel doesn't make a blank page look like content;
- * `YDEV` would be the natural measure but many ffmpeg builds don't emit it.
- *
- * Scans at most `windowMs` from the end; returns 0 when the tail has real
- * content, or when the probe fails for any reason (best-effort polish, never a
- * reason to fail a compose).
+ * Both filters are core libavfilter (no external libs), like the
+ * `freezedetect`/`signalstats` probes already used here.
  */
-export function probeFlatTailMs(
+const FLAT_SPREAD = 4;
+const BLANK_EDGE_PX = 200;
+const EDGE_FILTER = "edgedetect=low=0.1:high=0.3";
+
+/** Per-frame stats from one `signalstats,metadata=print` pass, in frame order. */
+function signalstatsFrames(
   file: string,
-  durMs: number,
-  windowMs = 4000
-): Promise<number> {
-  const start = Math.max(0, durMs - windowMs) / 1000;
+  vf: string,
+  ss: number,
+  durSec: number | null
+): Promise<Array<Record<string, number>> | null> {
   return new Promise((resolvePromise) => {
     const proc = spawn(
       "ffmpeg",
       [
         "-hide_banner",
         "-nostats",
-        "-ss",
-        start.toFixed(3),
+        ...(ss > 0 ? ["-ss", ss.toFixed(3)] : []),
         "-i",
         file,
+        ...(durSec != null ? ["-t", durSec.toFixed(3)] : []),
         "-vf",
-        "signalstats,metadata=print:file=-",
+        `${vf}signalstats,metadata=print:file=-`,
         "-f",
         "null",
         "-",
@@ -128,115 +141,155 @@ export function probeFlatTailMs(
     );
     let out = "";
     proc.stdout.on("data", (d) => (out += d.toString()));
-    proc.on("error", () => resolvePromise(0));
-    proc.on("close", () => {
+    proc.on("error", () => resolvePromise(null));
+    proc.on("close", (code) => {
+      if (code !== 0) return resolvePromise(null);
       // The metadata muxer emits a header line per frame followed by one line
       // per key:
       //   frame:12  pts:...  pts_time:0.4
       //   lavfi.signalstats.YLOW=16
       //   ...
-      const frames: Array<{ t: number; spread: number }> = [];
-      let t = NaN;
-      let low = NaN;
-      let high = NaN;
-      const flush = (): void => {
-        if (!Number.isNaN(t) && !Number.isNaN(low) && !Number.isNaN(high)) {
-          frames.push({ t, spread: high - low });
-        }
-        low = NaN;
-        high = NaN;
-      };
+      const frames: Array<Record<string, number>> = [];
+      let cur: Record<string, number> | null = null;
       for (const line of out.split("\n")) {
-        const ts = /pts_time:\s*([\d.]+)/.exec(line);
+        const ts = /pts_time:\s*(-?[\d.]+)/.exec(line);
         if (ts) {
-          flush();
-          t = parseFloat(ts[1]);
+          cur = { t: parseFloat(ts[1]) };
+          frames.push(cur);
           continue;
         }
-        const lo = /YLOW=\s*([\d.]+)/.exec(line);
-        if (lo) low = parseFloat(lo[1]);
-        const hi = /YHIGH=\s*([\d.]+)/.exec(line);
-        if (hi) high = parseFloat(hi[1]);
+        const kv = /lavfi\.signalstats\.(\w+)=\s*(-?[\d.e+-]+)/.exec(line);
+        if (kv && cur) cur[kv[1]] = parseFloat(kv[2]);
       }
-      flush();
-      if (frames.length === 0) return resolvePromise(0);
-      // Walk back while frames stay flat. A real page — even a mostly-empty
-      // one — has chrome, text and edges, so its spread is far above this.
-      const FLAT_SPREAD = 4;
-      let i = frames.length - 1;
-      if (frames[i].spread > FLAT_SPREAD) return resolvePromise(0);
-      while (i > 0 && frames[i - 1].spread <= FLAT_SPREAD) i--;
-      resolvePromise(Math.max(0, Math.round(durMs - (start + frames[i].t) * 1000)));
+      resolvePromise(frames);
     });
   });
 }
 
+/** Luma flatness per frame of a window; `t` is absolute seconds in `file`. */
+async function flatFrames(
+  file: string,
+  ss: number,
+  durSec: number | null
+): Promise<Array<{ t: number; flat: boolean }> | null> {
+  const frames = await signalstatsFrames(file, "", ss, durSec);
+  if (!frames) return null;
+  const out: Array<{ t: number; flat: boolean }> = [];
+  for (const f of frames) {
+    if (f.YLOW == null || f.YHIGH == null) return null;
+    out.push({ t: ss + f.t, flat: f.YHIGH - f.YLOW <= FLAT_SPREAD });
+  }
+  return out;
+}
+
 /**
- * Mirror of `probeFlatTailMs` for the HEAD of a file: how many ms at the start
- * are a flat, contentless frame (the browser's white pre-paint after a `goto`).
- * Used to open the video on the product instead of on a blank page, and to pick
- * a poster frame that isn't a white rectangle (issue #47). Best-effort: any
- * probe failure resolves to 0.
+ * Which frames of a contiguous run of flat frames (absolute times, in order)
+ * are also free of outlines — i.e. truly blank. The edge pass is the costly
+ * one (Canny on every full-size frame), so it runs only over this run, never
+ * over a window whose frames already differ. A frame the second pass can't be
+ * matched to counts as content: a probe hiccup must never cause a trim.
  */
-export function probeFlatLeadMs(
+async function blankInRun(
   file: string,
+  run: Array<{ t: number }>,
+  pxScale: number
+): Promise<boolean[] | null> {
+  const step =
+    run.length > 1 ? (run[run.length - 1].t - run[0].t) / (run.length - 1) : 1 / 30;
+  const half = Math.max(step / 2, 0.001);
+  // Seek half a frame early: `-ss` is rounded to ms, and an accurate seek
+  // drops a frame whose pts lands a hair before it.
+  const ss = Math.max(0, run[0].t - half);
+  const [dims, edges] = await Promise.all([
+    probeVideoDims(file).catch(() => null),
+    signalstatsFrames(file, `${EDGE_FILTER},`, ss, run[run.length - 1].t - ss + step),
+  ]);
+  if (!dims || !edges) return null;
+  const area = dims.width * dims.height;
+  const scale = pxScale > 0 ? pxScale : 1;
+  const samples = edges
+    .filter((e) => e.YAVG != null)
+    .map((e) => ({ t: ss + e.t, px: ((e.YAVG / 255) * area) / scale }));
+  let j = 0;
+  return run.map((f) => {
+    while (
+      j + 1 < samples.length &&
+      Math.abs(samples[j + 1].t - f.t) <= Math.abs(samples[j].t - f.t)
+    ) {
+      j++;
+    }
+    const s = samples[j];
+    return !!s && Math.abs(s.t - f.t) <= half && s.px < BLANK_EDGE_PX;
+  });
+}
+
+/**
+ * Length (ms) of the *blank* tail of a video — the trailing run of frames
+ * that show nothing (one solid colour and no text or outlines; see
+ * `FLAT_SPREAD` / `BLANK_EDGE_PX`).
+ *
+ * Compose freeze-holds a scene's last frame when the narration outruns the
+ * recorded action. When the scene ends right before a `goto`, that last frame
+ * is the browser's white pre-paint, and the hold clones *white* for as long as
+ * the narration runs (issue #36: 37 near-blank seconds out of 209). Trimming
+ * the blank tail first makes the hold clone the last frame that actually shows
+ * the app. A sparse-but-real page (a terminal prompt on a dark background) is
+ * not blank, so its tail is never dropped (issue #78).
+ *
+ * `pxScale` is device px per CSS px (output width / `video.width`), so the
+ * edge threshold means the same on a 1x and a 2x take. Scans at most
+ * `windowMs` from the end; returns 0 when the tail has real content, or when
+ * the probe fails for any reason (best-effort polish, never a reason to fail a
+ * compose).
+ */
+export async function probeFlatTailMs(
+  file: string,
+  durMs: number,
   windowMs = 4000,
-  startMs = 0
+  pxScale = 1
 ): Promise<number> {
-  return new Promise((resolvePromise) => {
-    const proc = spawn(
-      "ffmpeg",
-      [
-        "-hide_banner",
-        "-nostats",
-        ...(startMs > 0 ? ["-ss", (startMs / 1000).toFixed(3)] : []),
-        "-i",
-        file,
-        "-t",
-        (windowMs / 1000).toFixed(3),
-        "-vf",
-        "signalstats,metadata=print:file=-",
-        "-f",
-        "null",
-        "-",
-      ],
-      { stdio: ["ignore", "pipe", "ignore"] }
-    );
-    let out = "";
-    proc.stdout.on("data", (d) => (out += d.toString()));
-    proc.on("error", () => resolvePromise(0));
-    proc.on("close", () => {
-      const frames: Array<{ t: number; spread: number }> = [];
-      let t = NaN;
-      let low = NaN;
-      let high = NaN;
-      const flush = (): void => {
-        if (!Number.isNaN(t) && !Number.isNaN(low) && !Number.isNaN(high)) {
-          frames.push({ t, spread: high - low });
-        }
-        low = NaN;
-        high = NaN;
-      };
-      for (const line of out.split("\n")) {
-        const ts = /pts_time:\s*([\d.]+)/.exec(line);
-        if (ts) {
-          flush();
-          t = parseFloat(ts[1]);
-          continue;
-        }
-        const lo = /YLOW=\s*([\d.]+)/.exec(line);
-        if (lo) low = parseFloat(lo[1]);
-        const hi = /YHIGH=\s*([\d.]+)/.exec(line);
-        if (hi) high = parseFloat(hi[1]);
-      }
-      flush();
-      const FLAT_SPREAD = 4;
-      if (!frames.length || frames[0].spread > FLAT_SPREAD) return resolvePromise(0);
-      let i = 0;
-      while (i + 1 < frames.length && frames[i + 1].spread <= FLAT_SPREAD) i++;
-      resolvePromise(Math.max(0, Math.round(frames[i].t * 1000)));
-    });
-  });
+  const start = Math.max(0, durMs - windowMs) / 1000;
+  const frames = await flatFrames(file, start, null);
+  if (!frames || !frames.length || !frames[frames.length - 1].flat) return 0;
+  let i = frames.length - 1;
+  while (i > 0 && frames[i - 1].flat) i--;
+  const run = frames.slice(i);
+  // A static page (a terminal) is one long flat run: settle it on the last
+  // frame alone before paying for the whole run.
+  if (!(await blankInRun(file, run.slice(-1), pxScale))?.[0]) return 0;
+  const blank = await blankInRun(file, run, pxScale);
+  if (!blank || !blank[blank.length - 1]) return 0;
+  let k = blank.length - 1;
+  while (k > 0 && blank[k - 1]) k--;
+  return Math.max(0, Math.round(durMs - run[k].t * 1000));
+}
+
+/**
+ * Mirror of `probeFlatTailMs` for the HEAD of a file: how many ms after
+ * `startMs` are blank frames (the browser's white pre-paint after a `goto`, a
+ * solid splash). Used to open the video on the product instead of on a blank
+ * page, and to pick a poster frame that isn't a white rectangle (issue #47). A
+ * static but populated opening — a dark terminal with a prompt — is content,
+ * not blank (issue #78). Best-effort: any probe failure resolves to 0.
+ */
+export async function probeFlatLeadMs(
+  file: string,
+  windowMs = 4000,
+  startMs = 0,
+  pxScale = 1
+): Promise<number> {
+  const start = startMs / 1000;
+  const frames = await flatFrames(file, start, windowMs / 1000);
+  if (!frames || !frames.length || !frames[0].flat) return 0;
+  let i = 0;
+  while (i + 1 < frames.length && frames[i + 1].flat) i++;
+  const run = frames.slice(0, i + 1);
+  if (!(await blankInRun(file, run.slice(0, 1), pxScale))?.[0]) return 0;
+  const blank = await blankInRun(file, run, pxScale);
+  if (!blank || !blank[0]) return 0;
+  let k = 0;
+  while (k + 1 < blank.length && blank[k + 1]) k++;
+  return Math.max(0, Math.round((run[k].t - start) * 1000));
 }
 
 /** A motionless span found by `freezedetect`, in ms from the file's start. */

package/src/frame.ts

@@ -7,7 +7,7 @@
  * overlays that PNG. Two baseline filters (`pad`, `overlay`), no drawbox.
  */
 
-import { chromium } from "playwright";
+import { launchChrome } from "./browser.js";
 import type { Brand, Frame } from "./types.js";
 
 export interface FrameLayout {
@@ -189,7 +189,7 @@ export async function renderFramePng(
     <div class="canvas">${device ? '<div class="bezel"></div>' : ""}<div class="win"></div>${chromeHtml}</div>${deviceHtml}
   </body></html>`;
 
-  const browser = await chromium.launch({ channel: "chrome", headless: true });
+  const browser = await launchChrome({ headless: true });
   const context = await browser.newContext({
     viewport: { width: W, height: H },
     deviceScaleFactor: pxScale,

package/src/inspect.ts

@@ -10,7 +10,8 @@
  * fix a selector from the failure artifact instead of guessing.
  */
 
-import { chromium, type Frame, type Page } from "playwright";
+import type { Frame, Page } from "playwright";
+import { launchChromePersistent } from "./browser.js";
 import { chromeProfileDir } from "./config.js";
 import { ensureProfileUnlocked } from "./login.js";
 import { applySeeds, type Seeds } from "./setup.js";
@@ -36,6 +37,8 @@ export interface InspectElement {
 }
 
 export interface InspectResult {
+  /** Whether the requested product UI was actually available to inspect. */
+  target: { status: "available" | "blocked"; reason?: string };
   url: string;
   finalUrl: string;
   title: string;
@@ -174,11 +177,12 @@ const SCAN_JS = String.raw`(() => {
     src: (f.getAttribute("src") || "").slice(0, 200),
     selector: f.id && stableId(f.id) ? "#" + cssEsc(f.id) : (f.getAttribute("name") ? 'iframe[name="' + q(f.getAttribute("name")) + '"]' : "iframe:nth-of-type(" + (i + 1) + ")"),
   }));
-  return { title: document.title, elements: items, headings, iframes, truncated: all.length > LIMIT && items.length >= LIMIT, total: all.length };
+  return { title: document.title, bodyText: (document.body?.innerText || "").slice(0, 1200), elements: items, headings, iframes, truncated: all.length > LIMIT && items.length >= LIMIT, total: all.length };
 })()`;
 
 interface ScanResult {
   title: string;
+  bodyText: string;
   elements: InspectElement[];
   headings: Array<{ level: number; text: string }>;
   iframes: Array<{ name: string; src: string; selector: string }>;
@@ -186,6 +190,23 @@ interface ScanResult {
   total: number;
 }
 
+/** Conservative signal: report a challenge without guessing how to solve it. */
+export function inspectTargetStatus(scan: Pick<ScanResult, "title" | "headings" | "bodyText">): InspectResult["target"] {
+  const title = scan.title.trim().toLowerCase();
+  const headings = scan.headings.map((h) => h.text.toLowerCase()).join(" ");
+  const body = scan.bodyText.toLowerCase();
+  if (/^(just a moment|attention required|security verification|checking your browser)/i.test(title) ||
+      /performing security verification|verify (you are|that you are) human|checking your browser/i.test(headings) ||
+      (/security verification|verify you are human/i.test(body) && /challenge|cloudflare|captcha/i.test(body))) {
+    return { status: "blocked", reason: "security verification page; the requested product UI was not inspected" };
+  }
+  if (/^(sign in|log in|login|authentication required)$/i.test(scan.title.trim()) &&
+      /sign in|log in|email|password/i.test(body)) {
+    return { status: "blocked", reason: "login page; the requested product UI was not inspected" };
+  }
+  return { status: "available" };
+}
+
 /** Scan one frame for visible interactive elements (see SCAN_JS). */
 export async function scanInteractive(
   target: Page | Frame,
@@ -199,8 +220,7 @@ export async function inspectPage(opts: InspectOptions): Promise<InspectResult>
   const profileDir = opts.profileDir ?? chromeProfileDir();
   await ensureProfileUnlocked(profileDir);
   const viewport = opts.viewport ?? { width: 1280, height: 720 };
-  const context = await chromium.launchPersistentContext(profileDir, {
-    channel: "chrome",
+  const context = await launchChromePersistent(profileDir, {
     headless: opts.headless !== false,
     args: ["--disable-blink-features=AutomationControlled"],
     viewport,
@@ -233,6 +253,7 @@ export async function inspectPage(opts: InspectOptions): Promise<InspectResult>
       screenshot = opts.screenshotPath;
     }
     return {
+      target: inspectTargetStatus(main),
       url: opts.url,
       finalUrl: page.url(),
       title: main.title,

package/src/login.ts

@@ -2,6 +2,7 @@ import { promises as fs } from "node:fs";
 import { join, resolve } from "node:path";
 import { spawn } from "node:child_process";
 import { chromeProfileDir } from "./config.js";
+import { manualLaunchBinary } from "./browser.js";
 import { ensureDir, log, ok, step, sleep } from "./util.js";
 
 /**
@@ -98,13 +99,16 @@ export async function login(profileDir?: string, opts: LoginOptions = {}): Promi
       "--no-default-browser-check",
       url,
     ];
-    if (process.platform === "darwin") {
+    // AIDEMO_CHROME_EXECUTABLE / AIDEMO_CHROME_CHANNEL=chromium: log in with
+    // the SAME browser the recorder will launch (issue #80).
+    const configured = manualLaunchBinary();
+    if (process.platform === "darwin" && !configured) {
       spawn("open", ["-na", "Google Chrome", "--args", ...args], {
         stdio: "ignore",
         detached: true,
       }).unref();
     } else {
-      const bin = process.env.CHROME_BIN || "google-chrome";
+      const bin = configured || process.env.CHROME_BIN || "google-chrome";
       const child = spawn(bin, args, { stdio: "ignore", detached: true });
       child.on("error", () => {
         log(`could not launch "${bin}" (set CHROME_BIN) — open Chrome yourself with:`);