@broberg/lens-daemon 0.1.37 → 0.1.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@broberg/lens-daemon",
-  "version": "0.1.37",
+  "version": "0.1.38",
   "description": "The Lens module of the cardmem daemon (flows, critic, coverage, capture sessions, the /lens/* routes and the cardmem-lens MCP) as a package. The daemon mounts createLensRouter(deps) + createLensMcpRouter(deps). Bun runtime.",
   "type": "module",
   "license": "MIT",
@@ -15,8 +15,8 @@
     "sharp": "^0.35.5",
     "turndown": "^7.2.4",
     "zod": "^3.23.8",
-    "@broberg/lens-engine": "0.14.1",
-    "@broberg/lens-svg": "0.1.1"
+    "@broberg/lens-svg": "0.1.1",
+    "@broberg/lens-engine": "0.14.1"
   },
   "devDependencies": {
     "@happy-dom/global-registrator": "^20.10.6",

package/src/browser.ts

@@ -11,6 +11,7 @@
 // context + page are always closed in a finally, even on capture error.
 
 import { bindProfileChannel, claimProfile, killOwnBrowsersOn, profileDir, type ProfileChannel } from './profiles.ts';
+import { launchWithRepair, type BrowserRepair } from './ensure-chromium.ts';
 import {
   chromium,
   webkit,
@@ -80,7 +81,15 @@ const CHROMIUM_ARGS = [
 
 async function launch(engine: LensEngine): Promise<Browser> {
   const args = engine === 'chromium' ? CHROMIUM_ARGS : [];
-  return ENGINES[engine].launch({ headless: true, args });
+  // F010.1 — a deleted browser is installed and the launch retried, not a fleet-wide outage.
+  return launchWithRepair(engine, () => ENGINES[engine].launch({ headless: true, args }), (r) => lastRepairs.push(r));
+}
+
+/** F010.1 — repairs made since the last read; a run reads (and clears) them into
+ *  its report. Read-and-clear, so one repair is reported once. */
+const lastRepairs: BrowserRepair[] = [];
+export function takeBrowserRepairs(): BrowserRepair[] {
+  return lastRepairs.splice(0, lastRepairs.length);
 }
 
 /** Get the warm browser for an engine, launching it on first use. Re-launches
@@ -353,7 +362,7 @@ async function launchWithExtension(
     if (profile) bindProfileChannel(profile, EXTENSION_CHANNEL);
     userDataDir = profile ? profileDir(profile) : await mkdtemp(join(tmpdir(), 'lens-ext-'));
     try {
-      context = await chromium.launchPersistentContext(userDataDir, {
+      context = await launchWithRepair('chromium', () => chromium.launchPersistentContext(userDataDir, {
         ...contextOptions(opts),
         headless: true,
         channel: EXTENSION_CHANNEL,
@@ -364,7 +373,7 @@ async function launchWithExtension(
           '--disable-dev-shm-usage',
           '--no-sandbox',
         ],
-      });
+      }), (r) => lastRepairs.push(r));
     } catch (err) {
       lastLaunchError = err instanceof Error ? err.message.split('\n')[0]! : String(err);
       if (!profile) await rm(userDataDir, { recursive: true, force: true }).catch(() => {});

package/src/ensure-chromium.ts

@@ -14,7 +14,7 @@ import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, join } from 'node:path';
-import { chromium } from 'playwright';
+import { chromium, firefox, webkit } from 'playwright';
 
 export interface ChromiumExpectation {
   installed: boolean;
@@ -116,3 +116,115 @@ export function ensureChromium(): Promise<{
 
   return inFlight;
 }
+
+// ── F010.1 — repair at the moment of need, for every engine ────────────────────
+//
+// ensureChromium() runs once at daemon boot and installs the FULL Chromium only.
+// On 25 Oct the browsers were deleted while the daemon was running, and the warm
+// headless launch uses chromium-headless-shell, which boot never checked: every
+// run fleet-wide failed until a hand reinstalled. Now a launch that fails because
+// its binary is missing installs that engine's browsers (from the daemon's own
+// pinned Playwright, same as boot) and is retried once.
+
+export type BrowserEngine = 'chromium' | 'webkit' | 'firefox';
+
+/** What `playwright install` must fetch for an engine to launch in every mode Lens uses. */
+const INSTALL_NAMES: Record<BrowserEngine, string[]> = {
+  chromium: ['chromium', 'chromium-headless-shell', 'ffmpeg'],
+  webkit: ['webkit'],
+  firefox: ['firefox'],
+};
+
+export function isMissingBrowserError(err: unknown): boolean {
+  return /Executable doesn't exist/.test(err instanceof Error ? err.message : String(err));
+}
+
+type Installer = (names: string[]) => Promise<{ ok: boolean; error?: string }>;
+
+const spawnInstaller: Installer = (names) =>
+  new Promise((resolve) => {
+    let cliPath: string;
+    try {
+      cliPath = resolvePlaywrightCli();
+    } catch (err) {
+      resolve({ ok: false, error: `cannot resolve playwright CLI: ${err instanceof Error ? err.message : String(err)}` });
+      return;
+    }
+    console.log(`[lens] browser missing — installing ${names.join(', ')} via ${cliPath} …`);
+    const child = spawn(process.execPath, [cliPath, 'install', ...names], { stdio: 'inherit', env: process.env });
+    child.on('error', (err) => resolve({ ok: false, error: err.message }));
+    child.on('exit', (code) => resolve(code === 0 ? { ok: true } : { ok: false, error: `playwright install exited ${code}` }));
+  });
+
+let installer: Installer = spawnInstaller;
+/** Test seam: replace the installer (null restores the real one). */
+export function setBrowserInstaller(fn: Installer | null): void {
+  installer = fn ?? spawnInstaller;
+}
+
+// One install per engine at a time: two runs that hit the gap together share it.
+const engineInFlight = new Map<BrowserEngine, Promise<{ ok: boolean; error?: string }>>();
+
+export function installBrowsers(engine: BrowserEngine): Promise<{ ok: boolean; error?: string }> {
+  let p = engineInFlight.get(engine);
+  if (!p) {
+    p = installer(INSTALL_NAMES[engine]).finally(() => engineInFlight.delete(engine));
+    engineInFlight.set(engine, p);
+  }
+  return p;
+}
+
+export interface BrowserRepair {
+  engine: BrowserEngine;
+  ms: number;
+}
+
+/** Run a launch; if it fails ONLY because the browser binary is missing, install
+ *  that engine's browsers and retry once. Any other error propagates untouched. */
+export async function launchWithRepair<T>(
+  engine: BrowserEngine,
+  launch: () => Promise<T>,
+  onRepaired?: (r: BrowserRepair) => void,
+): Promise<T> {
+  try {
+    return await launch();
+  } catch (err) {
+    if (!isMissingBrowserError(err)) throw err;
+    const t0 = Date.now();
+    const inst = await installBrowsers(engine);
+    if (!inst.ok) {
+      throw new Error(`${engine} browser is missing and could not be installed: ${inst.error ?? 'unknown'} — original: ${(err as Error).message.split('\n')[0]}`);
+    }
+    const out = await launch();
+    onRepaired?.({ engine, ms: Date.now() - t0 });
+    return out;
+  }
+}
+
+/** For /health: does each engine's browser binary exist where this daemon looks?
+ *  chromium is reported for both the full build and the headless shell, because
+ *  the warm headless launch needs the shell (the 25 Oct gap boot never checked). */
+export function browsersPresent(): Record<string, boolean> {
+  const has = (f: () => string) => {
+    try {
+      return existsSync(f());
+    } catch {
+      return false;
+    }
+  };
+  const full = (() => {
+    try {
+      return chromium.executablePath();
+    } catch {
+      return '';
+    }
+  })();
+  const m = /^(.*[\\/])chromium-(\d+)[\\/]/.exec(full);
+  const shellDir = m ? join(m[1]!, `chromium_headless_shell-${m[2]}`) : '';
+  return {
+    chromium: has(() => full),
+    'chromium-headless-shell': shellDir ? existsSync(shellDir) : false,
+    webkit: has(() => webkit.executablePath()),
+    firefox: has(() => firefox.executablePath()),
+  };
+}

package/src/flow.ts

@@ -23,7 +23,7 @@ import {
   type AssertOutcome,
   type Target,
 } from '@broberg/lens-engine';
-import { withPage, type LensEngine, type RunBrowser } from './browser.ts';
+import { takeBrowserRepairs, withPage, type LensEngine, type RunBrowser } from './browser.ts';
 import { collectNetworkShapes, type NetworkShapesOptions, type NetworkShapesReport } from './network-shapes.ts';
 import { deadline, defaultPopupOf, prepareExtension, seedExtensionStorage, SIMULATED_ACCESS_NOTE } from './extension-flow.ts';
 import { authPrepare, fetchMintJson, persistStorageState, persistTarget, type AuthConfig, type AuthEnv } from './auth/index.ts';
@@ -424,6 +424,8 @@ export interface FlowResult {
   /** F009.131 — set when auth.persist was asked for: whether the renewed login was
    *  written back to statePath, and why not when it was not. Never a value. */
   auth_persisted?: { ok: boolean; reason?: string };
+  /** F010.1 — browsers the daemon reinstalled because their binary was missing. */
+  browser_repaired?: Array<{ engine: string; ms: number }>;
   /** F009.137 — mails this run consumed for a code, and how many were removed
    *  after. Present only when a step read mail. Never a code or a body. */
   mail?: { consumed: number; cleaned: number; reason?: string };
@@ -3508,6 +3510,8 @@ export async function runFlow(flow: Flow, env: AuthEnv, opts: RunFlowOptions = {
     reduced_motion: opts.reducedMotion ?? 'reduce',
     ...(authPersisted ? { auth_persisted: authPersisted } : {}),
     ...(mailReport ? { mail: mailReport } : {}),
+    // F010.1 — a missing browser this run had to reinstall, said out loud.
+    ...((() => { const r = takeBrowserRepairs(); return r.length ? { browser_repaired: r } : {}; })()),
     ...(extensionInfo ? { extension: extensionInfo } : {}),
     ...(networkShapesReport ? { network_shapes: networkShapesReport } : {}),
     downloads,

package/src/http.ts

@@ -5,6 +5,7 @@
 // all hit these. Artifact bytes are served here too, so an <img> in the
 // dashboard points straight at the daemon.
 
+import { browsersPresent } from './ensure-chromium.ts';
 import { Hono } from 'hono';
 import { setSandboxResolver } from './sandbox.ts';
 import { registerDaemonRoutes } from './daemon-routes.ts';
@@ -79,6 +80,8 @@ export function createLensRouter(deps: LensDeps): Hono {
 
   // F276.1/F276.4 — the upload queue: what it holds, and one drain pass.
   r.get('/uploads', (c) => c.json({ ok: true, ...uploadStats(deps.db) }));
+  // F010.1 — does each engine's browser binary exist where this daemon looks?
+  r.get('/browsers', (c) => c.json({ ok: true, browsers: browsersPresent() }));
   r.post('/uploads/drain', handle(async (body) => {
     const b = (body ?? {}) as { batch?: number };
     return drainUploads(deps.db, deps.storage, deps.cloud?.() ?? null, { batch: b.batch });

package/src/index.ts

@@ -16,7 +16,7 @@ export { durabilityOf, type EvidenceDurability } from './durability.ts';
 export { setSandboxResolver, type SandboxResolver } from './sandbox.ts';
 // Lifecycle the daemon owns: provision Chromium at boot, drain the evidence
 // upload queue on its timer, close the warm browser on shutdown.
-export { ensureChromium } from './ensure-chromium.ts';
+export { ensureChromium, browsersPresent } from './ensure-chromium.ts';
 export { drainUploads } from './artifact-uploads.ts';
 export { closeBrowser } from './browser.ts';