@coffre/conformance 0.1.16 → 0.1.18

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/main.js CHANGED
@@ -1,12 +1,12 @@
1
1
  import { n as DevIdp, o as defaultGitHubAccount, r as GITHUB_RUN } from "./idp-BeOsuZ3p.js";
2
2
  import { createRequire } from "node:module";
3
- import { dirname, join, resolve } from "node:path";
3
+ import { delimiter, dirname, join, resolve } from "node:path";
4
4
  import { inspect, parseArgs } from "node:util";
5
5
  import { spawn } from "node:child_process";
6
6
  import { createHash, createHmac, createPrivateKey, hkdfSync, randomBytes, randomUUID, sign } from "node:crypto";
7
- import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
8
- import { tmpdir } from "node:os";
9
- import { setTimeout } from "node:timers/promises";
7
+ import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "node:fs";
8
+ import { homedir, tmpdir } from "node:os";
9
+ import { setTimeout as setTimeout$1 } from "node:timers/promises";
10
10
  import { DatabaseSync } from "node:sqlite";
11
11
  import pg from "pg";
12
12
  import { postgresConnection } from "@coffre/db/connect";
@@ -244,7 +244,7 @@ async function until(what, probe, seconds, alive = () => true) {
244
244
  for (let i = 0; i < seconds * 10; i++) {
245
245
  if (!alive()) throw new Failure(`a process exited while waiting for ${what}`);
246
246
  if (await probe().catch(() => false)) return;
247
- await setTimeout(100);
247
+ await setTimeout$1(100);
248
248
  }
249
249
  throw new Failure(`timed out waiting for ${what}`);
250
250
  }
