janissary 0.5.0 → 0.5.2

package/scripts/check-diff.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+// Fast diff-scoped checks: lint changed files, typecheck affected projects (incremental),
+// run related tests. Runs concurrently and reports a summary.
+//
+//   npm run check:diff           # concurrent lint + tsc + test
+//   npm run check:diff -- --seq  # sequential (fail-fast) for debugging
+
+import { execFileSync } from 'node:child_process';
+import { changedFiles } from './changed-files.mjs';
+
+const LINTABLE = /\.(?:ts|tsx|js|jsx|mjs|cjs)$/;
+const seq = process.argv.includes('--seq');
+
+const files = changedFiles();
+if (files.length === 0) {
+  console.log('check:diff: no changes');
+  process.exit(0);
+}
+
+// Classify files to decide which checks to run
+const hasLintable = files.some((f) => {
+  const base = f.split('/').pop() ?? f;
+  return !base.includes('.') || LINTABLE.test(f);
+});
+const touchesSrc = files.some((f) => f.startsWith('src/'));
+const touchesWeb = files.some((f) => f.startsWith('web/'));
+
+// Tools to run with timing
+const tools = [];
+
+if (hasLintable) {
+  tools.push({
+    name: 'lint',
+    run: () => execFileSync('node', ['scripts/lint-files.mjs'], { stdio: 'pipe', encoding: 'utf8' }),
+  });
+}
+
+if (touchesSrc || touchesWeb) {
+  tools.push({
+    name: 'tsc',
+    run: () => execFileSync('npm', ['run', 'typecheck:diff'], { stdio: 'pipe', encoding: 'utf8' }),
+  });
+}
+
+if (touchesSrc) {
+  tools.push({
+    name: 'test:server',
+    run: () => execFileSync('npm', ['run', 'test:diff:server'], { stdio: 'pipe', encoding: 'utf8' }),
+  });
+}
+
+if (touchesWeb) {
+  tools.push({
+    name: 'test:web',
+    run: () => execFileSync('npm', ['run', 'test:diff:web'], { stdio: 'pipe', encoding: 'utf8' }),
+  });
+}
+
+// Run tools concurrently or sequentially
+const results = [];
+const startTime = Date.now();
+
+if (seq) {
+  for (const tool of tools) {
+    const start = Date.now();
+    let status = 'pass';
+    try {
+      tool.run();
+    } catch {
+      status = 'fail';
+    }
+    results.push({ ...tool, status, time: Date.now() - start });
+  }
+} else {
+  const promises = tools.map(
+    (tool) =>
+      new Promise((resolve) => {
+        const start = Date.now();
+        let status = 'pass';
+        try {
+          tool.run();
+        } catch {
+          status = 'fail';
+        }
+        resolve({ ...tool, status, time: Date.now() - start });
+      }),
+  );
+  results.push(...(await Promise.all(promises)));
+}
+
+// Print summary
+const summary = results
+  .map((r) => `${r.name} ${r.status === 'pass' ? '✓' : '✗'} (${r.time}ms)`)
+  .join('  ');
+console.log(`\n${summary}`);
+console.log(`total: ${Date.now() - startTime}ms`);
+
+// Exit non-zero if any failed
+const anyFailed = results.some((r) => r.status === 'fail');
+process.exit(anyFailed ? 1 : 0);

