@sudobility/testomniac_runner 0.0.160 → 0.0.161

package/bun.lock

@@ -8,7 +8,7 @@
         "@noble/curves": "^1.0.0",
         "@noble/hashes": "^1.0.0",
         "@sudobility/signic_sdk": "^0.1.7",
-        "@sudobility/testomniac_runner_service": "^0.1.154",
+        "@sudobility/testomniac_runner_service": "^0.1.155",
         "@sudobility/testomniac_types": "^0.0.78",
         "hono": "^4.7.0",
         "jose": "^6.1.2",
@@ -172,7 +172,7 @@
 
     "@sudobility/signic_sdk": ["@sudobility/signic_sdk@0.1.7", "", {}, "sha512-5XSgHSVsmyrMQ/ui1nDywwzt9dbRCsaeJ5tX6mKw2ZXbTZ82OsMr+dqDyV9XV3pfy7IHRIZq73af5KBamx72Fw=="],
 
-    "@sudobility/testomniac_runner_service": ["@sudobility/testomniac_runner_service@0.1.154", "", { "peerDependencies": { "@sudobility/testomniac_types": "^0.0.78" } }, "sha512-pHGkl5TcCteE698Y3Z0dGrQjDc43CyN0vdEusPalY9CWiRA4ZbfC8lBEiLwWZsSeIoZLWaQcLEIIdFLjgRDTyg=="],
+    "@sudobility/testomniac_runner_service": ["@sudobility/testomniac_runner_service@0.1.155", "", { "peerDependencies": { "@sudobility/testomniac_types": "^0.0.78" } }, "sha512-gu/r8bLxVyu0PQ1LjiJ8BBL4GdA3v3ZmdyG3fyaEeADQUgWyjsZqDwzzMVwdJyPWexORV3R/MxX+gIPIFMZBgQ=="],
 
     "@sudobility/testomniac_types": ["@sudobility/testomniac_types@0.0.78", "", { "peerDependencies": { "@sudobility/types": "^1.9.62" } }, "sha512-LMmuSEvrl16v49mRWMwjqSOisc6dwoghZcswaiyj5wRdzT2FHGLIgwl25LvYILaJrWpBy/VOdkOjlBbU/ea2qg=="],
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sudobility/testomniac_runner",
-  "version": "0.0.160",
+  "version": "0.0.161",
   "publishConfig": {
     "access": "public"
   },
@@ -24,7 +24,7 @@
     "@noble/curves": "^1.0.0",
     "@noble/hashes": "^1.0.0",
     "@sudobility/signic_sdk": "^0.1.7",
-    "@sudobility/testomniac_runner_service": "^0.1.154",
+    "@sudobility/testomniac_runner_service": "^0.1.155",
     "@sudobility/testomniac_types": "^0.0.78",
     "hono": "^4.7.0",
     "jose": "^6.1.2",

package/src/browser/chromium.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ChromiumManager } from "./chromium";
+import { loadConfig } from "../config/index";
+
+beforeEach(() => {
+  process.env.SCANNER_API_KEY = "test-key";
+  process.env.DEEP_LINK_SECRET = "test-secret";
+});
+
+function fakeBrowser() {
+  const page = { setViewport: vi.fn().mockResolvedValue(undefined) };
+  const context = {
+    newPage: vi.fn().mockResolvedValue(page),
+    close: vi.fn().mockResolvedValue(undefined),
+  };
+  const browser = {
+    createBrowserContext: vi.fn().mockResolvedValue(context),
+    close: vi.fn().mockResolvedValue(undefined),
+  };
+  return { browser, context, page };
+}
+
+describe("ChromiumManager shared browser", () => {
+  it("launches the browser only once across multiple launch() calls", async () => {
+    const { browser } = fakeBrowser();
+    const launcher = vi.fn().mockResolvedValue(browser);
+    const mgr = new ChromiumManager(loadConfig(), launcher as never);
+    await mgr.launch();
+    await mgr.launch();
+    expect(launcher).toHaveBeenCalledTimes(1);
+  });
+
+  it("creates an isolated context + page per run and closes only the context", async () => {
+    const { browser, context, page } = fakeBrowser();
+    const launcher = vi.fn().mockResolvedValue(browser);
+    const mgr = new ChromiumManager(loadConfig(), launcher as never);
+    await mgr.launch();
+    const acquired = await mgr.createContext();
+    expect(acquired.page).toBe(page);
+    await mgr.closeContext(acquired.context);
+    expect(context.close).toHaveBeenCalledTimes(1);
+    expect(browser.close).not.toHaveBeenCalled();
+  });
+});

