@voeu/cli 0.1.0 → 0.1.1

package/README.md

@@ -124,6 +124,10 @@ That seam is deliberate: a harness that supplies its own session store proves on
 it supplied works. A partly-filled adapter still gives honest answers, because scenarios it cannot
 exercise report UNPROVEN rather than passing.
 
+A TypeScript adapter runs as written: `verify` loads `.ts` modules itself, following `.js`-suffixed
+imports, extensionless ones and tsconfig `paths` the way your compiler would, with no build step and
+no type checking. In CI it reads `DATABASE_URL` when `voeu.config.json` names no database.
+
 `npx @voeu/cli verify --reference` runs the whole suite against a built-in application, so you can see
 the output before writing anything.
 

package/dist/build-info.json

@@ -1,8 +1,9 @@
 {
-  "version": "0.1.0",
-  "bytes": 252644,
+  "version": "0.1.1",
+  "bytes": 256864,
+  "hooksBytes": 6800,
   "externals": [
     "ts-parser"
   ],
-  "inputs": 43
+  "inputs": 45
 }

package/dist/ts-loader-hooks.js

@@ -0,0 +1,186 @@
+import { createRequire as __voeuCreateRequire } from 'node:module';
+const require = __voeuCreateRequire(import.meta.url);
+
+// packages/cli/src/ts-loader-hooks.ts
+import { readFileSync, statSync } from "node:fs";
+import { dirname, extname, isAbsolute, join, resolve as resolvePath } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import ts from "ts-parser";
+var repoRoot = "";
+function initialize(data) {
+  repoRoot = data.repoRoot;
+}
+var TS_SOURCE = /\.(ts|tsx|mts|cts)$/;
+var SIBLINGS = {
+  ".js": [".ts", ".tsx"],
+  ".mjs": [".mts"],
+  ".cjs": [".cts"],
+  ".jsx": [".tsx"]
+};
+var EXTENSIONS = [".ts", ".tsx", ".mts", ".js", ".mjs", ".cjs", ".json"];
+var INDEXES = EXTENSIONS.map((e) => `index${e}`);
+var NOT_FOUND = /* @__PURE__ */ new Set(["ERR_MODULE_NOT_FOUND", "ERR_UNSUPPORTED_DIR_IMPORT"]);
+function isFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function probe(base) {
+  if (isFile(base)) return base;
+  const ext = extname(base);
+  for (const sibling of SIBLINGS[ext] ?? []) {
+    const candidate = base.slice(0, -ext.length) + sibling;
+    if (isFile(candidate)) return candidate;
+  }
+  for (const extension of EXTENSIONS) if (isFile(base + extension)) return base + extension;
+  for (const index of INDEXES) if (isFile(join(base, index))) return join(base, index);
+  return null;
+}
+var pathMaps = /* @__PURE__ */ new Map();
+function pathMapFor(dir) {
+  const cached = pathMaps.get(dir);
+  if (cached !== void 0) return cached;
+  const visited = [];
+  let current = dir;
+  let found = null;
+  for (; ; ) {
+    visited.push(current);
+    const file = join(current, "tsconfig.json");
+    if (isFile(file)) {
+      found = readPathMap(file);
+      break;
+    }
+    const parent = dirname(current);
+    if (current === repoRoot || parent === current) break;
+    current = parent;
+  }
+  for (const d of visited) pathMaps.set(d, found);
+  return found;
+}
+function readPathMap(file) {
+  const read = ts.readConfigFile(file, ts.sys.readFile);
+  if (read.error || typeof read.config !== "object" || read.config === null) return null;
+  const raw = { ...read.config, files: [], include: [] };
+  const parsed = ts.parseJsonConfigFileContent(raw, ts.sys, dirname(file), void 0, file);
+  const options = parsed.options;
+  const paths = options.paths ?? {};
+  const patterns = Object.entries(paths).map(([key, targets]) => ({ key, targets })).sort((a, b) => b.key.length - a.key.length);
+  if (patterns.length === 0 && options.baseUrl === void 0) return null;
+  return { base: options.baseUrl ?? options.pathsBasePath ?? dirname(file), patterns };
+}
+function mapThroughPaths(specifier, map) {
+  const out = [];
+  for (const { key, targets } of map.patterns) {
+    const star = key.indexOf("*");
+    if (star === -1) {
+      if (specifier === key) out.push(...targets.map((t) => resolvePath(map.base, t)));
+      continue;
+    }
+    const prefix = key.slice(0, star);
+    const suffix = key.slice(star + 1);
+    if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix)) continue;
+    if (specifier.length < prefix.length + suffix.length) continue;
+    const matched = specifier.slice(prefix.length, specifier.length - suffix.length);
+    out.push(...targets.map((t) => resolvePath(map.base, t.replace("*", matched))));
+  }
+  if (out.length === 0 && map.patterns.length === 0) out.push(resolvePath(map.base, specifier));
+  return out;
+}
+function parentPath(parentURL) {
+  if (!parentURL || !parentURL.startsWith("file:")) return null;
+  const path = fileURLToPath(parentURL);
+  if (path.split(/[\\/]/).includes("node_modules")) return null;
+  return path;
+}
+function findTypeScriptTarget(specifier, parent) {
+  if (specifier.startsWith("./") || specifier.startsWith("../") || specifier === "." || specifier === "..") {
+    return probe(resolvePath(dirname(parent), specifier));
+  }
+  if (specifier.startsWith("file:")) return probe(fileURLToPath(specifier));
+  if (isAbsolute(specifier)) return probe(specifier);
+  if (specifier.startsWith("node:") || specifier.startsWith("data:")) return null;
+  const map = pathMapFor(dirname(parent));
+  if (map === null) return null;
+  for (const candidate of mapThroughPaths(specifier, map)) {
+    const found = probe(candidate);
+    if (found !== null) return found;
+  }
+  return null;
+}
+async function resolve(specifier, context, nextResolve) {
+  try {
+    return await nextResolve(specifier, context);
+  } catch (error) {
+    const code = error.code ?? "";
+    if (!NOT_FOUND.has(code)) throw error;
+    const parent = parentPath(context.parentURL);
+    if (parent === null) throw error;
+    const found = findTypeScriptTarget(specifier, parent);
+    if (found === null) throw error;
+    return { url: pathToFileURL(found).href, shortCircuit: true };
+  }
+}
+var packageTypes = /* @__PURE__ */ new Map();
+function packageType(dir) {
+  const cached = packageTypes.get(dir);
+  if (cached !== void 0) return cached;
+  let type = null;
+  const file = join(dir, "package.json");
+  if (isFile(file)) {
+    try {
+      type = JSON.parse(readFileSync(file, "utf8")).type ?? "commonjs";
+    } catch {
+      type = null;
+    }
+  } else {
+    const parent = dirname(dir);
+    type = parent === dir ? null : packageType(parent);
+  }
+  packageTypes.set(dir, type);
+  return type;
+}
+var ESM_SYNTAX = /^\s*(?:import\s+[\w{*"'\s]|import\s*\(|export\s+)/m;
+function formatFor(path, source) {
+  if (path.endsWith(".mts")) return "module";
+  if (path.endsWith(".cts")) return "commonjs";
+  if (packageType(dirname(path)) === "module") return "module";
+  return ESM_SYNTAX.test(source) ? "module" : "commonjs";
+}
+function transpile(path, source, format) {
+  return ts.transpileModule(source, {
+    fileName: path,
+    reportDiagnostics: false,
+    compilerOptions: {
+      module: format === "module" ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS,
+      target: ts.ScriptTarget.ES2022,
+      jsx: ts.JsxEmit.ReactJSX,
+      esModuleInterop: true,
+      isolatedModules: true,
+      // Type-only imports vanish; an import used only in type positions is
+      // elided too, so a module that exports a type and nothing else is never
+      // asked for a runtime binding it does not have.
+      verbatimModuleSyntax: false,
+      useDefineForClassFields: true,
+      inlineSourceMap: true,
+      inlineSources: false
+    }
+  }).outputText;
+}
+async function load(url, context, nextLoad) {
+  if (!url.startsWith("file:") || !TS_SOURCE.test(new URL(url).pathname)) return nextLoad(url, context);
+  const path = fileURLToPath(url);
+  const source = readFileSync(path, "utf8");
+  const format = formatFor(path, source);
+  return { format, source: transpile(path, source, format), shortCircuit: true };
+}
+export {
+  findTypeScriptTarget,
+  formatFor,
+  initialize,
+  load,
+  probe,
+  resolve,
+  transpile
+};

package/dist/voeu.js

@@ -159,6 +159,8 @@ function snapshotFromFiles(files, options = {}) {
     byPath: new Map(parsed.map((f) => [f.path, f])),
     packageJson: options.packageJson ?? null,
     lockfileHash: options.lockfileHash ?? null,
+    // A test that hands over a lockfile by content means the lockfile exists.
+    lockfile: options.lockfile ?? LOCKFILE_NAMES.find((name) => files.has(name)) ?? null,
     truncated: options.truncated ?? false,
     unparsed,
     nestedPackages: [...options.nestedPackages ?? []]
@@ -226,9 +228,11 @@ function loadRepo(root) {
     }
   }
   let lockfileHash = null;
+  let lockfile = null;
   for (const name of LOCKFILE_NAMES) {
     try {
       lockfileHash = hashString(readFileSync(join(root, name), "utf8"));
+      lockfile = name;
       break;
     } catch {
     }
@@ -239,6 +243,7 @@ function loadRepo(root) {
     byPath: new Map(files.map((f) => [f.path, f])),
     packageJson,
     lockfileHash,
+    lockfile,
     truncated,
     unparsed,
     nestedPackages
@@ -2020,6 +2025,22 @@ var SCENARIOS = [
 
 // packages/harness/src/run.ts
 var DEFAULT_START = Date.parse("2026-09-08T12:00:00.000Z");
+var DEFAULT_SCENARIO_TIMEOUT_MS = 6e4;
+var STOP_TIMEOUT_MS = 5e3;
+var Timeout = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "Timeout";
+  }
+};
+function within(ms, work, what) {
+  let timer;
+  const expiry = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Timeout(what)), ms);
+  });
+  work.catch(() => void 0);
+  return Promise.race([work, expiry]).finally(() => clearTimeout(timer));
+}
 var OPTIONAL_CAPABILITIES = [
   "peekQueue",
   "withSecondProcess",
@@ -2030,6 +2051,7 @@ var OPTIONAL_CAPABILITIES = [
 async function runSuite(options) {
   const scenarios = options.scenarios ?? SCENARIOS;
   const outcomes = [];
+  const budget = options.scenarioTimeoutMs ?? DEFAULT_SCENARIO_TIMEOUT_MS;
   for (const scenario of scenarios) {
     let clock = options.startedAt ?? DEFAULT_START;
     const now = () => clock;
@@ -2041,18 +2063,33 @@ async function runSuite(options) {
     const url = await simulator.listen();
     const app = await options.makeApp();
     try {
-      await app.start({ simulatorUrl: url, databaseUrl: options.databaseUrl ?? "", now });
-      options.observe?.(app);
-      const capabilities = new Set(
-        OPTIONAL_CAPABILITIES.filter((name) => typeof app[name] === "function")
-      );
-      const outcome = await runScenario(scenario, {
-        app,
-        simulator,
-        advance,
-        now,
-        faults: simulator.faults,
-        capabilities
+      const started = Date.now();
+      const outcome = await within(
+        budget,
+        (async () => {
+          await app.start({ simulatorUrl: url, databaseUrl: options.databaseUrl ?? "", now });
+          options.observe?.(app);
+          const capabilities = new Set(
+            OPTIONAL_CAPABILITIES.filter((name) => typeof app[name] === "function")
+          );
+          return runScenario(scenario, {
+            app,
+            simulator,
+            advance,
+            now,
+            faults: simulator.faults,
+            capabilities
+          });
+        })(),
+        scenario.id
+      ).catch((error) => {
+        if (!(error instanceof Timeout)) throw error;
+        return {
+          scenario,
+          verdict: "not_verified",
+          detail: `The scenario was still running after ${Math.round(budget / 1e3)} s and was abandoned. Scenarios move a simulated clock, so real time goes only to the application's own I/O; a scenario that does not finish is stuck on it - most often a queue or database client waiting for a connection that will never come. Nothing was established either way.`,
+          durationMs: Date.now() - started
+        };
       });
       const internal = simulator.requests.filter((r) => r.outcome === "internal");
       outcomes.push(
@@ -2070,7 +2107,7 @@ async function runSuite(options) {
         durationMs: 0
       });
     } finally {
-      await app.stop().catch(() => void 0);
+      await within(STOP_TIMEOUT_MS, Promise.resolve().then(() => app.stop()), `${scenario.id} stop`).catch(() => void 0);
       await simulator.close();
     }
   }
@@ -4867,6 +4904,22 @@ function renderHtml(run) {
 `;
 }
 
+// packages/cli/src/ts-loader.ts
+import { existsSync } from "node:fs";
+import { register } from "node:module";
+import { fileURLToPath } from "node:url";
+var registered = false;
+function registerTypeScriptLoader(repoRoot) {
+  if (registered) return { registered: true, reason: null };
+  const hooks = new URL("./ts-loader-hooks.js", import.meta.url);
+  if (!existsSync(fileURLToPath(hooks))) {
+    return { registered: false, reason: `no ${fileURLToPath(hooks)} beside the CLI, so TypeScript adapters load only if the host can` };
+  }
+  register(hooks, { parentURL: import.meta.url, data: { repoRoot } });
+  registered = true;
+  return { registered: true, reason: null };
+}
+
 // packages/fixer/src/diff.ts
 var MAX_CELLS = 4e6;
 function lcsOps(before, after) {
@@ -5756,6 +5809,24 @@ async function runVerifyStripe(args) {
   emit(run, args, null);
   return verdictExit(run);
 }
+async function recordingBackgroundErrors(work) {
+  const errors = [];
+  const describe2 = (error) => error instanceof Error ? error.message : String(error);
+  const onRejection = (reason) => {
+    errors.push(`unhandled rejection: ${describe2(reason)}`);
+  };
+  const onException = (error) => {
+    errors.push(`uncaught exception: ${describe2(error)}`);
+  };
+  process.on("unhandledRejection", onRejection);
+  process.on("uncaughtException", onException);
+  try {
+    return { result: await work(), errors };
+  } finally {
+    process.off("unhandledRejection", onRejection);
+    process.off("uncaughtException", onException);
+  }
+}
 async function runVerify(args) {
   if (args.provider === "stripe") return runVerifyStripe(args);
   if (args.reference) {
@@ -5778,27 +5849,54 @@ async function runVerify(args) {
     );
     return EXIT.UNSUPPORTED;
   }
+  let loader;
+  try {
+    loader = registerTypeScriptLoader(root);
+  } catch (error) {
+    process.stderr.write(
+      `voeu: could not start the TypeScript loader: ${error instanceof Error ? error.message : error}
+`
+    );
+    return EXIT.INFRASTRUCTURE;
+  }
   let makeApp;
   try {
     makeApp = await loadAdapter(root, config.adapter);
   } catch (error) {
     process.stderr.write(
       `voeu: could not load adapter ${config.adapter}: ${error instanceof Error ? error.message : error}
-`
+${loader.registered ? "" : `  (${loader.reason})
+`}`
     );
     return EXIT.UNSUPPORTED;
   }
   try {
-    const run = await verify({
-      makeApp,
-      group: "independent",
-      targetName: args.name ?? basename(root),
-      targetPath: root,
-      databaseUrl: config.databaseUrl,
-      // A verify run reported from CI is matched to the hosted inspect of the
-      // same commit; without this it arrives as a run about no commit at all.
-      baseCommit: commitOf(root)
-    });
+    const { result: verified, errors } = await recordingBackgroundErrors(
+      () => verify({
+        makeApp,
+        group: "independent",
+        targetName: args.name ?? basename(root),
+        targetPath: root,
+        // The generated workflow starts Postgres as a job service and names it in
+        // DATABASE_URL; an adapter written against the reference reads
+        // `env.databaseUrl` and would otherwise be handed "" in the one place it
+        // matters most. The config still wins when it says.
+        databaseUrl: config.databaseUrl ?? process.env["DATABASE_URL"],
+        // A verify run reported from CI is matched to the hosted inspect of the
+        // same commit; without this it arrives as a run about no commit at all.
+        baseCommit: commitOf(root)
+      })
+    );
+    const run = errors.length === 0 ? verified : {
+      ...verified,
+      limitations: [
+        ...verified.limitations,
+        {
+          scope: "application",
+          reason: `The application raised ${errors.length} error(s) outside any scenario's control flow - an unhandled promise rejection or an uncaught exception - which would have ended this process before the report existed. Recorded rather than fatal: the scenarios decided what they decided, and the errors are the application's to explain. First: ${errors[0]}`
+        }
+      ]
+    };
     emit(run, args, null);
     return verdictExit(run);
   } catch (error) {
@@ -6176,13 +6274,12 @@ async function runCli(argv) {
 }
 
 // packages/cli/src/bin.ts
-runCli(process.argv.slice(2)).then(
-  (code) => {
-    process.exitCode = code;
-  },
-  (error) => {
-    process.stderr.write(`voeu: ${error instanceof Error ? error.message : String(error)}
+function exit(code) {
+  process.exitCode = code;
+  process.stdout.write("", () => process.exit(code));
+}
+runCli(process.argv.slice(2)).then(exit, (error) => {
+  process.stderr.write(`voeu: ${error instanceof Error ? error.message : String(error)}
 `);
-    process.exitCode = 3;
-  }
-);
+  exit(3);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voeu/cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Keep integrations working when providers change. Assess and verify Shopify apps against the expiring offline access token contract.",
   "type": "module",
   "bin": {