@ai-ecoverse/slicc-shared-web 1.10.1 → 1.10.2

package/README.md

@@ -31,7 +31,7 @@ The hooks expect two scripts in each repo: `test:unit`, which writes `coverage/u
 
 ## Integration-test harness
 
-`harness/` drives playwright-core's Chromium over raw CDP, as its only client, from `node --test`. Every page, service worker, shared worker and dedicated worker, nested ones included, starts paused, gets coverage and the CPU profiler switched on in the same tick, and only then runs. Each test gets its own browser context and leaves `artifacts/<suite>/<test>/` behind: one CPU profile per target and snapshot, a screenshot per tab and a `console.log` of every target. The global teardown merges the raw coverage into `coverage/` (console table, lcov, V8 HTML) and writes `artifacts/hotspots.md`, the 15 frames with the most self time in the repo's own scripts.
+`harness/` drives playwright-core's Chromium over raw CDP on `--remote-debugging-pipe`, as its only client, from `node --test`. Every page, service worker, shared worker and dedicated worker, nested ones included, starts paused, gets coverage and the CPU profiler switched on in the same tick, and only then runs. Each test gets its own browser context and leaves `artifacts/<suite>/<test>/` behind: one CPU profile per target and snapshot, a screenshot per tab and a `console.log` of every target. Lines logged before the first test, such as an extension service worker's at startup, go into the first test's `console.log`. The global teardown merges the raw coverage into `coverage/` (console table, lcov, V8 HTML) and writes `artifacts/hotspots.md`, the 15 frames with the most self time in the repo's own scripts.
 
 `playwright-core` and `monocart-coverage-reports` are peer dependencies; pin both in the repo's `devDependencies`. A repo describes what to serve and launches the browser once per test file:
 
@@ -60,7 +60,7 @@ test('boots', async (t) => {
 | `coverage` | URL prefixes whose `.js`/`.mjs` scripts count for coverage. `node_modules/` never does. A `.map` next to a file is used | `['/']` |
 | `exits` | `{ urlPath: [regex, ...] }`: a breakpoint on the first line matching each pattern in that worker script, where the harness takes the worker's coverage and profile before it closes itself | none |
 | `intercept` | Remote URL prefixes answered from a disk cache in `node_modules/.cache/`. Registry documents (anything on a `registry.*` host but a `/-/….tgz` tarball: packuments, abbreviated or full, and dist-tags) are fetched fresh once per test process and only served from the disk cache when the registry can't be reached (a `4xx` is passed on) | none |
-| `extensions` | Unpacked extension directories to load. Their scripts are covered and profiled like the repo's own, and tests then run in the default browser context, closing their tabs when they end, because Chrome does not run extensions in the per-test contexts | none |
+| `extensions` | Unpacked extension directories to load. They are loaded with `Extensions.loadUnpacked` (behind `--enable-unsafe-extension-debugging`) once the harness is attached, so their service workers start paused like every other target. Their scripts are covered and profiled like the repo's own, and tests then run in the default browser context, closing their tabs when they end, because Chrome does not run extensions in the per-test contexts | none |
 | `args` | Extra Chromium flags, such as `--host-resolver-rules` or `--ignore-certificate-errors` | none |
 | `timeout` | How long `page.until` polls and `page.evaluate` waits, in ms | `30000` |
 | `stallAfter` | How long one evaluation may run before the harness probes the test's targets, in ms | `30000` |
@@ -98,9 +98,9 @@ Why it works the way it does:
 
 ## Cleanup
 
-`close()` stops Chrome and removes its profile. A test process that ends without `close()` still leaves nothing running:
+`close()` stops Chrome and removes its profile. It asks Chrome to close, waits up to 10 s for the exit, sends `SIGKILL`, waits up to 5 s more and then moves on with a warning, so a browser that ignores `Browser.close` or a missed exit never hangs teardown. A test process that ends without `close()` still leaves nothing running:
 - on `exit` and on `SIGINT`, `SIGTERM` or `SIGHUP`, the harness kills every browser it started in that process with `SIGKILL` and removes its profile and crash dump directory, then re-raises the signal so the process ends the way it would have;
-- when the test process dies of `SIGKILL`, no handler runs. A watchdog, a `sh` that reads a pipe from the test process, then gets end of file and kills Chrome with `SIGKILL` at once. Chrome also runs with `--remote-debugging-pipe` next to the port, so it shuts itself down when that pipe closes, but its shutdown can take seconds. Only the profile stays behind;
+- when the test process dies of `SIGKILL`, no handler runs. A watchdog, a `sh` that reads a pipe from the test process, then gets end of file and kills Chrome with `SIGKILL` at once. Chrome also shuts itself down when the CDP pipe closes, but that can take seconds. Only the profile stays behind;
 - the first `launch()` in a process removes every `slicc-harness-*` directory in `$TMPDIR` that is older than a day, or older than a minute and no running process uses as its `--user-data-dir`. It never kills a process.
 
 ## Crash dumps

package/harness/cdp.mjs

@@ -17,12 +17,42 @@ function grace(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms, 'socket closed').unref());
 }
 
-export async function connect(url, { exited, tail = () => [] } = {}) {
+async function websocket(url) {
   const socket = new WebSocket(url);
   await new Promise((resolve, reject) => {
     socket.onopen = resolve;
     socket.onerror = reject;
   });
+  return {
+    send: (text) => socket.send(text),
+    close: () => socket.close(),
+    listen(message, closed) {
+      socket.onmessage = ({ data }) => message(data);
+      socket.onclose = closed;
+    },
+  };
+}
+
+export function pipe(input, output) {
+  input.on('error', () => null);
+  return {
+    send: (text) => input.write(`${text}\0`),
+    close: () => input.end(),
+    listen(message, closed) {
+      let partial = '';
+      output.setEncoding('utf8');
+      output.on('data', (chunk) => {
+        const parts = `${partial}${chunk}`.split('\0');
+        partial = parts.pop();
+        for (const part of parts) message(part);
+      });
+      output.once('close', closed);
+    },
+  };
+}
+
+export async function connect(url, { exited, tail = () => [] } = {}) {
+  const socket = typeof url?.listen === 'function' ? url : await websocket(url);
   const pending = new Map();
   const listeners = new Set();
   const targets = new Map();
@@ -79,16 +109,18 @@ export async function connect(url, { exited, tail = () => [] } = {}) {
     gone = reason;
     drop(() => true, told(reason), fatal);
   };
-  socket.onmessage = ({ data }) => {
-    const message = JSON.parse(data);
-    track(message);
-    const call = pending.get(message.id);
-    pending.delete(message.id);
-    if (!call) notify(message);
-    else if (message.error) call.reject(new Error(`${call.method}: ${message.error.message}`));
-    else call.resolve(message.result);
-  };
-  socket.onclose = async () => die(await Promise.race([exited ?? 'socket closed', grace(2000)]));
+  socket.listen(
+    (data) => {
+      const message = JSON.parse(data);
+      track(message);
+      const call = pending.get(message.id);
+      pending.delete(message.id);
+      if (!call) notify(message);
+      else if (message.error) call.reject(new Error(`${call.method}: ${message.error.message}`));
+      else call.resolve(message.result);
+    },
+    async () => die(await Promise.race([exited ?? 'socket closed', grace(2000)]))
+  );
   void exited?.then(die);
   return {
     send: (method, params = {}, sessionId, ms = SEND_TIMEOUT) =>

package/harness/chrome.mjs

@@ -7,9 +7,9 @@ import { env as inherited } from 'node:process';
 import { promisify } from 'node:util';
 import { chromium } from 'playwright-core';
 import { cdn } from './cdn.mjs';
-import { CRASHED, connect } from './cdp.mjs';
+import { CRASHED, connect, pipe } from './cdp.mjs';
 import { crashpad } from './dumps.mjs';
-import { extensionSource, unpacked } from './extensions.mjs';
+import { extensionSource, install, unpacked } from './extensions.mjs';
 import { page } from './page.mjs';
 import { breakpoints, recorder } from './recorder.mjs';
 import { serve } from './server.mjs';
@@ -35,9 +35,7 @@ export const flags = [
 export function commandLine(profile, extensions = [], extra = []) {
   const loaded = extensions.length > 0;
   const base = loaded ? flags.filter((flag) => flag !== '--disable-extensions') : flags;
-  const load = loaded
-    ? [`--disable-extensions-except=${extensions}`, `--load-extension=${extensions}`]
-    : [];
+  const load = loaded ? ['--enable-unsafe-extension-debugging'] : [];
   return [...base, ...load, ...extra, `--user-data-dir=${profile}`, 'about:blank'];
 }
 
@@ -105,15 +103,17 @@ export function died(child) {
   return (child.exitCode ?? 0) !== 0;
 }
 
-export async function stop(cdp, child) {
+export const WAITS = { close: 10000, exit: 10000, kill: 5000 };
+
+export async function stop(cdp, child, waits = WAITS) {
+  const gone = () => child.exitCode !== null || child.signalCode !== null;
   const exited = new Promise((resolve) => child.once('exit', resolve));
-  await bounded(cdp.send('Browser.close').catch(ignore), 'Browser.close');
+  await bounded(cdp.send('Browser.close').catch(ignore), 'Browser.close', waits.close);
   cdp.close();
-  const running = child.exitCode === null && child.signalCode === null;
-  if (running && (await bounded(exited, 'exit')) === TIMED_OUT) {
-    child.kill('SIGKILL');
-    await exited;
-  }
+  if (gone() || (await bounded(exited, 'exit', waits.exit)) !== TIMED_OUT || gone()) return;
+  child.kill('SIGKILL');
+  if (gone() || (await bounded(exited, 'exit after SIGKILL', waits.kill)) !== TIMED_OUT) return;
+  if (!gone()) console.warn(`chrome: pid ${child.pid} still runs after SIGKILL, moving on`);
 }
 
 export const PREFIX = 'slicc-harness-';
@@ -221,14 +221,14 @@ export async function launch({
   const profile = await mkdtemp(join(tmpdir(), PREFIX));
   const loaded = [...found.values()].map((root) => root.slice(0, -1));
   const dumps = await crashpad();
-  const { child, url, exited, stderr } = await start(
+  const { child, exited, stderr } = await start(
     profile,
     commandLine(profile, loaded, args),
     chromium.executablePath(),
     dumps.env
   );
   const untrack = track(child, [profile, dumps.dir]);
-  const cdp = await connect(url, {
+  const cdp = await connect(pipe(child.stdio[3], child.stdio[4]), {
     exited,
     tail: () => stderr.tail().map((line) => `stderr: ${line}`),
   });
@@ -246,6 +246,7 @@ export async function launch({
     waitForDebuggerOnStart: true,
     flatten: true,
   });
+  await install(cdp, found);
 
   async function tabs() {
     const { targetInfos } = await cdp.send('Target.getTargets');

package/harness/extensions.mjs

@@ -26,3 +26,10 @@ export function extensionSource(found) {
     return root ? join(root, normalize(decodeURIComponent(pathname))) : null;
   };
 }
+
+export async function install(cdp, found) {
+  for (const [expected, root] of [...found]) {
+    const { id } = await cdp.send('Extensions.loadUnpacked', { path: root.slice(0, -1) });
+    if (id !== expected) found.set(id, root);
+  }
+}

package/harness/recorder.mjs

@@ -125,6 +125,7 @@ export function recorder(cdp, server, { coverage = ['/'], exits = new Map() } =
   const pauses = new Map();
   const parents = new Map();
   const tabs = new Map();
+  const early = [];
   const ours = covered(server, coverage);
   let run = null;
 
@@ -204,8 +205,8 @@ export function recorder(cdp, server, { coverage = ['/'], exits = new Map() } =
 
   function log(sessionId, line) {
     const target = sessions.get(sessionId);
-    if (!run || target?.browserContextId !== run.context) return;
-    run.console.push(`${label(target)}: ${line}`);
+    const into = run ? target?.browserContextId === run.context && run.console : target && early;
+    if (into) into.push(`${label(target)}: ${line}`);
   }
 
   async function capture(sessionId, target) {
@@ -274,7 +275,7 @@ export function recorder(cdp, server, { coverage = ['/'], exits = new Map() } =
   }
 
   function begin(context, dir, name) {
-    run = { context, dir, name, scripts: [], console: [], profiles: 0, self: {} };
+    run = { context, dir, name, scripts: [], console: early.splice(0), profiles: 0, self: {} };
   }
 
   async function end() {

package/harness/server.mjs

@@ -78,6 +78,10 @@ export async function serve({
     locate,
     source: (href) =>
       href.startsWith(url) ? lookup(decodeURIComponent(new URL(href).pathname)) : null,
-    close: () => new Promise((done) => server.close(done)),
+    close: () =>
+      new Promise((done) => {
+        server.close(done);
+        server.closeAllConnections();
+      }),
   };
 }

package/harness/util.mjs

@@ -19,7 +19,11 @@ export function sleep(ms) {
 }
 
 export async function bounded(promise, label, ms = 10000) {
-  const result = await Promise.race([promise, sleep(ms).then(() => TIMED_OUT)]);
+  let timer;
+  const expired = new Promise((resolve) => {
+    timer = setTimeout(resolve, ms, TIMED_OUT);
+  });
+  const result = await Promise.race([promise, expired]).finally(() => clearTimeout(timer));
   if (result === TIMED_OUT) console.warn(`chrome: ${label} took over ${ms} ms, moving on`);
   return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-shared-web",
-  "version": "1.10.1",
+  "version": "1.10.2",
   "description": "Shared Renovate, Biome, TypeScript, lefthook and GitHub Actions configuration, plus the CDP integration-test harness, for SLICC's web repos",
   "type": "module",
   "license": "Apache-2.0",