package/src/browser/chromium.ts

@@ -1,10 +1,16 @@
 import { existsSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import puppeteer, { type Browser, type Page } from "puppeteer-core";
+import puppeteer, {
+  type Browser,
+  type BrowserContext,
+  type Page,
+} from "puppeteer-core";
 import type { Config } from "../config/index";
 import type { Screen } from "@sudobility/testomniac_types";
 
+type Launcher = typeof puppeteer.launch;
+
 /**
  * Finds the latest Chrome for Testing binary in the Puppeteer cache.
  * Falls back to common system paths, then to the config value.
@@ -64,10 +70,15 @@ export function resolveChromiumPath(configPath: string): string {
 export class ChromiumManager {
   private browser: Browser | null = null;
 
-  constructor(private config: Config) {}
+  constructor(
+    private config: Config,
+    private launcher: Launcher = puppeteer.launch
+  ) {}
 
+  /** Launch the shared browser. Idempotent — reuses the existing one. */
   async launch(): Promise<Browser> {
-    this.browser = await puppeteer.launch({
+    if (this.browser) return this.browser;
+    this.browser = await this.launcher({
       executablePath: resolveChromiumPath(this.config.chromiumPath),
       userDataDir: this.config.userDataDir,
       headless: true,
@@ -85,6 +96,28 @@ export class ChromiumManager {
     return page;
   }
 
+  /**
+   * Create an isolated browser context (own cookies/cache/storage) and a page
+   * within it. Use one per concurrent run so runs don't share profile state.
+   */
+  async createContext(
+    screen?: Screen
+  ): Promise<{ context: BrowserContext; page: Page }> {
+    if (!this.browser) throw new Error("Browser not launched");
+    const context = await this.browser.createBrowserContext();
+    const page = await context.newPage();
+    if (screen) {
+      await page.setViewport({ width: screen.width, height: screen.height });
+    }
+    return { context, page };
+  }
+
+  /** Close a single run's context (not the shared browser). */
+  async closeContext(context: BrowserContext): Promise<void> {
+    await context.close();
+  }
+
+  /** Close the whole browser. Process shutdown only. */
   async close(): Promise<void> {
     if (this.browser) {
       await this.browser.close();

package/src/config/index.ts

@@ -26,6 +26,9 @@ export function loadConfig(): Config {
     signicEmailApiUrl:
       process.env.SIGNIC_EMAIL_API_URL || "https://api.signic.email/api",
     chromiumPath: process.env.CHROMIUM_PATH || "/usr/bin/chromium",
+    // Single browser per worker; each run uses an isolated BrowserContext
+    // (own cookies/cache/storage), so this dir is shared safely. Do NOT shard
+    // per-run — context isolation already prevents cross-run profile contention.
     userDataDir: process.env.USER_DATA_DIR || "./testomniac-browser-profile",
     artifactDir: process.env.ARTIFACT_DIR || "./testomniac-artifacts",
     maxConcurrentRunners: Number(process.env.MAX_CONCURRENT_RUNNERS ?? 5),

package/src/index.ts

@@ -4,6 +4,7 @@ import pino from "pino";
 import { loadConfig } from "./config/index";
 import { RunnerManager } from "./runner-manager";
 import { runFullScan, runSequenceScan } from "./orchestrator";
+import { ChromiumManager } from "./browser/chromium";
 
 const logger = pino({
   name: "testomniac_runner",
@@ -14,7 +15,12 @@ const port = Number(process.env.PORT ?? 8030);
 const config = loadConfig();
 const pollIntervalMs = Number(process.env.SCAN_POLL_INTERVAL_MS ?? 10_000);
 const maxConcurrentRunners = config.maxConcurrentRunners;
-const runnerManager = new RunnerManager(pollIntervalMs, maxConcurrentRunners);
+const chromium = new ChromiumManager(config);
+const runnerManager = new RunnerManager(
+  pollIntervalMs,
+  maxConcurrentRunners,
+  chromium
+);
 const runnerInstanceId =
   process.env.TESTOMNIAC_RUNNER_INSTANCE_ID ??
   process.env.TESTOMNIAC_RUNNER_PROCESS_INSTANCE_ID;
@@ -97,7 +103,9 @@ if (import.meta.main) {
       process.exit(1);
     }
   } else {
-    // Default: polling mode
+    // Default: polling mode — launch the shared browser once up front.
+    await runnerManager.start();
+
     const pollInterval = setInterval(() => {
       void runnerManager.tick();
     }, pollIntervalMs);
@@ -147,7 +155,7 @@ if (import.meta.main) {
         const check = setInterval(() => {
           if (runnerManager.getActiveRunCount() === 0) {
             clearInterval(check);
-            process.exit(0);
+            void runnerManager.shutdown().finally(() => process.exit(0));
           }
         }, 500);
         setTimeout(() => {

package/src/orchestrator.ts

@@ -1,4 +1,5 @@
 import pino from "pino";
+import type { Page } from "puppeteer-core";
 import { ChromiumManager } from "./browser/chromium";
 import { loadConfig } from "./config/index";
 import { computeSummary } from "./runner/reporter";
@@ -42,6 +43,12 @@ export interface RunOptions {
   quickScan?: boolean;
   scanMode?: "full" | "partial" | "minimum";
   signal?: AbortSignal;
+  /**
+   * A page from a shared browser (polling mode reuses one browser across runs
+   * with an isolated context per run). When omitted (one-shot CLI mode) a
+   * one-off browser is launched and torn down here.
+   */
+  page?: Page;
 }
 
 export async function runFullScan(options: RunOptions): Promise<void> {
@@ -53,15 +60,18 @@ export async function runFullScan(options: RunOptions): Promise<void> {
 
   const runStart = Date.now();
 
-  const chromium = new ChromiumManager(config);
-  await chromium.launch();
+  // Reuse an injected page when provided (shared browser); otherwise
+  // self-manage a one-off browser for this single run.
+  const ownsBrowser = options.page == null;
+  const chromium = ownsBrowser ? new ChromiumManager(config) : null;
+  if (chromium) await chromium.launch();
   const runnerId = options.runnerId;
   const scanId = options.scanId;
 
   try {
     const defaultScreen: Screen =
       sizeClass === SizeClass.Desktop ? DESKTOP_SCREENS[0] : MOBILE_SCREENS[0];
-    const page = await chromium.newPage(defaultScreen);
+    const page = options.page ?? (await chromium!.newPage(defaultScreen));
     const adapter = new PuppeteerAdapter(page);
 
     const eventHandler: ScanEventHandler & {
@@ -144,10 +154,14 @@ export async function runFullScan(options: RunOptions): Promise<void> {
       });
     }
 
-    try {
-      await page.close();
-    } catch (err) {
-      logger.debug({ err }, "page already closed during scan cleanup");
+    // When we own the browser, close the page here. When the page was
+    // injected, the caller (RunnerManager.withRunContext) closes its context.
+    if (ownsBrowser) {
+      try {
+        await page.close();
+      } catch (err) {
+        logger.debug({ err }, "page already closed during scan cleanup");
+      }
     }
 
     logger.info(
@@ -155,7 +169,7 @@ export async function runFullScan(options: RunOptions): Promise<void> {
       "run complete"
     );
   } finally {
-    await chromium.close();
+    if (chromium) await chromium.close();
   }
 }
 

package/src/runner-manager.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect, vi } from "vitest";
+import { RunnerManager } from "./runner-manager";
+
+describe("RunnerManager context lifecycle", () => {
+  it("acquires and releases a context for each run, even on failure", async () => {
+    const context = {};
+    const page = {};
+    const chromium = {
+      launch: vi.fn().mockResolvedValue({}),
+      createContext: vi.fn().mockResolvedValue({ context, page }),
+      closeContext: vi.fn().mockResolvedValue(undefined),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+    const mgr = new RunnerManager(1000, 2, chromium as never);
+
+    await expect(
+      mgr.withRunContext(async p => {
+        expect(p).toBe(page);
+        throw new Error("boom");
+      })
+    ).rejects.toThrow("boom");
+
+    expect(chromium.createContext).toHaveBeenCalledTimes(1);
+    expect(chromium.closeContext).toHaveBeenCalledWith(context);
+  });
+
+  it("start() launches the shared browser; shutdown() closes it", async () => {
+    const chromium = {
+      launch: vi.fn().mockResolvedValue({}),
+      createContext: vi.fn(),
+      closeContext: vi.fn(),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+    const mgr = new RunnerManager(1000, 1, chromium as never);
+    await mgr.start();
+    await mgr.shutdown();
+    expect(chromium.launch).toHaveBeenCalledTimes(1);
+    expect(chromium.close).toHaveBeenCalledTimes(1);
+  });
+});

package/src/runner-manager.ts

@@ -1,7 +1,9 @@
 import pino from "pino";
+import type { Page } from "puppeteer-core";
 import { getApiClient } from "@sudobility/testomniac_runner_service";
 import { loadConfig } from "./config/index";
 import { runFullScan } from "./orchestrator";
+import { ChromiumManager } from "./browser/chromium";
 
 const logger = pino({
   name: "runner_manager",
@@ -22,9 +24,31 @@ export class RunnerManager {
 
   constructor(
     private readonly pollIntervalMs: number,
-    private readonly maxConcurrentRunners: number
+    private readonly maxConcurrentRunners: number,
+    private readonly chromium: ChromiumManager
   ) {}
 
+  /** Launch the shared browser once before polling begins. */
+  async start(): Promise<void> {
+    await this.chromium.launch();
+  }
+
+  /** Stop active runs and close the shared browser (process shutdown). */
+  async shutdown(): Promise<void> {
+    this.stopAllRuns();
+    await this.chromium.close();
+  }
+
+  /** Run `fn(page)` in a fresh isolated context, always releasing it. */
+  async withRunContext<T>(fn: (page: Page) => Promise<T>): Promise<T> {
+    const { context, page } = await this.chromium.createContext();
+    try {
+      return await fn(page);
+    } finally {
+      await this.chromium.closeContext(context);
+    }
+  }
+
   getActiveRunCount(): number {
     return this.activeRuns.size;
   }
@@ -176,19 +200,22 @@ export class RunnerManager {
     const api = getApiClient(config.apiUrl, config.scannerApiKey);
 
     try {
-      await runFullScan({
-        runnerId: params.runnerId,
-        scanId: params.runId,
-        scanUrl: params.scanUrl,
-        baseUrl: params.scanUrl,
-        sizeClass: params.sizeClass,
-        runnerName: params.runnerName,
-        runnerInstanceId: params.runnerInstanceId,
-        runnerInstanceName: params.runnerInstanceName,
-        quickScan: params.quickScan,
-        scanMode: params.scanMode,
-        signal: params.signal,
-      });
+      await this.withRunContext(page =>
+        runFullScan({
+          page,
+          runnerId: params.runnerId,
+          scanId: params.runId,
+          scanUrl: params.scanUrl,
+          baseUrl: params.scanUrl,
+          sizeClass: params.sizeClass,
+          runnerName: params.runnerName,
+          runnerInstanceId: params.runnerInstanceId,
+          runnerInstanceName: params.runnerInstanceName,
+          quickScan: params.quickScan,
+          scanMode: params.scanMode,
+          signal: params.signal,
+        })
+      );
 
       logger.info({ runId: params.runId }, "run completed successfully");
     } catch (error) {