package/scripts/coverage-file.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+// Print per-file coverage detail from coverage/coverage-final.json for one file, without
+// building a one-off `node -e` snippet each time. Used by ai/tasks/improve-test-coverage.md's Step 6
+// to precisely confirm a target file's coverage moved, since the printed summary table rounds
+// percentages and truncates long paths.
+//
+// Usage: ./scripts/run.mjs coverage-file <path-substring>
+// Requires `npm run coverage` to have already run (reads coverage/coverage-final.json).
+
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+
+const substring = process.argv[2];
+if (!substring) {
+  console.error('Usage: coverage-file <path-substring>');
+  process.exit(1);
+}
+
+const coveragePath = path.resolve('coverage', 'coverage-final.json');
+let data;
+try {
+  data = JSON.parse(readFileSync(coveragePath, 'utf8'));
+} catch {
+  console.error(`Could not read ${coveragePath} — run "npm run coverage" first.`);
+  process.exit(1);
+}
+
+const matches = Object.keys(data).filter((key) => key.includes(substring));
+if (matches.length === 0) {
+  console.error(`No file in coverage-final.json matches "${substring}".`);
+  process.exit(1);
+}
+if (matches.length > 1) {
+  console.error(`"${substring}" matches multiple files — be more specific:\n${matches.map((m) => `  ${m}`).join('\n')}`);
+  process.exit(1);
+}
+
+const file = data[matches[0]];
+
+function summarize(map, hits) {
+  const total = Object.keys(map).length;
+  const covered = Object.values(hits).filter((count) => count > 0).length;
+  const pct = total === 0 ? 100 : Math.round((covered / total) * 1000) / 10;
+  return { total, covered, pct };
+}
+
+// Branches are arrays of hit counts (one per location); a branch entry is "covered" only when
+// every location in it was hit at least once, matching Istanbul's own branch-coverage definition.
+function summarizeBranches(branchMap, b) {
+  const entries = Object.entries(branchMap);
+  const total = entries.reduce((sum, [, entry]) => sum + entry.locations.length, 0);
+  const covered = Object.values(b).reduce((sum, hits) => sum + hits.filter((count) => count > 0).length, 0);
+  const pct = total === 0 ? 100 : Math.round((covered / total) * 1000) / 10;
+  return { total, covered, pct };
+}
+
+// "% Lines" (matching the printed coverage table's column, and lcov's LF/LH) is not raw statement
+// count — Istanbul derives it by collapsing statements onto their start line, keeping the highest
+// hit count per line (istanbul-lib-coverage's FileCoverage#getLineCoverage). Two statements on the
+// same line count as one line; a statement spanning multiple lines only counts on its start line.
+function lineCoverage(statementMap, s) {
+  const lineMap = new Map();
+  for (const [id, entry] of Object.entries(statementMap)) {
+    const line = entry.start.line;
+    const count = s[id];
+    if (!lineMap.has(line) || lineMap.get(line) < count) lineMap.set(line, count);
+  }
+  const total = lineMap.size;
+  const covered = [...lineMap.values()].filter((count) => count > 0).length;
+  const pct = total === 0 ? 100 : Math.round((covered / total) * 1000) / 10;
+  const uncovered = [...lineMap].filter(([, count]) => count === 0).map(([line]) => line).toSorted((a, b) => a - b);
+  return { total, covered, pct, uncovered };
+}
+
+const statements = summarize(file.statementMap, file.s);
+const branches = summarizeBranches(file.branchMap, file.b);
+const functions = summarize(file.fnMap, file.f);
+const lines = lineCoverage(file.statementMap, file.s);
+
+console.log(matches[0]);
+console.log(`Statements: ${statements.covered}/${statements.total} (${statements.pct}%)`);
+console.log(`Branches:   ${branches.covered}/${branches.total} (${branches.pct}%)`);
+console.log(`Functions:  ${functions.covered}/${functions.total} (${functions.pct}%)`);
+console.log(`Lines:      ${lines.covered}/${lines.total} (${lines.pct}%)`);
+console.log(`Uncovered line #s: ${lines.uncovered.length > 0 ? lines.uncovered.join(', ') : 'none'}`);

package/scripts/docs-screenshots/capture.mjs

