@celilo/e2e 0.1.0 → 0.2.1

package/src/index.ts

@@ -24,6 +24,9 @@
 // Builder API
 export { network, NetworkBuilder } from './network-builder';
 
+// Progress reporting (emit signals the test runner displays)
+export { progress } from './progress';
+
 // Types
 export type {
   NetworkConfig,
@@ -33,7 +36,7 @@ export type {
   Zone,
   TopologyPreset,
 } from './types';
-export { ZONE_GATEWAYS, ZONE_SUBNETS } from './types';
+export { CeliloCommandError, ZONE_GATEWAYS, ZONE_SUBNETS } from './types';
 
 // Common fixtures
 export {

package/src/progress.ts

@@ -0,0 +1,39 @@
+/**
+ * Emit progress signals that the e2e test runner displays.
+ *
+ * Each step has a "while doing" message and a "when done" message.
+ * The runner shows `… deploying caddy` while in progress, then
+ * replaces it with `✔ caddy deployed` when the next step starts
+ * or done() is called.
+ *
+ * Usage:
+ *   import { progress } from '@celilo/e2e';
+ *
+ *   progress('deploying caddy', 'caddy deployed with HTTPS');
+ *   await net.celilo('module deploy caddy');
+ *   // Next progress() auto-finalizes the previous step.
+ *
+ *   progress('verifying DNS', 'DNS resolves');
+ *   await net.waitFor(...);
+ *   progress.done();  // Explicit finalize (optional — next progress() also works)
+ */
+export function progress(doing: string, done?: string): void {
+  // Protocol: [progress:start] doing | done
+  // The runner shows "… doing" and replaces with "✔ done" when finalized.
+  const doneMsg = done ?? doing;
+  console.log(`[progress:start] ${doing} | ${doneMsg}`);
+}
+
+/** Explicitly finalize the current step. Optional override message. */
+progress.done = (message?: string): void => {
+  if (message) {
+    console.log(`[progress:done] ${message}`);
+  } else {
+    console.log('[progress:done]');
+  }
+};
+
+/** Mark the current step as failed with a message. */
+progress.fail = (message: string): void => {
+  console.log(`[progress:fail] ${message}`);
+};

package/src/runner.ts

@@ -0,0 +1,637 @@
+#!/usr/bin/env bun
+/**
+ * E2E Test Runner
+ *
+ * Runs each test file sequentially with live progress display.
+ * Tracks historical timing in .e2e-timing.json for countdown ETAs.
+ * Detects false passes (0 assertions).
+ *
+ * Progress protocol:
+ *   [progress:start] doing message | done message
+ *   [progress:done] optional override
+ *   [progress:fail] error message
+ *
+ * Display:
+ *   While in progress:  "  -45s  … deploying caddy"
+ *   When done:          "  -45s  ✔ caddy deployed"
+ *   Countdown goes negative when over estimate.
+ */
+
+import { spawn, spawnSync, execSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+
+// ─── Config ──────────────────────────────────────────────────────────
+
+const PKG_DIR = resolve(import.meta.dir, '..');
+const testDir = process.env.E2E_TEST_DIR || process.cwd();
+const testsPath = join(testDir, 'tests');
+const timingFile = join(testDir, '.e2e-timing.json');
+const patterns = process.argv.slice(2);
+
+// ─── Colors ──────────────────────────────────────────────────────────
+
+const bold = '\x1b[1m';
+const dim = '\x1b[2m';
+const green = '\x1b[32m';
+const red = '\x1b[31m';
+const cyan = '\x1b[36m';
+const reset = '\x1b[0m';
+
+// Terminal control for interactive mode
+const CLEAR_LINE = '\x1b[2K\r';
+const MOVE_UP = '\x1b[A';
+
+const interactive = process.stdout.isTTY && !process.argv.includes('--no-interactive');
+
+// ─── Timing ──────────────────────────────────────────────────────────
+
+type TimingHistory = Record<string, number>;
+
+function loadTiming(): TimingHistory {
+  try {
+    return JSON.parse(readFileSync(timingFile, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+function saveTiming(history: TimingHistory): void {
+  writeFileSync(timingFile, JSON.stringify(history, Object.keys(history).sort(), 2) + '\n');
+}
+
+function formatDuration(secs: number): string {
+  if (secs >= 60) return `${Math.floor(secs / 60)}m${Math.abs(secs) % 60}s`;
+  return `${secs}s`;
+}
+
+/** Format countdown: positive = remaining, negative = over estimate */
+function formatCountdown(elapsedSecs: number, expectedSecs: number | undefined): string {
+  if (!expectedSecs) return `${dim}${String(elapsedSecs).padStart(4)}s${reset}`;
+  const remaining = expectedSecs - elapsedSecs;
+  if (remaining >= 0) {
+    return `${dim}${String(remaining).padStart(4)}s${reset}`;
+  }
+  return `${red}${String(remaining).padStart(4)}s${reset}`;
+}
+
+// ─── Progress Display ────────────────────────────────────────────────
+
+interface PendingStep {
+  doingMsg: string;
+  doneMsg: string;
+  startTime: number;
+}
+
+class ProgressDisplay {
+  private pending: PendingStep | null = null;
+  private testStart = 0;
+  private expectedDuration: number | undefined;
+  /** Number of sub-event lines printed below the current "… doing" line */
+  private subEventCount = 0;
+
+  reset(testStart: number, expectedDuration: number | undefined) {
+    this.pending = null;
+    this.testStart = testStart;
+    this.expectedDuration = expectedDuration;
+    this.subEventCount = 0;
+  }
+
+  private time(): string {
+    const elapsed = Math.floor((Date.now() - this.testStart) / 1000);
+    return formatCountdown(elapsed, this.expectedDuration);
+  }
+
+  /**
+   * In interactive mode: erase the "… doing" line and all sub-event
+   * lines below it, then print the "✔ done" line in their place.
+   * In non-interactive mode: just append the done line.
+   */
+  private finalizePending() {
+    if (!this.pending) return;
+    if (interactive) {
+      // Erase sub-event lines + the pending "…" line
+      const linesToErase = this.subEventCount + 1;
+      for (let i = 0; i < linesToErase; i++) {
+        process.stdout.write(`${MOVE_UP}${CLEAR_LINE}`);
+      }
+    }
+    process.stdout.write(`  ${this.time()}  ${green}✔${reset} ${this.pending.doneMsg}\n`);
+    this.pending = null;
+    this.subEventCount = 0;
+  }
+
+  private finalizeFailed(message: string) {
+    if (interactive && this.pending) {
+      const linesToErase = this.subEventCount + 1;
+      for (let i = 0; i < linesToErase; i++) {
+        process.stdout.write(`${MOVE_UP}${CLEAR_LINE}`);
+      }
+    }
+    process.stdout.write(`  ${this.time()}  ${red}✗${reset} ${message}\n`);
+    this.pending = null;
+    this.subEventCount = 0;
+  }
+
+  startStep(doingMsg: string, doneMsg: string) {
+    this.finalizePending();
+    this.pending = { doingMsg, doneMsg, startTime: Date.now() };
+    this.subEventCount = 0;
+    process.stdout.write(`  ${this.time()}  ${dim}…${reset} ${doingMsg}\n`);
+  }
+
+  doneStep(overrideMessage?: string) {
+    if (this.pending && overrideMessage) {
+      this.pending.doneMsg = overrideMessage;
+    }
+    this.finalizePending();
+  }
+
+  failStep(message: string) {
+    this.finalizeFailed(message);
+  }
+
+  instantEvent(message: string) {
+    this.finalizePending();
+    process.stdout.write(`  ${this.time()}  ${message}\n`);
+  }
+
+  /**
+   * Show a sub-event under the current "… doing" step.
+   * Interactive: replaces the "… doing" line with the sub-event,
+   * then reprints "… doing" below it — so the pending line is always last.
+   * Non-interactive: just appends indented.
+   */
+  subEvent(message: string) {
+    if (interactive && this.pending) {
+      // Replace the "… doing" line with this sub-event (permanent)
+      process.stdout.write(`${MOVE_UP}${CLEAR_LINE}`);
+      process.stdout.write(`  ${this.time()}    ${message}\n`);
+      // Reprint the "… doing" line as the new bottom line
+      process.stdout.write(`  ${this.time()}  ${dim}…${reset} ${this.pending.doingMsg}\n`);
+      this.subEventCount++;
+    } else {
+      process.stdout.write(`  ${this.time()}    ${message}\n`);
+      if (this.pending) this.subEventCount++;
+    }
+  }
+
+  /** Finalize pending on success */
+  flush() {
+    this.finalizePending();
+  }
+
+  /** Abandon pending step on failure (erase the … line in interactive mode) */
+  abandon() {
+    if (!this.pending) return;
+    if (interactive) {
+      const linesToErase = this.subEventCount + 1;
+      for (let i = 0; i < linesToErase; i++) {
+        process.stdout.write(`${MOVE_UP}${CLEAR_LINE}`);
+      }
+    }
+    this.pending = null;
+    this.subEventCount = 0;
+  }
+}
+
+// ─── Line Parsing ────────────────────────────────────────────────────
+
+function parseLine(line: string, display: ProgressDisplay): void {
+  // Protocol: [progress:start] doing | done
+  const startMatch = line.match(/\[progress:start\] (.*?) \| (.*)/);
+  if (startMatch) {
+    display.startStep(startMatch[1], startMatch[2]);
+    return;
+  }
+
+  // Protocol: [progress:done] optional message
+  const doneMatch = line.match(/\[progress:done\](.*)/);
+  if (doneMatch) {
+    const msg = doneMatch[1].trim();
+    display.doneStep(msg || undefined);
+    return;
+  }
+
+  // Protocol: [progress:fail] message
+  const failMatch = line.match(/\[progress:fail\] (.*)/);
+  if (failMatch) {
+    display.failStep(failMatch[1]);
+    return;
+  }
+
+  // Legacy: [progress] message (treat as instant event)
+  const legacyMatch = line.match(/\[progress\] (.*)/);
+  if (legacyMatch) {
+    display.instantEvent(legacyMatch[1]);
+    return;
+  }
+
+  // Celilo CLI signals — shown as sub-events under the current step.
+  // These must NOT finalize the test's progress step.
+  const deployMatch = line.match(/Module '([^']+)' deployed successfully/);
+  if (deployMatch) {
+    display.subEvent(`${green}✔${reset} ${deployMatch[1]} deployed`);
+    return;
+  }
+
+  const importMatch = line.match(/Successfully imported module: (\S+)/);
+  if (importMatch) {
+    display.subEvent(`${green}✔${reset} ${importMatch[1]} imported`);
+    return;
+  }
+
+  if (line.includes('Deploying software')) {
+    display.subEvent('running Ansible');
+    return;
+  }
+  if (line.includes('Infrastructure selected')) {
+    display.subEvent('infrastructure selected');
+    return;
+  }
+  if (line.includes('Terraform skipped')) {
+    display.subEvent('terraform skipped (existing machine)');
+    return;
+  }
+  if (line.includes('terraform init') || line.includes('Terraform init')) {
+    display.subEvent('running terraform init');
+    return;
+  }
+  if (line.includes('terraform apply') || line.includes('Terraform apply')) {
+    display.subEvent('running terraform apply');
+    return;
+  }
+
+  const retryMatch = line.match(/RETRYING.*?(\d+) retries left/);
+  if (retryMatch) {
+    display.subEvent(`health check (${retryMatch[1]} retries left)`);
+    return;
+  }
+
+  // Error lines
+  if (line.includes('Error:') && !line.includes('bun test') && !line.includes('ipv4: Address already')) {
+    const err = line.replace(/.*Error: /, '').slice(0, 70);
+    display.subEvent(`${red}✗${reset} ${err}`);
+  }
+}
+
+// ─── Error Extraction ────────────────────────────────────────────────
+
+function extractFailureMessage(lines: string[], exitCode: number): string {
+  const errorIdx = lines.findIndex(
+    (l) => l.startsWith('error:') && !l.includes('bun test'),
+  );
+
+  if (errorIdx >= 0) {
+    const context = lines
+      .slice(errorIdx, errorIdx + 5)
+      .map((l) => l.trim())
+      .filter((l) => l.length > 0 && !l.startsWith('at '));
+    return context.join('\n    ');
+  }
+
+  const celiloError = lines.find(
+    (l) => l.includes('CeliloCommandError') || (l.includes('celilo') && l.includes('failed')),
+  );
+  if (celiloError) return celiloError.slice(0, 120);
+
+  const timeout = lines.find((l) => l.includes('Timeout') || l.includes('timed out'));
+  if (timeout) return timeout.slice(0, 120);
+
+  return `exit code ${exitCode}`;
+}
+
+// ─── Test Execution ──────────────────────────────────────────────────
+
+interface TestResult {
+  name: string;
+  status: 'pass' | 'fail' | 'suspicious';
+  duration: number;
+  error?: string;
+  hadDebugPause?: boolean;
+}
+
+async function runTest(
+  file: string,
+  name: string,
+  expectedDuration: number | undefined,
+  logDir: string,
+  display: ProgressDisplay,
+): Promise<TestResult> {
+  const start = Date.now();
+  const logFile = join(logDir, 'output.log');
+
+  display.reset(start, expectedDuration);
+  let hadDebugPause = false;
+
+  return new Promise<TestResult>((resolveTest) => {
+    // 1 hour timeout per test (debug sessions can be long)
+    const proc = spawn('bun', ['test', '--timeout', '3600000', file], {
+      cwd: PKG_DIR,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env },
+    });
+
+    let stdout = '';
+    let stderr = '';
+    const lines: string[] = [];
+
+    function handleDebugPause(project: string, container: string) {
+      display.instantEvent(`${bold}\x1b[33m⏸ DEBUG: paused at ${container}${reset}`);
+
+      const signalFile = join(PKG_DIR, `.debug-resume-${proc.pid}`);
+      const border = '═'.repeat(56);
+      process.stdout.write(`\n${bold}\x1b[33m╔${border}╗${reset}\n`);
+      process.stdout.write(`${bold}\x1b[33m║  DEBUG: test paused                                    ║${reset}\n`);
+      process.stdout.write(`${bold}\x1b[33m╠${border}╣${reset}\n`);
+      process.stdout.write(`${bold}\x1b[33m║${reset}  Project:   ${bold}${project}${reset}\n`);
+      process.stdout.write(`${bold}\x1b[33m║${reset}  Container: ${bold}${container}${reset}\n`);
+      process.stdout.write(`${bold}\x1b[33m║${reset}\n`);
+      process.stdout.write(`${bold}\x1b[33m║${reset}  ${dim}Run commands:${reset}\n`);
+      process.stdout.write(`${bold}\x1b[33m║${reset}    docker compose -f docker-compose.test.yml \\\n`);
+      process.stdout.write(`${bold}\x1b[33m║${reset}      -p ${project} exec ${container} bash -c '<cmd>'\n`);
+      process.stdout.write(`${bold}\x1b[33m║${reset}\n`);
+
+      if (interactive) {
+        process.stdout.write(`${bold}\x1b[33m║${reset}  ${dim}Or get a shell: type 'exit' to resume the test.${reset}\n`);
+        process.stdout.write(`${bold}\x1b[33m╚${border}╝${reset}\n\n`);
+
+        spawnSync('docker', [
+          'compose', '-f', 'docker-compose.test.yml', '-p', project,
+          'exec', container, 'bash',
+        ], {
+          cwd: PKG_DIR,
+          stdio: 'inherit',
+        });
+      } else {
+        process.stdout.write(`${bold}\x1b[33m║${reset}  ${dim}Resume: touch ${signalFile}${reset}\n`);
+        process.stdout.write(`${bold}\x1b[33m╚${border}╝${reset}\n\n`);
+
+        // Non-interactive: just wait for the signal file (no shell)
+        // The caller creates the file when they're done investigating.
+        return;
+      }
+
+      process.stdout.write(`\n${dim}Resuming test...${reset}\n\n`);
+      writeFileSync(signalFile, 'resume');
+    }
+
+    function processChunk(chunk: Buffer) {
+      const text = chunk.toString();
+      stdout += text;
+
+      for (const part of text.split('\n')) {
+        const trimmed = part.trim();
+        if (!trimmed) continue;
+        lines.push(trimmed);
+
+        // Check for debug pause signal: [debug:pause] <project> <container>
+        const debugMatch = trimmed.match(/\[debug:pause\] (\S+) (\S+)/);
+        if (debugMatch) {
+          hadDebugPause = true;
+          handleDebugPause(debugMatch[1], debugMatch[2]);
+          continue;
+        }
+
+        parseLine(trimmed, display);
+      }
+    }
+
+    proc.stdout.on('data', processChunk);
+    proc.stderr.on('data', (chunk: Buffer) => {
+      stderr += chunk.toString();
+      processChunk(chunk);
+    });
+
+    proc.on('close', (code) => {
+      const duration = Math.floor((Date.now() - start) / 1000);
+      if (code === 0) {
+        display.flush();
+      } else {
+        display.abandon();
+      }
+
+      writeFileSync(logFile, stdout + '\n---STDERR---\n' + stderr);
+
+      const expectMatch = stdout.match(/(\d+) expect\(\) calls/);
+      const expectCount = expectMatch ? parseInt(expectMatch[1], 10) : undefined;
+
+      if (code === 0) {
+        if (expectCount === 0) {
+          resolveTest({
+            name,
+            status: 'suspicious',
+            duration,
+            hadDebugPause,
+            error: '0 assertions — test likely exited before reaching assertions',
+          });
+        } else {
+          resolveTest({ name, status: 'pass', duration, hadDebugPause });
+        }
+      } else {
+        resolveTest({
+          name,
+          status: 'fail',
+          duration,
+          hadDebugPause,
+          error: extractFailureMessage(lines, code ?? 1),
+        });
+      }
+    });
+  });
+}
+
+// ─── Shared Infrastructure ───────────────────────────────────────────
+
+function dockerComposeShared(cmd: string): string {
+  try {
+    return execSync(
+      `docker compose -f docker-compose.shared.yml -p celilo-e2e-shared ${cmd}`,
+      { cwd: PKG_DIR, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 60_000 },
+    ).trim();
+  } catch {
+    return '';
+  }
+}
+
+function isSharedInfraHealthy(): boolean {
+  const containers = dockerComposeShared('ps -q');
+  if (!containers) return false;
+  return dockerComposeShared(
+    'exec -T namecheap-dns dig @127.0.0.1 iamtheinternet.org SOA +short +timeout=2',
+  ).length > 0;
+}
+
+function stopSharedInfra(): void {
+  dockerComposeShared('down --volumes --remove-orphans');
+  try { execSync('docker network prune -f', { stdio: 'pipe', timeout: 10_000 }); } catch {}
+}
+
+// ─── Main ────────────────────────────────────────────────────────────
+
+async function main() {
+  if (!existsSync(testsPath)) {
+    console.error(`${red}No tests/ directory found at ${testsPath}${reset}`);
+    process.exit(1);
+  }
+
+  let testFiles = readdirSync(testsPath)
+    .filter((f) => f.endsWith('.test.ts'))
+    .sort()
+    .map((f) => resolve(testsPath, f));
+
+  if (patterns.length > 0) {
+    testFiles = testFiles.filter((f) => patterns.some((p) => basename(f, '.test.ts').includes(p)));
+  }
+
+  if (testFiles.length === 0) {
+    console.error(`${red}No test files matched${reset}`);
+    process.exit(1);
+  }
+
+  const history = loadTiming();
+  const testNames = testFiles.map((f) => basename(f, '.test.ts'));
+  const hasHistory = testNames.some((n) => history[n]);
+  const suiteExpected = testNames.reduce((sum, n) => sum + (history[n] || 0), 0);
+
+  console.log();
+  console.log(`${bold}╔══════════════════════════════════════════════════════════════╗${reset}`);
+  console.log(`${bold}║  Celilo E2E Tests                                          ║${reset}`);
+  if (hasHistory) {
+    console.log(`${bold}║  ${testFiles.length} test(s) — expected ~${formatDuration(suiteExpected).padEnd(30)}║${reset}`);
+  } else {
+    console.log(`${bold}║  ${testFiles.length} test(s) — first run, no timing history             ║${reset}`);
+  }
+  console.log(`${bold}╚══════════════════════════════════════════════════════════════╝${reset}`);
+  console.log();
+
+  // Shared infra check
+  console.log(`${bold}Shared Infrastructure${reset}`);
+  if (isSharedInfraHealthy()) {
+    console.log(`  ${green}✔ already running (DNS healthy)${reset}`);
+  } else {
+    console.log(`  ${dim}Will start on first test...${reset}`);
+  }
+  console.log();
+
+  const suiteStart = Date.now();
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const resultsDir = join(testDir, 'results', timestamp);
+  mkdirSync(resultsDir, { recursive: true });
+
+  const display = new ProgressDisplay();
+  let passed = 0;
+  let failed = 0;
+  const results: TestResult[] = [];
+
+  let interrupted = false;
+  process.on('SIGINT', () => {
+    if (interrupted) process.exit(130);
+    interrupted = true;
+    console.log(`\n${red}Interrupted. Stopping shared infrastructure...${reset}`);
+    stopSharedInfra();
+    saveTiming(history);
+    process.exit(130);
+  });
+
+  for (let i = 0; i < testFiles.length; i++) {
+    if (interrupted) break;
+
+    const file = testFiles[i];
+    const name = testNames[i];
+    const logDir = join(resultsDir, name);
+    mkdirSync(logDir, { recursive: true });
+
+    const expected = history[name];
+
+    // Remaining ETA from history
+    const remainingExpected = testNames.slice(i).reduce((sum, n) => sum + (history[n] || 0), 0);
+    const hasRemaining = testNames.slice(i).some((n) => history[n]);
+
+    let header = `${bold}[${i + 1}/${testFiles.length}] ${name}${reset}`;
+    if (expected) {
+      header += ` ${dim}(~${formatDuration(expected)})${reset}`;
+    }
+    if (hasRemaining && i > 0) {
+      header += ` ${dim}— ~${formatDuration(remainingExpected)} remaining${reset}`;
+    }
+    console.log(header);
+
+    const result = await runTest(file, name, expected, logDir, display);
+    results.push(result);
+    // Only save meaningful durations — crashes (<10s) and debug sessions
+    // would poison future ETAs
+    if (result.duration >= 10 && !result.hadDebugPause) {
+      history[name] = result.duration;
+    }
+
+    if (result.status === 'pass') {
+      console.log(`  ${green}✔ passed (${result.duration}s)${reset}`);
+      passed++;
+    } else if (result.status === 'suspicious') {
+      console.log(`  ${red}✗ suspicious pass — 0 assertions (${result.duration}s)${reset}`);
+      console.log(`  ${red}  └─ ${result.error}${reset}`);
+      failed++;
+    } else {
+      console.log(`  ${red}✗ failed (${result.duration}s)${reset}`);
+      if (result.error) {
+        console.log(`  ${red}  └─ ${result.error}${reset}`);
+      }
+      failed++;
+    }
+    console.log();
+
+    writeFileSync(
+      join(logDir, 'result.json'),
+      JSON.stringify({ status: result.status, duration: result.duration, error: result.error }),
+    );
+
+    try { execSync('docker network prune -f', { stdio: 'pipe', timeout: 10_000 }); } catch {}
+  }
+
+  saveTiming(history);
+
+  console.log(`${dim}Stopping shared infrastructure...${reset}`);
+  stopSharedInfra();
+
+  const suiteDuration = Math.floor((Date.now() - suiteStart) / 1000);
+
+  console.log();
+  console.log(`${bold}╔══════════════════════════════════════════════════════════════╗${reset}`);
+  console.log(
+    `${bold}║  Results: ${green}${passed} passed${reset}${bold}, ${red}${failed} failed${reset}${bold} — ${formatDuration(suiteDuration)} total${' '.repeat(20)}║${reset}`,
+  );
+  console.log(`${bold}╠══════════════════════════════════════════════════════════════╣${reset}`);
+
+  for (const r of results) {
+    const icon = r.status === 'pass' ? '✓' : '✗';
+    const color = r.status === 'pass' ? green : red;
+    console.log(`${bold}║${reset}  ${color}${icon}${reset} ${r.name.padEnd(28)} ${dim}${(r.duration + 's').padStart(6)}${reset}`);
+    if (r.error) {
+      console.log(`${bold}║${reset}    ${red}└─ ${r.error}${reset}`);
+    }
+  }
+
+  console.log(`${bold}╚══════════════════════════════════════════════════════════════╝${reset}`);
+  console.log();
+  console.log(`${dim}Full logs: ${resultsDir}${reset}`);
+
+  writeFileSync(
+    join(resultsDir, 'summary.json'),
+    JSON.stringify({ timestamp, total: testFiles.length, passed, failed, duration: suiteDuration }, null, 2),
+  );
+
+  const gitignore = join(testDir, '.gitignore');
+  const content = existsSync(gitignore) ? readFileSync(gitignore, 'utf-8') : '';
+  const adds: string[] = [];
+  if (!content.includes('results/')) adds.push('results/');
+  if (!content.includes('.e2e-timing.json')) adds.push('.e2e-timing.json');
+  if (adds.length) writeFileSync(gitignore, content.trimEnd() + '\n' + adds.join('\n') + '\n');
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});