seer-mcp 0.1.0

package/tests/mcp-tracki.ts

@@ -0,0 +1,174 @@
+/**
+ * MCP smoke test for Track I (post-Track-H features):
+ *   - seer_external_bundles
+ *   - seer_contract_diff
+ *   - seer_preflight
+ *   - seer_boundaries / seer_boundary_for_file / seer_boundary_dependencies
+ *   - seer_continuity
+ *
+ * Spawns `seer mcp` against a tiny fixture monorepo and exercises each tool.
+ *
+ * Run: npx tsx tests/mcp-tracki.ts
+ */
+
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+
+const ROOT = path.resolve(__dirname, '..');
+const TMP_WS = path.join(os.tmpdir(), `seer-mcp-i-${Date.now()}`);
+const CLI = path.join(ROOT, 'dist/cli/index.js');
+
+let passed = 0;
+let failed = 0;
+const ok  = (m: string): void => { passed++; console.log(`  ✓ ${m}`); };
+const bad = (m: string, x?: unknown): void => {
+  failed++;
+  console.error(`  ✗ ${m}` + (x !== undefined ? `  ::  ${JSON.stringify(x).slice(0, 400)}` : ''));
+};
+
+function write(rel: string, content: string): void {
+  const full = path.join(TMP_WS, rel);
+  fs.mkdirSync(path.dirname(full), { recursive: true });
+  fs.writeFileSync(full, content);
+}
+
+async function main(): Promise<void> {
+  console.log('\nSeer MCP Track-I Smoke');
+  console.log('======================\n');
+
+  fs.mkdirSync(TMP_WS, { recursive: true });
+  // Tiny monorepo with one package and one service.
+  write('package.json', JSON.stringify({
+    name: 'tracki-mcp-fixture', private: true,
+    workspaces: ['packages/*', 'services/*'],
+  }));
+  write('packages/lib/package.json', JSON.stringify({ name: 'lib', version: '0.0.0' }));
+  write('packages/lib/src/util.ts', `
+export function makeId(seed: number): string { return 'id-' + seed; }
+`.trimStart());
+  write('services/svc/package.json', JSON.stringify({ name: 'svc', version: '0.0.0' }));
+  write('services/svc/src/api.ts', `
+import { makeId } from '../../../packages/lib/src/util';
+declare const app: any;
+export function getHandler(req: any, res: any): unknown {
+  return res.send({ id: makeId(req.body.seed) });
+}
+app.get('/api/get', getHandler);
+`.trimStart());
+
+  const proc = spawn(process.execPath,
+    [CLI, 'mcp', '--workspace', TMP_WS, '--no-watch', '--no-jit'],
+    { stdio: ['pipe', 'pipe', 'pipe'] });
+  proc.stderr.on('data', d => process.stderr.write(`[mcp-stderr] ${d}`));
+
+  let buf = '';
+  const pending = new Map<number, (msg: any) => void>();
+  proc.stdout.on('data', (chunk: Buffer) => {
+    buf += chunk.toString('utf8');
+    let nl: number;
+    while ((nl = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line) continue;
+      let msg: any;
+      try { msg = JSON.parse(line); } catch { continue; }
+      if (msg.id != null && pending.has(msg.id)) {
+        pending.get(msg.id)!(msg);
+        pending.delete(msg.id);
+      }
+    }
+  });
+
+  let nextId = 1;
+  const call = (method: string, params: any): Promise<any> => {
+    const id = nextId++;
+    return new Promise((resolve, reject) => {
+      pending.set(id, resolve);
+      proc.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
+      setTimeout(() => {
+        if (pending.has(id)) { pending.delete(id); reject(new Error(`timeout ${method}`)); }
+      }, 60_000);
+    });
+  };
+
+  let initOk = false;
+  for (let i = 0; i < 40; i++) {
+    try {
+      const r = await call('initialize', {
+        protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 't', version: '0' },
+      });
+      if (r.result) { initOk = true; break; }
+    } catch { /* */ }
+    await new Promise(r => setTimeout(r, 500));
+  }
+  if (initOk) ok('initialize');
+  else { bad('initialize'); process.exit(1); }
+
+  const list = await call('tools/list', {});
+  const names: string[] = (list.result?.tools ?? []).map((t: any) => t.name);
+  for (const n of [
+    'seer_external_bundles', 'seer_contract_diff', 'seer_preflight',
+    'seer_boundaries', 'seer_boundary_for_file', 'seer_boundary_dependencies',
+    'seer_continuity',
+  ]) {
+    if (names.includes(n)) ok(`tools/list advertises ${n}`);
+    else bad(`tools/list missing ${n}`, names);
+  }
+
+  const callTool = async (name: string, args: any = {}): Promise<any> => {
+    const r = await call('tools/call', { name, arguments: args });
+    return JSON.parse(r.result?.content?.[0]?.text ?? '{}');
+  };
+
+  // seer_boundaries
+  const boundaries = await callTool('seer_boundaries');
+  if (boundaries.total >= 1) ok(`seer_boundaries returned ${boundaries.total} boundaries`);
+  else bad('seer_boundaries returned no boundaries', boundaries);
+  const labels = (boundaries.items ?? []).map((b: any) => b.label);
+  if (labels.includes('lib')) ok('seer_boundaries includes lib');
+  else bad('seer_boundaries missing lib', labels);
+  if (labels.includes('svc')) ok('seer_boundaries includes svc');
+  else bad('seer_boundaries missing svc', labels);
+
+  // seer_boundary_for_file
+  const bf = await callTool('seer_boundary_for_file', {
+    file: 'services/svc/src/api.ts',
+  });
+  if (bf.ok && bf.boundary?.label === 'svc')
+    ok('seer_boundary_for_file returns svc for api.ts');
+  else bad('seer_boundary_for_file unexpected', bf);
+
+  // seer_preflight (symbol)
+  const pf = await callTool('seer_preflight', { symbol: 'getHandler' });
+  if (pf.ok && pf.symbol?.name === 'getHandler')
+    ok('seer_preflight symbol mode returns getHandler');
+  else bad('seer_preflight symbol mode', pf);
+  if (pf.boundaries?.primary?.label === 'svc')
+    ok('seer_preflight surfaces boundary');
+  else bad('seer_preflight boundary missing', pf.boundaries);
+
+  // seer_external_bundles (no layers imported — should return total=0)
+  const eb = await callTool('seer_external_bundles');
+  if (eb.total === 0) ok('seer_external_bundles total=0 when no layers');
+  else bad('seer_external_bundles unexpected', eb);
+
+  // seer_continuity — for getHandler may or may not find candidates, just
+  // verify it does not crash.
+  const ct = await callTool('seer_continuity', { symbol: 'getHandler' });
+  if (ct.ok === true) ok('seer_continuity ok=true');
+  else bad('seer_continuity not ok', ct);
+
+  proc.kill();
+  await new Promise(r => setTimeout(r, 200));
+  try { fs.rmSync(TMP_WS, { recursive: true, force: true }); } catch { /* */ }
+
+  console.log(`\nPassed: ${passed}   Failed: ${failed}`);
+  if (failed > 0) process.exit(1);
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/tests/mcp-watcher.ts