@@ -0,0 +1,82 @@
+// Drives one manifest entry against a freshly launched app: types the setup commands into the
+// command bar, performs the staged actions, waits for the shot to stabilize, and saves the PNG.
+const VIEWPORT = { width: 768, height: 768 };
+const DEFAULT_SETTLE_MS = 800;
+// 2x (retina) scale, applied to every shot, so doc pages stay crisp without oversized PNGs.
+const SCALE = 2;
+const CHILD_CROP_PAD = 12;
+
+async function typeCommand(page, text) {
+  const input = page.locator('.command textarea');
+  await input.waitFor({ state: 'visible' });
+  await input.click();
+  await page.keyboard.type(text);
+  await page.keyboard.press('Enter');
+}
+
+async function runActions(page, actions) {
+  for (const action of actions) {
+    if (action.type !== undefined) await page.keyboard.type(action.type);
+    if (action.press !== undefined) await page.keyboard.press(action.press);
+    if (action.wait !== undefined) await page.waitForTimeout(action.wait);
+  }
+}
+
+// The busy dot is fully off for half of every 1.2s blink cycle; wait for its lit phase so the
+// still can't catch it dark.
+async function stabilize(page, kind) {
+  if (kind !== 'busy-dot') return;
+  await page.waitForFunction(
+    () => {
+      const dot = globalThis.document.querySelector('.tab .dot.busy');
+      return dot !== null && globalThis.getComputedStyle(dot).opacity === '1';
+    },
+    undefined,
+    { timeout: 10_000 },
+  );
+}
+
+// The region to capture: the target element's box, optionally narrowed to its children (a tab
+// strip is viewport-wide but its tabs occupy the left edge) and/or cut below `clipHeight` (tall
+// bodies whose content sits at the top would otherwise be mostly empty space).
+async function elementClip(page, entry) {
+  const container = page.locator(`[data-doc-shot="${entry.target}"]`).first();
+  await container.waitFor({ state: 'visible' });
+  const box = await container.boundingBox();
+  let { width, height } = box;
+  if (entry.cropToChildren) {
+    const children = await container.locator(entry.cropToChildren).all();
+    let maxRight = box.x;
+    for (const child of children) {
+      const childBox = await child.boundingBox();
+      if (childBox) maxRight = Math.max(maxRight, childBox.x + childBox.width);
+    }
+    width = Math.min(width, maxRight - box.x + CHILD_CROP_PAD);
+  }
+  if (entry.clipHeight) height = Math.min(height, entry.clipHeight);
+  return { x: box.x, y: box.y, width, height };
+}
+
+export async function captureShot(browser, url, entry, outputPath) {
+  const context = await browser.newContext({ viewport: VIEWPORT, deviceScaleFactor: SCALE });
+  try {
+    const page = await context.newPage();
+    await page.goto(url, { waitUntil: 'networkidle' });
+    await page.locator('.command textarea').waitFor({ state: 'visible' });
+    const setupCommands = entry.setup ?? [];
+    for (const command of setupCommands) {
+      await typeCommand(page, command);
+      await page.waitForTimeout(entry.settle ?? DEFAULT_SETTLE_MS);
+    }
+    await runActions(page, entry.actions ?? []);
+    if (entry.actions?.length) await page.waitForTimeout(400);
+    await stabilize(page, entry.stabilize);
+    if (entry.target === 'page') {
+      await page.screenshot({ path: outputPath });
+      return;
+    }
+    await page.screenshot({ path: outputPath, clip: await elementClip(page, entry) });
+  } finally {
+    await context.close();
+  }
+}

package/scripts/docs-screenshots/fixtures/docs/api.md

@@ -0,0 +1,3 @@
+# API
+
+A second fixture file, so the expanded directory shows more than one row.

package/scripts/docs-screenshots/fixtures/docs/guide.md

@@ -0,0 +1,3 @@
+# Guide
+
+A fixture file so the file navigator screenshot has a docs directory to expand.

package/scripts/docs-screenshots/fixtures/page.html