@@ -305,6 +305,23 @@ var Report = class {
305
305
  //#endregion
306
306
  //#region src/harness.ts
307
307
  const ROOT_ADMIN = "root@conformance.example";
308
+ /**
309
+ * The CLI the deployment pins, as its pipeline runs it: `pnpm exec coffre`,
310
+ * found from its folder, so only as one of its own packages. Its entry is
311
+ * run with Node, so that it needs no bin linked, as a workspace links none
312
+ * before its build.
313
+ */
314
+ function deploymentCli(dir) {
315
+ let manifest;
316
+ try {
317
+ manifest = createRequire(join(dir, "package.json")).resolve("@coffre/cli/package.json");
318
+ } catch {
319
+ throw new Failure(`${dir} has no @coffre/cli of its own: pin it among its devDependencies, as coffre init does, and install`);
320
+ }
321
+ const bin = JSON.parse(readFileSync(manifest, "utf8")).bin?.coffre;
322
+ if (bin === void 0) throw new Failure(`${manifest} names no coffre bin`);
323
+ return join(dirname(manifest), bin);
324
+ }
308
325
  async function boot(kind, at, options) {
309
326
  const { port } = options;
310
327
  const dir = resolve(at);
@@ -352,8 +369,8 @@ async function boot(kind, at, options) {
352
369
  children.push(entry);
353
370
  return entry;
354
371
  }
355
- async function run(command, args) {
356
- const entry = start(args[0] ?? command, command, args, {}, false);
372
+ async function run(command, args, env = {}) {
373
+ const entry = start(args[0] ?? command, command, args, env, false);
357
374
  if (await new Promise((done) => {
358
375
  entry.child.once("exit", done);
359
376
  entry.child.once("error", done);
@@ -379,7 +396,7 @@ async function boot(kind, at, options) {
379
396
  for (const { child, exited } of children) if (!exited) try {
380
397
  process.kill(-child.pid, signal);
381
398
  } catch {}
382
- await setTimeout(500);
399
+ await setTimeout$1(500);
383
400
  }
384
401
  await idp.stop().catch(() => {});
385
402
  await cleanup().catch(() => {});
@@ -405,7 +422,11 @@ async function boot(kind, at, options) {
405
422
  const vaultRuntime = withDatabase(options.vaultRuntime, name);
406
423
  await using(postgres(withDatabase(options.postgres, "postgres")), (sql) => sql.exec(`CREATE DATABASE ${name}`));
407
424
  cleanup = () => using(postgres(withDatabase(options.postgres, "postgres")), (sql) => sql.exec(`DROP DATABASE IF EXISTS ${name} WITH (FORCE)`));
408
- await run(bin("coffre-server"), ["migrate", owner]);
425
+ await run(process.execPath, [
426
+ deploymentCli(dir),
427
+ "migrate",
428
+ "--yes"
429
+ ], { COFFRE_MIGRATE_DATABASE_URL: owner });
409
430
  const state = join(scratch, "state");
410
431
  start("wrangler", bin("wrangler"), [
411
432
  "dev",
@@ -523,6 +544,10 @@ var Browser = class {
523
544
  constructor(origin) {
524
545
  this.origin = origin;
525
546
  }
547
+ /** The cookies coffre left this browser, to hand a real one. */
548
+ cookies() {
549
+ return [...this.#jar];
550
+ }
526
551
  /** Whether coffre left this browser a cookie. */
527
552
  get hasCookies() {
528
553
  return this.#jar.size > 0;
@@ -2131,7 +2156,7 @@ var Cli = class {
2131
2156
  child.kill("SIGKILL");
2132
2157
  throw new Failure(`coffre never got to ${what}`, output);
2133
2158
  }
2134
- await setTimeout(50);
2159
+ await setTimeout$1(50);
2135
2160
  }
2136
2161
  return pattern.exec(output);
2137
2162
  }
@@ -2342,6 +2367,200 @@ async function verifyKeys(cli) {
2342
2367
  return "this deployment's keys pass, vault ID included; a wrong vault key and a malformed app key are each named; no key shown";
2343
2368
  }
2344
2369
  //#endregion
2370
+ //#region src/chrome.ts
2371
+ const NAMES = [
2372
+ "google-chrome",
2373
+ "google-chrome-stable",
2374
+ "chromium",
2375
+ "chromium-browser",
2376
+ "chrome"
2377
+ ];
2378
+ const MAC = ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome", "/Applications/Chromium.app/Contents/MacOS/Chromium"];
2379
+ /** A Chrome or Chromium on this machine: on PATH, where macOS keeps it, or Playwright's. */
2380
+ function findChrome() {
2381
+ for (const dir of (process.env.PATH ?? "").split(delimiter)) for (const name of NAMES) if (dir !== "" && existsSync(join(dir, name))) return join(dir, name);
2382
+ for (const path of MAC) if (existsSync(path)) return path;
2383
+ const playwright = join(homedir(), ".cache", "ms-playwright");
2384
+ if (existsSync(playwright)) for (const dir of readdirSync(playwright).filter((name) => name.startsWith("chromium-")).sort().reverse()) for (const build of ["chrome-linux64", "chrome-linux"]) {
2385
+ const path = join(playwright, dir, build, "chrome");
2386
+ if (existsSync(path)) return path;
2387
+ }
2388
+ return null;
2389
+ }
2390
+ var Chrome = class Chrome {
2391
+ #process;
2392
+ #socket;
2393
+ #profile;
2394
+ #next = 0;
2395
+ #pending = /* @__PURE__ */ new Map();
2396
+ #listeners = /* @__PURE__ */ new Set();
2397
+ constructor(process, socket, profile) {
2398
+ this.#process = process;
2399
+ this.#socket = socket;
2400
+ this.#profile = profile;
2401
+ socket.addEventListener("message", (event) => {
2402
+ const message = JSON.parse(String(event.data));
2403
+ if (message.id !== void 0) {
2404
+ const pending = this.#pending.get(message.id);
2405
+ this.#pending.delete(message.id);
2406
+ if (message.error !== void 0) pending?.reject(new Error(message.error.message));
2407
+ else pending?.resolve(message.result ?? {});
2408
+ } else for (const listener of this.#listeners) listener(message);
2409
+ });
2410
+ }
2411
+ /** Chrome at `executable`, headless, with a profile of its own, gone when closed. */
2412
+ static async open(executable) {
2413
+ const profile = mkdtempSync(join(tmpdir(), "coffre-chrome-"));
2414
+ const child = spawn(executable, [
2415
+ "--headless=new",
2416
+ "--remote-debugging-port=0",
2417
+ `--user-data-dir=${profile}`,
2418
+ "--no-first-run",
2419
+ "--no-default-browser-check",
2420
+ "--disable-gpu",
2421
+ "--no-sandbox",
2422
+ "about:blank"
2423
+ ], { stdio: [
2424
+ "ignore",
2425
+ "ignore",
2426
+ "pipe"
2427
+ ] });
2428
+ const url = await new Promise((resolve, reject) => {
2429
+ let output = "";
2430
+ const timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Chrome did not start: ${output.trim().split("\n").slice(-3).join(" ")}`)), 3e4);
2431
+ child.stderr.setEncoding("utf8").on("data", (chunk) => {
2432
+ output += chunk;
2433
+ const found = /DevTools listening on (ws:\/\/\S+)/.exec(output);
2434
+ if (found !== null) {
2435
+ clearTimeout(timer);
2436
+ resolve(found[1]);
2437
+ }
2438
+ });
2439
+ child.on("error", (error) => {
2440
+ clearTimeout(timer);
2441
+ reject(error);
2442
+ });
2443
+ child.on("exit", (code) => {
2444
+ clearTimeout(timer);
2445
+ reject(/* @__PURE__ */ new Error(`Chrome exited with ${code}: ${output.trim().split("\n").slice(-3).join(" ")}`));
2446
+ });
2447
+ });
2448
+ const socket = new WebSocket(url);
2449
+ await new Promise((resolve, reject) => {
2450
+ socket.addEventListener("open", () => resolve(), { once: true });
2451
+ socket.addEventListener("error", () => reject(/* @__PURE__ */ new Error(`could not reach Chrome at ${url}`)), { once: true });
2452
+ });
2453
+ return new Chrome(child, socket, profile);
2454
+ }
2455
+ #send(method, params = {}, sessionId) {
2456
+ const id = ++this.#next;
2457
+ return new Promise((resolve, reject) => {
2458
+ this.#pending.set(id, {
2459
+ resolve,
2460
+ reject
2461
+ });
2462
+ this.#socket.send(JSON.stringify({
2463
+ id,
2464
+ method,
2465
+ params,
2466
+ sessionId
2467
+ }));
2468
+ });
2469
+ }
2470
+ /**
2471
+ * `url` in a tab of its own, with `cookies` for its origin: the heading it
2472
+ * shows once its scripts have run and settled, and every uncaught error,
2473
+ * console error and failed load along the way.
2474
+ */
2475
+ async load(url, cookies, settle = 2e3) {
2476
+ const { targetId } = await this.#send("Target.createTarget", { url: "about:blank" });
2477
+ const { sessionId } = await this.#send("Target.attachToTarget", {
2478
+ targetId,
2479
+ flatten: true
2480
+ });
2481
+ const errors = [];
2482
+ let loaded;
2483
+ const load = new Promise((resolve) => loaded = resolve);
2484
+ const listener = (message) => {
2485
+ if (message.sessionId !== sessionId) return;
2486
+ const params = message.params ?? {};
2487
+ if (message.method === "Runtime.exceptionThrown") {
2488
+ const details = params.exceptionDetails;
2489
+ errors.push(`${details.exception?.description?.split("\n")[0] ?? details.text}${details.url ? ` (${details.url}:${(details.lineNumber ?? 0) + 1})` : ""}`);
2490
+ } else if (message.method === "Runtime.consoleAPICalled" && params.type === "error") {
2491
+ const args = params.args;
2492
+ errors.push(`console.error: ${args.map((arg) => arg.description ?? String(arg.value)).join(" ")}`);
2493
+ } else if (message.method === "Log.entryAdded") {
2494
+ const entry = params.entry;
2495
+ if (entry.level === "error") errors.push(`${entry.text}${entry.url ? ` (${entry.url})` : ""}`);
2496
+ } else if (message.method === "Page.loadEventFired") loaded();
2497
+ };
2498
+ this.#listeners.add(listener);
2499
+ try {
2500
+ for (const domain of [
2501
+ "Runtime",
2502
+ "Log",
2503
+ "Page",
2504
+ "Network"
2505
+ ]) await this.#send(`${domain}.enable`, {}, sessionId);
2506
+ for (const [name, value] of cookies) await this.#send("Network.setCookie", {
2507
+ name,
2508
+ value,
2509
+ url
2510
+ }, sessionId);
2511
+ await this.#send("Page.navigate", { url }, sessionId);
2512
+ await Promise.race([load, new Promise((resolve) => setTimeout(resolve, 3e4))]);
2513
+ await new Promise((resolve) => setTimeout(resolve, settle));
2514
+ const { result } = await this.#send("Runtime.evaluate", {
2515
+ expression: "document.querySelector('h1')?.textContent?.trim() || null",
2516
+ returnByValue: true
2517
+ }, sessionId);
2518
+ return {
2519
+ heading: result.value,
2520
+ errors
2521
+ };
2522
+ } finally {
2523
+ this.#listeners.delete(listener);
2524
+ await this.#send("Target.closeTarget", { targetId }).catch(() => {});
2525
+ }
2526
+ }
2527
+ async close() {
2528
+ await this.#send("Browser.close").catch(() => {});
2529
+ this.#socket.close();
2530
+ if (this.#process.exitCode === null) {
2531
+ await Promise.race([new Promise((resolve) => this.#process.once("exit", resolve)), new Promise((resolve) => setTimeout(resolve, 5e3))]);
2532
+ this.#process.kill("SIGKILL");
2533
+ }
2534
+ rmSync(this.#profile, {
2535
+ recursive: true,
2536
+ force: true
2537
+ });
2538
+ }
2539
+ };
2540
+ //#endregion
2541
+ //#region src/checks/pages.ts
2542
+ /** Each page, and the heading it shows. */
2543
+ const PAGES = [
2544
+ ["/projects", "Projects"],
2545
+ [`/projects/${PROJECT}`, "Conformance"],
2546
+ ["/audit", "Audit"]
2547
+ ];
2548
+ async function pagesInBrowser(deployment, admin, browser) {
2549
+ const executable = browser ?? findChrome();
2550
+ if (executable === null) throw new Skip("no Chrome or Chromium here: --browser <path> names one");
2551
+ const chrome = await Chrome.open(executable);
2552
+ try {
2553
+ for (const [path, heading] of PAGES) {
2554
+ const loaded = await chrome.load(new URL(path, deployment.origin).href, admin.browser.cookies());
2555
+ expect(loaded.errors.length === 0, `${path}, signed in, reported errors in the browser`, loaded.errors.join("\n"));
2556
+ expect(loaded.heading?.startsWith(heading), `${path}, signed in, shows ${JSON.stringify(loaded.heading)}, not the heading ${JSON.stringify(heading)}`);
2557
+ }
2558
+ } finally {
2559
+ await chrome.close();
2560
+ }
2561
+ return `${PAGES.map(([path]) => path).join(", ")}, signed in, in Chrome: each rendered, no error from their scripts`;
2562
+ }
2563
+ //#endregion
2345
2564
  //#region src/checks/surface.ts
2346
2565
  async function health(deployment) {
2347
2566
  const { origin } = deployment;
@@ -2611,6 +2830,10 @@ async function conform(deployment, options) {
2611
2830
  const admin = await report.check("sign-in", {}, () => signInAdmin(deployment));
2612
2831
  await report.check("page load", { admin }, ({ admin }) => pageLoad(admin));
2613
2832
  const canaries = await report.check("setup", { admin }, ({ admin }) => setUp(admin));
2833
+ await report.check("pages in a browser", {
2834
+ admin,
2835
+ canaries
2836
+ }, ({ admin }) => pagesInBrowser(deployment, admin, options.browser));
2614
2837
  const people = await report.check("personas", {
2615
2838
  admin,
2616
2839
  canaries
@@ -2730,6 +2953,8 @@ const USAGE = `usage:
2730
2953
  <dir> the deployment, as \`coffre init\` wrote it (default: here)
2731
2954
  --port <n> coffre's port; the IdP gets the next, wrangler's inspector the one after (3082)
2732
2955
  --bulk-limit <n> the vault's bulkLimit count, when not the default (1000)
2956
+ --browser <path> Chrome or Chromium, to load the pages in (default: one found here;
2957
+ without one, that check is skipped)
2733
2958
  --postgres <url> workers: a Postgres login that may create databases; one is made for the run
2734
2959
  --runtime <url> workers: the same server as coffre_runtime, the login the app runs as
2735
2960
  --vault-runtime <url>
@@ -2748,6 +2973,7 @@ const { values, positionals } = parseArgs({
2748
2973
  type: "string",
2749
2974
  default: "1000"
2750
2975
  },
2976
+ browser: { type: "string" },
2751
2977
  postgres: { type: "string" },
2752
2978
  runtime: { type: "string" },
2753
2979
  "vault-runtime": { type: "string" },
@@ -2782,7 +3008,10 @@ try {
2782
3008
  console.log(` up on ${deployment.origin}`);
2783
3009
  let failed;
2784
3010
  try {
2785
- failed = await conform(deployment, { bulkLimit });
3011
+ failed = await conform(deployment, {
3012
+ bulkLimit,
3013
+ browser: values.browser || null
3014
+ });
2786
3015
  if (failed.length > 0) console.error(`\nThe processes' output, last lines:\n${deployment.output(4e3)}`);
2787
3016
  } finally {
2788
3017
  await deployment.stop();
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@coffre/conformance",
3
- "version": "0.1.16",
3
+ "version": "0.1.18",
4
4
  "description": "Checks a coffre deployment from outside: what it must never do, whatever code it runs.",
5
5
  "license": "MIT",
6
6
  "repository": {
@@ -31,8 +31,8 @@
31
31
  "dependencies": {
32
32
  "jose": "6.2.3",
33
33
  "pg": "8.16.3",
34
- "@coffre/cli": "0.1.16",
35
- "@coffre/db": "0.1.16"
34
+ "@coffre/cli": "0.1.18",
35
+ "@coffre/db": "0.1.18"
36
36
  },
37
37
  "devDependencies": {
38
38
  "@types/node": "26.1.1",
@@ -40,7 +40,7 @@
40
40
  "oauth4webapi": "3.8.8",
41
41
  "tsdown": "0.23.0",
42
42
  "typescript": "5.9.3",
43
- "@coffre/client": "0.1.16"
43
+ "@coffre/client": "0.1.18"
44
44
  },
45
45
  "scripts": {
46
46
  "build": "tsdown",
package/src/browser.ts CHANGED
@@ -10,6 +10,11 @@ export class Browser {
10
10
  this.origin = origin;
11
11
  }
12
12
 
13
+ /** The cookies coffre left this browser, to hand a real one. */
14
+ cookies(): [string, string][] {
15
+ return [...this.#jar];
16
+ }
17
+
13
18
  /** Whether coffre left this browser a cookie. */
14
19
  get hasCookies(): boolean {
15
20
  return this.#jar.size > 0;
@@ -0,0 +1,33 @@
1
+ // coffre's pages in a real browser, signed in: each renders its heading,
2
+ // and its scripts run without an error. What a bundler does to the code a
3
+ // page receives shows only there: wrangler's keep_names once wrapped the
4
+ // functions seroval writes into a page in an `__name` that only the Worker
5
+ // had, and a signed-in page rendered, then went blank.
6
+ import { Chrome, findChrome } from '../chrome.ts';
7
+ import type { Deployment } from '../harness.ts';
8
+ import { expect, Skip } from '../report.ts';
9
+ import { type Person, PROJECT } from './people.ts';
10
+
11
+ /** Each page, and the heading it shows. */
12
+ const PAGES = [
13
+ ['/projects', 'Projects'],
14
+ [`/projects/${PROJECT}`, 'Conformance'],
15
+ ['/audit', 'Audit'],
16
+ ] as const;
17
+
18
+ export async function pagesInBrowser(deployment: Deployment, admin: Person, browser: string | null): Promise<string> {
19
+ const executable = browser ?? findChrome();
20
+ if (executable === null) throw new Skip('no Chrome or Chromium here: --browser <path> names one');
21
+ const chrome = await Chrome.open(executable);
22
+ try {
23
+ for (const [path, heading] of PAGES) {
24
+ const loaded = await chrome.load(new URL(path, deployment.origin).href, admin.browser.cookies());
25
+ expect(loaded.errors.length === 0, `${path}, signed in, reported errors in the browser`, loaded.errors.join('\n'));
26
+ // The heading, then what may follow it in the h1, such as a project's slug.
27
+ expect(loaded.heading?.startsWith(heading), `${path}, signed in, shows ${JSON.stringify(loaded.heading)}, not the heading ${JSON.stringify(heading)}`);
28
+ }
29
+ } finally {
30
+ await chrome.close();
31
+ }
32
+ return `${PAGES.map(([path]) => path).join(', ')}, signed in, in Chrome: each rendered, no error from their scripts`;
33
+ }
package/src/chrome.ts ADDED
@@ -0,0 +1,171 @@
1
+ // A real browser, for what only one shows: coffre's pages as they render
2
+ // and hydrate, their scripts run. Headless Chrome, driven over the DevTools
3
+ // protocol with Node's own WebSocket, so that conformance depends on no
4
+ // browser package; the machine's Chrome or Chromium does.
5
+ import { spawn, type ChildProcess } from 'node:child_process';
6
+ import { existsSync, mkdtempSync, readdirSync, rmSync } from 'node:fs';
7
+ import { homedir, tmpdir } from 'node:os';
8
+ import { delimiter, join } from 'node:path';
9
+
10
+ /** What a page did, loaded: the heading it shows, and every error its scripts and console reported. */
11
+ export type Loaded = { heading: string | null; errors: string[] };
12
+
13
+ const NAMES = ['google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser', 'chrome'];
14
+ const MAC = ['/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', '/Applications/Chromium.app/Contents/MacOS/Chromium'];
15
+
16
+ /** A Chrome or Chromium on this machine: on PATH, where macOS keeps it, or Playwright's. */
17
+ export function findChrome(): string | null {
18
+ for (const dir of (process.env.PATH ?? '').split(delimiter)) {
19
+ for (const name of NAMES) if (dir !== '' && existsSync(join(dir, name))) return join(dir, name);
20
+ }
21
+ for (const path of MAC) if (existsSync(path)) return path;
22
+ const playwright = join(homedir(), '.cache', 'ms-playwright');
23
+ if (existsSync(playwright)) {
24
+ for (const dir of readdirSync(playwright).filter((name) => name.startsWith('chromium-')).sort().reverse()) {
25
+ for (const build of ['chrome-linux64', 'chrome-linux']) {
26
+ const path = join(playwright, dir, build, 'chrome');
27
+ if (existsSync(path)) return path;
28
+ }
29
+ }
30
+ }
31
+ return null;
32
+ }
33
+
34
+ type Message = { id?: number; method?: string; params?: Record<string, unknown>; result?: Record<string, unknown>; error?: { message: string }; sessionId?: string };
35
+
36
+ export class Chrome {
37
+ readonly #process: ChildProcess;
38
+ readonly #socket: WebSocket;
39
+ readonly #profile: string;
40
+ #next = 0;
41
+ readonly #pending = new Map<number, { resolve: (result: Record<string, unknown>) => void; reject: (error: Error) => void }>();
42
+ readonly #listeners = new Set<(message: Message) => void>();
43
+
44
+ private constructor(process: ChildProcess, socket: WebSocket, profile: string) {
45
+ this.#process = process;
46
+ this.#socket = socket;
47
+ this.#profile = profile;
48
+ socket.addEventListener('message', (event) => {
49
+ const message = JSON.parse(String(event.data)) as Message;
50
+ if (message.id !== undefined) {
51
+ const pending = this.#pending.get(message.id);
52
+ this.#pending.delete(message.id);
53
+ if (message.error !== undefined) pending?.reject(new Error(message.error.message));
54
+ else pending?.resolve(message.result ?? {});
55
+ } else {
56
+ for (const listener of this.#listeners) listener(message);
57
+ }
58
+ });
59
+ }
60
+
61
+ /** Chrome at `executable`, headless, with a profile of its own, gone when closed. */
62
+ static async open(executable: string): Promise<Chrome> {
63
+ const profile = mkdtempSync(join(tmpdir(), 'coffre-chrome-'));
64
+ const child = spawn(
65
+ executable,
66
+ [
67
+ '--headless=new',
68
+ '--remote-debugging-port=0',
69
+ `--user-data-dir=${profile}`,
70
+ '--no-first-run',
71
+ '--no-default-browser-check',
72
+ '--disable-gpu',
73
+ // Only coffre's own pages are loaded; CI's runners have no user namespaces for Chrome's sandbox.
74
+ '--no-sandbox',
75
+ 'about:blank',
76
+ ],
77
+ { stdio: ['ignore', 'ignore', 'pipe'] },
78
+ );
79
+ const url = await new Promise<string>((resolve, reject) => {
80
+ let output = '';
81
+ const timer = setTimeout(() => reject(new Error(`Chrome did not start: ${output.trim().split('\n').slice(-3).join(' ')}`)), 30_000);
82
+ child.stderr!.setEncoding('utf8').on('data', (chunk: string) => {
83
+ output += chunk;
84
+ const found = /DevTools listening on (ws:\/\/\S+)/.exec(output);
85
+ if (found !== null) {
86
+ clearTimeout(timer);
87
+ resolve(found[1]!);
88
+ }
89
+ });
90
+ child.on('error', (error) => {
91
+ clearTimeout(timer);
92
+ reject(error);
93
+ });
94
+ child.on('exit', (code) => {
95
+ clearTimeout(timer);
96
+ reject(new Error(`Chrome exited with ${code}: ${output.trim().split('\n').slice(-3).join(' ')}`));
97
+ });
98
+ });
99
+ const socket = new WebSocket(url);
100
+ await new Promise<void>((resolve, reject) => {
101
+ socket.addEventListener('open', () => resolve(), { once: true });
102
+ socket.addEventListener('error', () => reject(new Error(`could not reach Chrome at ${url}`)), { once: true });
103
+ });
104
+ return new Chrome(child, socket, profile);
105
+ }
106
+
107
+ #send(method: string, params: Record<string, unknown> = {}, sessionId?: string): Promise<Record<string, unknown>> {
108
+ const id = ++this.#next;
109
+ return new Promise((resolve, reject) => {
110
+ this.#pending.set(id, { resolve, reject });
111
+ this.#socket.send(JSON.stringify({ id, method, params, sessionId }));
112
+ });
113
+ }
114
+
115
+ /**
116
+ * `url` in a tab of its own, with `cookies` for its origin: the heading it
117
+ * shows once its scripts have run and settled, and every uncaught error,
118
+ * console error and failed load along the way.
119
+ */
120
+ async load(url: string, cookies: [string, string][], settle = 2_000): Promise<Loaded> {
121
+ const { targetId } = (await this.#send('Target.createTarget', { url: 'about:blank' })) as { targetId: string };
122
+ const { sessionId } = (await this.#send('Target.attachToTarget', { targetId, flatten: true })) as { sessionId: string };
123
+ const errors: string[] = [];
124
+ let loaded!: () => void;
125
+ const load = new Promise<void>((resolve) => (loaded = resolve));
126
+ const listener = (message: Message) => {
127
+ if (message.sessionId !== sessionId) return;
128
+ const params = message.params ?? {};
129
+ if (message.method === 'Runtime.exceptionThrown') {
130
+ const details = params.exceptionDetails as { text: string; exception?: { description?: string }; url?: string; lineNumber?: number };
131
+ errors.push(`${details.exception?.description?.split('\n')[0] ?? details.text}${details.url ? ` (${details.url}:${(details.lineNumber ?? 0) + 1})` : ''}`);
132
+ } else if (message.method === 'Runtime.consoleAPICalled' && params.type === 'error') {
133
+ const args = params.args as { value?: unknown; description?: string }[];
134
+ errors.push(`console.error: ${args.map((arg) => arg.description ?? String(arg.value)).join(' ')}`);
135
+ } else if (message.method === 'Log.entryAdded') {
136
+ const entry = params.entry as { level: string; text: string; url?: string };
137
+ if (entry.level === 'error') errors.push(`${entry.text}${entry.url ? ` (${entry.url})` : ''}`);
138
+ } else if (message.method === 'Page.loadEventFired') {
139
+ loaded();
140
+ }
141
+ };
142
+ this.#listeners.add(listener);
143
+ try {
144
+ for (const domain of ['Runtime', 'Log', 'Page', 'Network']) await this.#send(`${domain}.enable`, {}, sessionId);
145
+ for (const [name, value] of cookies) await this.#send('Network.setCookie', { name, value, url }, sessionId);
146
+ await this.#send('Page.navigate', { url }, sessionId);
147
+ await Promise.race([load, new Promise((resolve) => setTimeout(resolve, 30_000))]);
148
+ // What streams in after the load, and hydration, have their time: the page may render, then fail.
149
+ await new Promise((resolve) => setTimeout(resolve, settle));
150
+ const { result } = (await this.#send(
151
+ 'Runtime.evaluate',
152
+ { expression: "document.querySelector('h1')?.textContent?.trim() || null", returnByValue: true },
153
+ sessionId,
154
+ )) as { result: { value: string | null } };
155
+ return { heading: result.value, errors };
156
+ } finally {
157
+ this.#listeners.delete(listener);
158
+ await this.#send('Target.closeTarget', { targetId }).catch(() => {});
159
+ }
160
+ }
161
+
162
+ async close(): Promise<void> {
163
+ await this.#send('Browser.close').catch(() => {});
164
+ this.#socket.close();
165
+ if (this.#process.exitCode === null) {
166
+ await Promise.race([new Promise((resolve) => this.#process.once('exit', resolve)), new Promise((resolve) => setTimeout(resolve, 5_000))]);
167
+ this.#process.kill('SIGKILL');
168
+ }
169
+ rmSync(this.#profile, { recursive: true, force: true });
170
+ }
171
+ }
package/src/harness.ts CHANGED
@@ -12,9 +12,10 @@
12
12
  // one after.
13
13
  import { spawn, type ChildProcess } from 'node:child_process';
14
14
  import { randomBytes } from 'node:crypto';
15
- import { existsSync, mkdtempSync, rmSync } from 'node:fs';
15
+ import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
16
+ import { createRequire } from 'node:module';
16
17
  import { tmpdir } from 'node:os';
17
- import { join, resolve } from 'node:path';
18
+ import { dirname, join, resolve } from 'node:path';
18
19
  import { setTimeout as sleep } from 'node:timers/promises';
19
20
 
20
21
  import { postgres, sqlite, using, type Sql } from './database.ts';
@@ -61,6 +62,24 @@ const ROOT_ADMIN = 'root@conformance.example';
61
62
 
62
63
  type Child = { name: string; child: ChildProcess; daemon: boolean; exited: boolean; output: Buffer[] };
63
64
 
65
+ /**
66
+ * The CLI the deployment pins, as its pipeline runs it: `pnpm exec coffre`,
67
+ * found from its folder, so only as one of its own packages. Its entry is
68
+ * run with Node, so that it needs no bin linked, as a workspace links none
69
+ * before its build.
70
+ */
71
+ function deploymentCli(dir: string): string {
72
+ let manifest: string;
73
+ try {
74
+ manifest = createRequire(join(dir, 'package.json')).resolve('@coffre/cli/package.json');
75
+ } catch {
76
+ throw new Failure(`${dir} has no @coffre/cli of its own: pin it among its devDependencies, as coffre init does, and install`);
77
+ }
78
+ const bin = (JSON.parse(readFileSync(manifest, 'utf8')) as { bin?: Record<string, string> }).bin?.coffre;
79
+ if (bin === undefined) throw new Failure(`${manifest} names no coffre bin`);
80
+ return join(dirname(manifest), bin);
81
+ }
82
+
64
83
  export async function boot(kind: Kind, at: string, options: HarnessOptions): Promise<Deployment> {
65
84
  const { port } = options;
66
85
  const dir = resolve(at);
@@ -109,8 +128,8 @@ export async function boot(kind: Kind, at: string, options: HarnessOptions): Pro
109
128
  return entry;
110
129
  }
111
130
 
112
- async function run(command: string, args: string[]): Promise<void> {
113
- const entry = start(args[0] ?? command, command, args, {}, false);
131
+ async function run(command: string, args: string[], env: Record<string, string> = {}): Promise<void> {
132
+ const entry = start(args[0] ?? command, command, args, env, false);
114
133
  const code = await new Promise((done) => {
115
134
  entry.child.once('exit', done);
116
135
  entry.child.once('error', done);
@@ -175,8 +194,10 @@ export async function boot(kind: Kind, at: string, options: HarnessOptions): Pro
175
194
  using(postgres(withDatabase(options.postgres!, 'postgres')), (sql) =>
176
195
  sql.exec(`DROP DATABASE IF EXISTS ${name} WITH (FORCE)`),
177
196
  );
197
+ // As the deployment's pipeline does before it deploys: its own CLI's
198
+ // `coffre migrate`, in its folder, the owner's URL in its environment.
178
199
  // A fresh log has no heartbeat: only the scheduled job can make /readyz pass.
179
- await run(bin('coffre-server'), ['migrate', owner]);
200
+ await run(process.execPath, [deploymentCli(dir), 'migrate', '--yes'], { COFFRE_MIGRATE_DATABASE_URL: owner });
180
201
  const state = join(scratch, 'state');
181
202
  start('wrangler', bin('wrangler'), [
182
203
  'dev',
package/src/main.ts CHANGED
@@ -17,6 +17,8 @@ const USAGE = `usage:
17
17
  <dir> the deployment, as \`coffre init\` wrote it (default: here)
18
18
  --port <n> coffre's port; the IdP gets the next, wrangler's inspector the one after (3082)
19
19
  --bulk-limit <n> the vault's bulkLimit count, when not the default (1000)
20
+ --browser <path> Chrome or Chromium, to load the pages in (default: one found here;
21
+ without one, that check is skipped)
20
22
  --postgres <url> workers: a Postgres login that may create databases; one is made for the run
21
23
  --runtime <url> workers: the same server as coffre_runtime, the login the app runs as
22
24
  --vault-runtime <url>
@@ -30,6 +32,7 @@ const { values, positionals } = parseArgs({
30
32
  options: {
31
33
  port: { type: 'string', default: '3082' },
32
34
  'bulk-limit': { type: 'string', default: '1000' },
35
+ browser: { type: 'string' },
33
36
  postgres: { type: 'string' },
34
37
  runtime: { type: 'string' },
35
38
  'vault-runtime': { type: 'string' },
@@ -63,7 +66,7 @@ try {
63
66
  console.log(` up on ${deployment.origin}`);
64
67
  let failed: string[];
65
68
  try {
66
- failed = await conform(deployment, { bulkLimit });
69
+ failed = await conform(deployment, { bulkLimit, browser: values.browser || null });
67
70
  if (failed.length > 0) console.error(`\nThe processes' output, last lines:\n${deployment.output(4000)}`);
68
71
  } finally {
69
72
  await deployment.stop();
package/src/suite.ts CHANGED
@@ -13,16 +13,18 @@ import { editedGeneration, forgedCredential, forgedIdentity, forgedApproval } fr
13
13
  import { canaryScan } from './checks/canaries.ts';
14
14
  import { Cli, cliLogin, verifyAsOwner, verifyAsUser, verifyInterrupted, verifyKeys, verifyLeftovers, verifyWithToken } from './checks/cli.ts';
15
15
  import { pageLoad, personas, setUp, setUpLive, signInAdmin } from './checks/people.ts';
16
+ import { pagesInBrowser } from './checks/pages.ts';
16
17
  import { health } from './checks/surface.ts';
17
18
  import { cliSignsIn, exchangesLimited, runSignsIn, runsRefused, runUnbound, spentOnce, tokensUnlogged, trustRun } from './checks/workloads.ts';
18
19
 
19
20
  /** The names of the checks that failed. */
20
- export async function conform(deployment: Deployment, options: { bulkLimit: number }): Promise<string[]> {
21
+ export async function conform(deployment: Deployment, options: { bulkLimit: number; browser: string | null }): Promise<string[]> {
21
22
  const report = new Report();
22
23
  await report.check('health', {}, () => health(deployment));
23
24
  const admin = await report.check('sign-in', {}, () => signInAdmin(deployment));
24
25
  await report.check('page load', { admin }, ({ admin }) => pageLoad(admin));
25
26
  const canaries = await report.check('setup', { admin }, ({ admin }) => setUp(admin));
27
+ await report.check('pages in a browser', { admin, canaries }, ({ admin }) => pagesInBrowser(deployment, admin, options.browser));
26
28
  const people = await report.check('personas', { admin, canaries }, ({ admin }) => personas(deployment, admin));
27
29
  const all = { people, canaries };
28
30