@@ -0,0 +1,126 @@
+/**
+ * Watcher-mode MCP test. Runs `seer mcp` with watcher ENABLED and JIT
+ * DISABLED, edits a file, then waits for the watcher to fire and queries
+ * to see whether the new symbol shows up. This verifies the watcher path
+ * works independently of JIT — they're two separate safety nets and the
+ * tests should cover them separately.
+ */
+
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+
+const ROOT = path.resolve(__dirname, '..');
+const FIXTURES = path.join(ROOT, 'tests/fixtures');
+const TMP_WS = path.join(os.tmpdir(), `seer-mcp-watch-${Date.now()}`);
+const CLI = path.join(ROOT, 'dist/cli/index.js');
+
+let passed = 0;
+let failed = 0;
+const ok = (label: string) => { passed++; console.log(`  ✓ ${label}`); };
+const bad = (label: string, extra?: unknown) => {
+  failed++;
+  console.error(`  ✗ ${label}` + (extra !== undefined ? ` :: ${JSON.stringify(extra)}` : ''));
+};
+
+async function main(): Promise<void> {
+  console.log('\nSeer MCP Watcher Test\n=======================\n');
+  fs.mkdirSync(TMP_WS, { recursive: true });
+  for (const f of fs.readdirSync(FIXTURES)) {
+    fs.copyFileSync(path.join(FIXTURES, f), path.join(TMP_WS, f));
+  }
+  console.log(`  Workspace: ${TMP_WS}\n`);
+
+  const proc = spawn(process.execPath, [CLI, 'mcp', '--workspace', TMP_WS, '--no-jit'], {
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+  proc.stderr.on('data', (d) => process.stderr.write(`[mcp-stderr] ${d}`));
+
+  let buf = '';
+  const pending = new Map<number, (msg: any) => void>();
+  proc.stdout.on('data', (chunk: Buffer) => {
+    buf += chunk.toString('utf8');
+    let nl: number;
+    while ((nl = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line) continue;
+      try {
+        const msg = JSON.parse(line);
+        if (msg.id != null && pending.has(msg.id)) {
+          pending.get(msg.id)!(msg);
+          pending.delete(msg.id);
+        }
+      } catch { /* */ }
+    }
+  });
+
+  let nextId = 1;
+  const call = (method: string, params: any): Promise<any> => {
+    const id = nextId++;
+    return new Promise((resolve, reject) => {
+      pending.set(id, resolve);
+      proc.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
+      setTimeout(() => {
+        if (pending.has(id)) { pending.delete(id); reject(new Error(`timeout: ${method}`)); }
+      }, 30_000);
+    });
+  };
+
+  for (let i = 0; i < 30; i++) {
+    try {
+      const r = await call('initialize', { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'watch-smoke', version: '0.1.0' } });
+      if (r.result) break;
+    } catch { /* */ }
+    await new Promise(r => setTimeout(r, 500));
+  }
+  ok('server initialized with watcher on');
+
+  // Confirm watcher status is reported
+  const h = JSON.parse((await call('tools/call', { name: 'seer_health', arguments: {} })).result.content[0].text);
+  if (h.watcher && h.watcher.watching) ok('seer_health reports watcher=true');
+  else bad('watcher not active', h.watcher);
+
+  // Give chokidar a beat to finish its initial scan — even with
+  // ignoreInitial:true it walks the tree before declaring "ready", and on
+  // Windows the walk is noticeably slow for small workspaces.
+  await new Promise(r => setTimeout(r, 1000));
+
+  // Edit sample.ts and wait for the watcher to fire + reindex.
+  const samplePath = path.join(TMP_WS, 'sample.ts');
+  const original = fs.readFileSync(samplePath, 'utf8');
+  fs.writeFileSync(samplePath, original + `\n\nexport function watcherInjected(): void {}\n`);
+  process.stderr.write(`  (wrote new function to sample.ts)\n`);
+
+  // Poll up to 15 seconds for the symbol to appear via the watcher (no JIT helping).
+  // The watcher has debounceMs=250, awaitWriteFinish stabilityThreshold=100, plus
+  // a full reindex of ~15 files (~200ms). So we'd expect detection in well under
+  // a second, but Windows file-event latency can be unpredictable.
+  let found = false;
+  for (let i = 0; i < 75; i++) {
+    await new Promise(r => setTimeout(r, 200));
+    const q = JSON.parse((await call('tools/call', { name: 'seer_symbols', arguments: { query: 'watcherInjected' } })).result.content[0].text);
+    if (q.items.some((it: any) => it.name === 'watcherInjected')) {
+      found = true;
+      ok(`watcher picked up new symbol after ${(i + 1) * 200}ms`);
+      break;
+    }
+  }
+  if (!found) bad('watcher never picked up new symbol within 15s');
+
+  proc.stdin.end();
+  proc.kill();
+  await new Promise(r => setTimeout(r, 200));
+
+  try { fs.rmSync(TMP_WS, { recursive: true, force: true }); } catch { /* */ }
+
+  console.log(`\n══════════════════════════════════════════════════════════════`);
+  console.log(`  Watcher results: ${passed} passed, ${failed} failed\n`);
+  if (failed > 0) process.exit(1);
+}
+
+main().catch(err => {
+  console.error('Watcher smoke crashed:', err);
+  process.exit(1);
+});

package/tests/optspec.ts

@@ -0,0 +1,194 @@
+/**
+ * MCP test for the AI-agent optimization features:
+ *   §1 token-budget truncation envelope (deterministic prefix-trim)
+ *   §2 did-you-mean fuzzy fallback (suggestion-only, never substitute)
+ *   §3 seer_skeleton (deterministic source elision + focus expansion)
+ *   §4 seer_batch (multi-tool fan-out in one call)
+ *   §5a lazy lifecycle (build tools rebranded; dependents auto-build)
+ *   §5b seer_trace umbrella (scope-dispatch over the seer_trace_* family)
+ *
+ * Spawns `seer mcp` against fixtures-tracke and drives it over stdio.
+ * Run: npx tsx tests/optspec.ts
+ */
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+
+const ROOT = path.resolve(__dirname, '..');
+const FIX = path.join(ROOT, 'tests/fixtures-tracke');
+const TMP_WS = path.join(os.tmpdir(), `seer-optspec-${Date.now()}`);
+const CLI = path.join(ROOT, 'dist/cli/index.js');
+
+let passed = 0;
+let failed = 0;
+const ok = (m: string): void => { passed++; console.log(`  ✓ ${m}`); };
+const bad = (m: string, x?: unknown): void => {
+  failed++;
+  console.error(`  ✗ ${m}` + (x !== undefined ? `  ::  ${JSON.stringify(x).slice(0, 240)}` : ''));
+};
+const check = (cond: boolean, m: string, x?: unknown): void => { cond ? ok(m) : bad(m, x); };
+
+function copyRecursive(src: string, dst: string): void {
+  fs.mkdirSync(dst, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, entry.name);
+    const d = path.join(dst, entry.name);
+    if (entry.isDirectory()) copyRecursive(s, d);
+    else fs.copyFileSync(s, d);
+  }
+}
+
+async function main(): Promise<void> {
+  console.log('\nSeer MCP Optimization-Spec Tests\n================================\n');
+  copyRecursive(FIX, TMP_WS);
+
+  const proc = spawn(process.execPath, [CLI, 'mcp', '--workspace', TMP_WS, '--no-watch', '--no-jit'],
+    { stdio: ['pipe', 'pipe', 'pipe'] });
+  proc.stderr.on('data', (d) => process.stderr.write(`[mcp-stderr] ${d}`));
+
+  let buf = '';
+  const pending = new Map<number, (msg: any) => void>();
+  proc.stdout.on('data', (chunk: Buffer) => {
+    buf += chunk.toString('utf8');
+    let nl: number;
+    while ((nl = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line) continue;
+      let msg: any;
+      try { msg = JSON.parse(line); } catch { continue; }
+      if (msg.id != null && pending.has(msg.id)) { pending.get(msg.id)!(msg); pending.delete(msg.id); }
+    }
+  });
+
+  let nextId = 1;
+  const call = (method: string, params: any): Promise<any> => {
+    const id = nextId++;
+    return new Promise((resolve, reject) => {
+      pending.set(id, resolve);
+      proc.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
+      setTimeout(() => { if (pending.has(id)) { pending.delete(id); reject(new Error(`timeout ${method}`)); } }, 30_000);
+    });
+  };
+  const callTool = async (name: string, args: any = {}): Promise<any> => {
+    const r = await call('tools/call', { name, arguments: args });
+    return JSON.parse(r.result?.content?.[0]?.text ?? '{}');
+  };
+
+  // ── init ──
+  let initOk = false;
+  for (let i = 0; i < 30; i++) {
+    try {
+      const r = await call('initialize', { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 't', version: '0' } });
+      if (r.result) { initOk = true; break; }
+    } catch { /* */ }
+    await new Promise(r => setTimeout(r, 500));
+  }
+  if (initOk) ok('initialize'); else { bad('initialize'); process.exit(1); }
+
+  // ── tools/list advertises the new surface ──
+  const list = await call('tools/list', {});
+  const tools: Array<{ name: string; description: string }> = list.result?.tools ?? [];
+  const names = tools.map(t => t.name);
+  for (const n of ['seer_skeleton', 'seer_trace', 'seer_batch']) {
+    check(names.includes(n), `tools/list advertises ${n}`, names);
+  }
+  // §5a: build tools rebranded as advanced
+  for (const n of ['seer_modules_build', 'seer_shape_hash_build', 'seer_symbol_history_build']) {
+    const d = tools.find(t => t.name === n)?.description ?? '';
+    check(/advanced/i.test(d), `${n} description marked advanced/automatic`, d);
+  }
+
+  // ── §3 seer_skeleton ──────────────────────────────────────────────────
+  const sk = await callTool('seer_skeleton', { file: 'auth/AuthService.ts' });
+  check(sk.ok === true, 'seer_skeleton resolves file by rel_path fragment', sk);
+  check(typeof sk.skeleton === 'string' && sk.skeleton.includes('AuthService'),
+    'skeleton shows the class AuthService', sk.skeleton);
+  check(/login/.test(sk.skeleton) && /logout/.test(sk.skeleton),
+    'skeleton shows nested methods login/logout', sk.skeleton);
+  check(/validateCredentials/.test(sk.skeleton), 'skeleton shows free function validateCredentials', sk.skeleton);
+  check(/\{ … \d+ lines … \}/.test(sk.skeleton), 'skeleton collapses bodies with exact line-count fold markers', sk.skeleton);
+  // Bodies must NOT appear verbatim (no focus): the literal call should be hidden.
+  check(!sk.skeleton.includes('invalidateToken(token)'), 'skeleton elides body source (no focus)', sk.skeleton);
+
+  // Determinism: identical render twice.
+  const sk2 = await callTool('seer_skeleton', { file: 'auth/AuthService.ts' });
+  check(sk2.skeleton === sk.skeleton, 'seer_skeleton is deterministic (byte-identical re-render)');
+
+  // Focus expands a single body verbatim.
+  const skf = await callTool('seer_skeleton', { file: 'auth/AuthService.ts', focusSymbol: 'login' });
+  check(/◀ focus/.test(skf.skeleton) && skf.skeleton.includes('hashPassword(password)'),
+    'seer_skeleton focusSymbol expands the target body verbatim', skf.skeleton);
+
+  const skMiss = await callTool('seer_skeleton', { file: 'does/not/exist.ts' });
+  check(skMiss.ok === false, 'seer_skeleton returns ok:false for an unknown file', skMiss);
+
+  // ── §2 did-you-mean ───────────────────────────────────────────────────
+  const exact = await callTool('seer_definition', { name: 'validateCredentials' });
+  check((exact.items ?? []).length >= 1 && exact.didYouMean === undefined,
+    'seer_definition exact hit carries NO didYouMean', exact);
+
+  const typo = await callTool('seer_definition', { name: 'validateCredential' }); // missing trailing s
+  check((typo.items ?? []).length === 0, 'seer_definition typo returns zero exact items', typo);
+  check(Array.isArray(typo.didYouMean) && typo.didYouMean.some((d: any) => d.name === 'validateCredentials'),
+    'seer_definition typo surfaces didYouMean → validateCredentials (suggestion-only)', typo.didYouMean);
+
+  const riskMiss = await callTool('seer_risk', { symbol: 'validateCredential' });
+  check(riskMiss.found === false && Array.isArray(riskMiss.didYouMean) && riskMiss.didYouMean.length > 0,
+    'seer_risk on a missing symbol returns found:false + didYouMean (never computes on a guess)', riskMiss);
+
+  // ── §1 token budget ───────────────────────────────────────────────────
+  const full = await callTool('seer_symbols', { query: 'a', limit: 200 });
+  const tiny = await callTool('seer_symbols', { query: 'a', limit: 200, tokenBudget: 60 });
+  check(full.truncated === undefined, 'seer_symbols without tokenBudget is not flagged truncated', full.truncated);
+  check(tiny.truncated === true && tiny.returned <= full.returned,
+    'seer_symbols tokenBudget trims items and flags truncated', { full: full.returned, tiny: tiny.returned });
+  check(tiny.returned >= 1, 'token budget always keeps at least one item', tiny.returned);
+  check(JSON.stringify(tiny).length <= JSON.stringify(full).length,
+    'budgeted payload is no larger than the full payload', { t: JSON.stringify(tiny).length, f: JSON.stringify(full).length });
+
+  // ── §5b seer_trace umbrella ───────────────────────────────────────────
+  const tr = await callTool('seer_trace', { scope: 'callers', args: { symbol: 'validateCredentials', maxDepth: 4 } });
+  const trDirect = await callTool('seer_trace_callers', { symbol: 'validateCredentials', maxDepth: 4 });
+  check((tr.total ?? -1) === (trDirect.total ?? -2),
+    'seer_trace scope=callers matches seer_trace_callers directly', { umbrella: tr.total, direct: trDirect.total });
+  const trFile = await callTool('seer_trace', { scope: 'file', args: { file: 'billing/Billing.ts', maxDepth: 3 } });
+  check(trFile.from != null || trFile.found === false, 'seer_trace scope=file delegates to file-dependency trace', trFile);
+  const trBad = await callTool('seer_trace', { scope: 'callers', args: {} });
+  check(trBad.found === false || trBad.error != null, 'seer_trace passes through delegate errors', trBad);
+
+  // ── §4 seer_batch ─────────────────────────────────────────────────────
+  const batch = await callTool('seer_batch', { calls: [
+    { tool: 'seer_definition', args: { name: 'validateCredentials' } },
+    { tool: 'seer_callers', args: { symbol: 'validateCredentials' } },
+    { tool: 'seer_skeleton', args: { file: 'auth/AuthService.ts' } },
+    { tool: 'seer_definition', args: { name: '__nope__' } },
+  ] });
+  check(batch.batch === true && batch.count === 4, 'seer_batch returns all 4 results', batch.count);
+  check(batch.results[0].ok === true && (batch.results[0].result.items ?? []).length >= 1,
+    'seer_batch result[0] = definition hit', batch.results[0]);
+  check(batch.results[2].ok === true && batch.results[2].result.ok === true,
+    'seer_batch result[2] = skeleton ok', batch.results[2]);
+  check(batch.results[3].ok === true && (batch.results[3].result.items ?? []).length === 0,
+    'seer_batch tolerates a sub-call that finds nothing (still ok:true wrapper)', batch.results[3]);
+
+  const batchNest = await callTool('seer_batch', { calls: [{ tool: 'seer_batch', args: {} }] });
+  check(batchNest.results[0].ok === false && /nested|disallowed/i.test(batchNest.results[0].error),
+    'seer_batch refuses to nest', batchNest.results[0]);
+  const batchUnknown = await callTool('seer_batch', { calls: [{ tool: 'seer_nonexistent', args: {} }] });
+  check(batchUnknown.results[0].ok === false && /unknown/i.test(batchUnknown.results[0].error),
+    'seer_batch reports unknown tool without aborting', batchUnknown.results[0]);
+
+  // ── §5a dependents still serve data (auto-build path doesn't break) ────
+  const dup = await callTool('seer_duplicates', {});
+  check(typeof dup.clusters === 'number', 'seer_duplicates serves after lazy shape-hash guard', dup);
+  const mods = await callTool('seer_modules', {});
+  check((mods.total ?? 0) >= 1, 'seer_modules serves after lazy modules guard', mods);
+
+  proc.kill();
+  console.log(`\n${passed} passed, ${failed} failed\n`);
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+main().catch((e) => { console.error(e); process.exit(2); });