@@ -0,0 +1,31 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Harbor Gazette</title>
+<style>
+  body { font-family: Georgia, serif; margin: 0; background: #f7f4ee; color: #22211e; }
+  header { background: #1d3557; color: #f1faee; padding: 24px 32px; }
+  header h1 { margin: 0; font-size: 28px; }
+  header p { margin: 4px 0 0; color: #a8dadc; }
+  main { padding: 24px 32px; max-width: 720px; }
+  article h2 { margin-top: 0; }
+  a { color: #1d3557; }
+</style>
+</head>
+<body>
+<header>
+  <h1>The Harbor Gazette</h1>
+  <p>Local news for the embedded-page screenshot</p>
+</header>
+<main>
+  <article>
+    <h2>Third bell still unexplained</h2>
+    <p>Harbor officials confirmed on Tuesday that the third bell, which rings each evening
+    shortly after the north pier lights come on, remains unaccounted for. "We only installed
+    two," said the harbormaster.</p>
+    <p>Residents are invited to submit theories at the town hall. <a href="#">Read more</a>.</p>
+  </article>
+</main>
+</body>
+</html>

package/scripts/docs-screenshots/fixtures/profiles/demo/editor.json

@@ -0,0 +1 @@
+{ "number": 2 }

package/scripts/docs-screenshots/fixtures/profiles/demo/writer.json

@@ -0,0 +1 @@
+{ "number": 1 }

package/scripts/docs-screenshots/fixtures/sample.md

@@ -0,0 +1,26 @@
+# Field notes
+
+A small document that exercises the renderer: headings, a list, a table, and a code block.
+
+## Observations
+
+- The harbor lights come on at dusk, north pier first.
+- Gulls prefer the fishing boats to the ferries.
+- Nobody has explained the third bell.
+
+## Tide table
+
+| Day | High | Low |
+| --- | ---- | --- |
+| Mon | 06:12 | 12:40 |
+| Tue | 07:03 | 13:29 |
+| Wed | 07:55 | 14:17 |
+
+## Sampling script
+
+```js
+const readings = tides.filter((t) => t.height > 1.5);
+console.log(`kept ${readings.length} of ${tides.length}`);
+```
+
+> Data collected between March and June. Treat Wednesday's numbers with suspicion.

package/scripts/docs-screenshots/fixtures/sample.ts

@@ -0,0 +1,25 @@
+// A tiny task tracker, here to give the editor screenshot some syntax to highlight.
+export type Task = {
+  id: number;
+  title: string;
+  done: boolean;
+};
+
+const tasks: Task[] = [
+  { id: 1, title: 'Chart the north pier', done: true },
+  { id: 2, title: 'Count the gulls', done: false },
+  { id: 3, title: 'Explain the third bell', done: false },
+];
+
+export function complete(id: number): Task | undefined {
+  const task = tasks.find((candidate) => candidate.id === id);
+  if (task) {
+    task.done = true;
+  }
+  return task;
+}
+
+export function remaining(): string {
+  const open = tasks.filter((candidate) => !candidate.done);
+  return `${open.length} task(s) remaining`;
+}

package/scripts/docs-screenshots/fixtures/src/app.ts

@@ -0,0 +1,2 @@
+// Fixture file for the file navigator screenshot.
+export const app = 'harbor-gazette';

package/scripts/docs-screenshots/fixtures/src/tides.ts

@@ -0,0 +1,2 @@
+// Fixture file for the file navigator screenshot.
+export const tides = [1.2, 1.7, 2.1];

package/scripts/docs-screenshots/janus.mjs

@@ -0,0 +1,51 @@
+// Spawns the app server under capture conditions: cwd in the scratch work directory, HOME in
+// the scratch home directory, no app window. The server entry is launched directly (not via
+// bin/janus.mjs, whose spawnSync child would outlive a kill of the launcher). The printed
+// `__JANUS_URL__ <url>` line carries the session token, so capture connects without guessing.
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+
+const URL_MARKER = '__JANUS_URL__ ';
+const URL_TIMEOUT_MS = 20_000;
+
+function serverCommand(repoRoot) {
+  const compiled = path.join(repoRoot, 'dist', 'main.js');
+  if (existsSync(compiled)) return [compiled];
+  return [path.join(repoRoot, 'node_modules', 'tsx', 'dist', 'cli.mjs'), path.join(repoRoot, 'src', 'main.ts')];
+}
+
+export function spawnJanus(repoRoot, scratch) {
+  const child = spawn(process.execPath, [...serverCommand(repoRoot), '--no-open'], {
+    cwd: scratch.work,
+    env: { ...process.env, HOME: scratch.home },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  const url = new Promise((resolve, reject) => {
+    let buffered = '';
+    const timer = setTimeout(() => reject(new Error(`no URL from janus within ${URL_TIMEOUT_MS}ms`)), URL_TIMEOUT_MS);
+    child.stdout.on('data', (chunk) => {
+      buffered += String(chunk);
+      const line = buffered.split('\n').find((candidate) => candidate.startsWith(URL_MARKER));
+      if (line !== undefined) {
+        clearTimeout(timer);
+        resolve(line.slice(URL_MARKER.length).trim());
+      }
+    });
+    child.stderr.on('data', () => {});
+    child.on('exit', (code) => {
+      clearTimeout(timer);
+      reject(new Error(`janus exited before printing its URL (code ${code})`));
+    });
+  });
+  return { child, url };
+}
+
+export async function killJanus(child) {
+  if (child.exitCode !== null) return;
+  const gone = new Promise((resolve) => child.once('exit', resolve));
+  child.kill('SIGTERM');
+  const timer = setTimeout(() => child.kill('SIGKILL'), 3000);
+  await gone;
+  clearTimeout(timer);
+}

package/scripts/docs-screenshots/manifest.mjs

@@ -0,0 +1,122 @@
+// The shot manifest for `./scripts/run.mjs docs-screenshots`. One entry per screenshot used by
+// the pages in documentation/user-documentation/; the entry name is the output filename, so a
+// doc page's image path (/screenshots/<name>.png) stays stable across reruns.
+//
+// Each entry may carry:
+//   setup          commands typed into the command bar, one at a time (Enter after each).
+//                  `{{PAGE_URL}}` is replaced with the fixture web server's URL.
+//   actions        staged input after setup: { type } text without submitting, { press } a key
+//                  (Playwright key syntax), { wait } milliseconds.
+//   target         the data-doc-shot attribute of the element to crop to, or 'page' for the
+//                  whole viewport.
+//   settle         milliseconds to wait after each setup command (default 800).
+//   cropToChildren narrow the crop to the extent of these child elements (e.g. the tab strip
+//                  spans the viewport but its tabs occupy the left edge).
+//   clipHeight     cut the crop below this many CSS pixels, for tall bodies whose content sits
+//                  at the top.
+//   stabilize      'busy-dot' waits for the blinking busy dot's lit phase, so a still can't
+//                  catch it dark.
+//   requiresBinary skip this shot (with a warning) unless the binary is on PATH; those shots
+//                  are captured manually on a machine that has it.
+export default [
+  // Getting started: the window on first launch, and the tab strip's signals.
+  { name: 'app-overview', setup: [], target: 'page' },
+  {
+    name: 'tabs-overview',
+    setup: ['agent bilal', 'shell sleep 30', 'agent cavus', 'msg janus info morning report ready'],
+    stabilize: 'busy-dot',
+    target: 'tab-strip',
+    cropToChildren: '.tab',
+  },
+  {
+    name: 'tabs-groups',
+    setup: ['agent bilal', 'profile launch demo'],
+    settle: 1500,
+    target: 'tab-strip',
+    cropToChildren: '.tab',
+  },
+
+  // Command bar.
+  { name: 'tab-completion', actions: [{ type: 'open sa' }, { press: 'Tab' }], target: 'command-bar' },
+  { name: 'shell-output', setup: ['shell ls -la'], settle: 1200, target: 'transcript', clipHeight: 400 },
+  {
+    name: 'history-picker',
+    setup: ['shell ls -la', 'shell git status', 'state'],
+    actions: [{ press: 'Control+r' }],
+    target: 'history-overlay',
+  },
+  {
+    // The scratch fixture has no `ai/` directory, so seed one with a few realistically named task
+    // files before opening the picker — otherwise Ctrl+A would capture the empty `(no tasks)` state.
+    // They go under `ai/tasks/` to match the real layout, which means the picker opens on a single
+    // collapsed `tasks` row: expand it (Right) and step onto a file (Down) so the shot shows the
+    // task files with one selected, as the doc page describes.
+    name: 'task-picker',
+    setup: [
+      'shell mkdir -p ai/tasks',
+      'shell touch ai/tasks/build-a-feature.md ai/tasks/fix-a-small-issue.md ai/tasks/improve-test-coverage.md ai/tasks/merge-change-to-master.md ai/tasks/open-feature-pull-request.md ai/tasks/reduce-complexity.md',
+    ],
+    actions: [{ press: 'Control+a' }, { press: 'ArrowRight' }, { press: 'ArrowDown' }],
+    target: 'task-overlay',
+  },
+  { name: 'ghost-text', setup: ['shell git status'], actions: [{ type: 'shell git' }], target: 'command-bar' },
+  {
+    name: 'tab-navigator',
+    setup: ['shell ls -la', 'shell git status'],
+    actions: [{ press: 'Control+g' }, { type: 'shell' }],
+    target: 'tab-nav-overlay',
+  },
+
+  // View tabs.
+  { name: 'image-tab', setup: ['open ./sample.png'], actions: [{ press: 'PageUp' }], target: 'image-view' },
+  { name: 'markdown-tab', setup: ['open ./sample.md'], target: 'markdown-view' },
+  { name: 'page-tab', setup: ['open {{PAGE_URL}}'], settle: 2000, target: 'page-view' },
+  {
+    name: 'editor-tab',
+    setup: ['edit ./sample.ts'],
+    actions: [{ type: '// TODO: tighten these types' }],
+    target: 'editor-view',
+    clipHeight: 560,
+  },
+  {
+    name: 'file-tree',
+    setup: ['files .'],
+    actions: [{ press: 'ArrowDown' }, { press: 'ArrowDown' }, { press: 'ArrowRight' }, { wait: 500 }],
+    target: 'file-tree-view',
+    clipHeight: 380,
+  },
+  {
+    name: 'file-tree-sidebar',
+    setup: ['files left .'],
+    settle: 1000,
+    target: 'page',
+  },
+
+  // Advanced agents and automation.
+  {
+    name: 'workspaced-agent',
+    setup: ['agent emrah --workspace', 'shell pwd'],
+    settle: 2500,
+    target: 'status-panels',
+  },
+  {
+    name: 'schedule-window',
+    setup: ['schedule standup every day at 9:00 state', 'schedule tests every 2h shell ls'],
+    target: 'status-panels',
+  },
+  {
+    name: 'profile-group',
+    setup: ['profile launch demo'],
+    settle: 1500,
+    target: 'tab-strip',
+    cropToChildren: '.tab',
+  },
+  {
+    name: 'harness-tab',
+    setup: ['harness claude'],
+    settle: 5000,
+    target: 'harness-view',
+    clipHeight: 540,
+    requiresBinary: 'claude',
+  },
+];

package/scripts/docs-screenshots/scratch.mjs

@@ -0,0 +1,53 @@
+// The disposable directory a screenshot run works in: a `work` directory seeded from the
+// fixtures (made into a git repo with a local `origin`, so workspaced shots can clone), and a
+// `home` directory so the app's homedir-scoped state (the global command history) never reads
+// or pollutes the real one.
+import { execFileSync } from 'node:child_process';
+import { cpSync, mkdirSync, mkdtempSync, rmSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import http from 'node:http';
+import os from 'node:os';
+import path from 'node:path';
+
+// Fixture commits need an identity that works on any machine, without touching real git config.
+const GIT_IDENTITY = ['-c', 'user.name=docs-screenshots', '-c', 'user.email=docs-screenshots@example.invalid'];
+
+function git(cwd, ...gitArguments) {
+  execFileSync('git', [...GIT_IDENTITY, ...gitArguments], { cwd, stdio: 'ignore' });
+}
+
+export function createScratch(fixturesDirectory) {
+  const root = mkdtempSync(path.join(os.tmpdir(), 'janus-docs-'));
+  // Named like a real project ("harbor", matching the fixtures' theme) because the directory
+  // name shows up in captured metadata headers.
+  const work = path.join(root, 'harbor');
+  const home = path.join(root, 'home');
+  mkdirSync(work);
+  mkdirSync(home);
+  cpSync(fixturesDirectory, work, { recursive: true });
+  // page.html is served by the fixture web server, not shown in the file tree.
+  rmSync(path.join(work, 'page.html'));
+  git(work, 'init', '--quiet');
+  git(work, 'add', '--all');
+  git(work, 'commit', '--quiet', '--message', 'fixtures');
+  const origin = path.join(root, 'origin.git');
+  git(root, 'clone', '--bare', '--quiet', work, origin);
+  git(work, 'remote', 'add', 'origin', origin);
+  return { root, work, home };
+}
+
+export function destroyScratch(scratch) {
+  rmSync(scratch.root, { recursive: true, force: true });
+}
+
+// A tiny local server for the embedded-web-page shot, so capture never depends on the network
+// or an external site staying up and stable.
+export async function startPageServer(fixturesDirectory) {
+  const html = await readFile(path.join(fixturesDirectory, 'page.html'));
+  const server = http.createServer((request, response) => {
+    response.writeHead(200, { 'content-type': 'text/html' });
+    response.end(html);
+  });
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  return { url: `http://127.0.0.1:${server.address().port}/`, close: () => server.close() };
+}