@usejourney/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1840 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { resolve as resolvePath } from "path";
+import { Command } from "commander";
+
+// src/commands/envList.ts
+import { listEnvironments, loadConfig, resolveConfigPaths } from "@usejourney/core";
+async function runEnvList(projectDir) {
+  const loaded = await loadConfig(projectDir);
+  const { environmentsDir } = resolveConfigPaths(loaded);
+  const envs = await listEnvironments(environmentsDir);
+  if (envs.length === 0) {
+    console.log(`No environments found in ${environmentsDir}`);
+    return;
+  }
+  const def = loaded.config.defaultEnvironment;
+  for (const name of envs) {
+    console.log(name === def ? `* ${name}` : `  ${name}`);
+  }
+}
+
+// src/commands/exportK6.ts
+import { stat } from "fs/promises";
+import { isAbsolute, resolve } from "path";
+import { exportToK6 } from "@usejourney/k6-adapter";
+
+// src/util/discover.ts
+import { readdir } from "fs/promises";
+import { join } from "path";
+async function discoverJourneyFiles(journeysDir) {
+  try {
+    const entries = await readdir(journeysDir);
+    return entries.filter((e) => e.endsWith(".journey.ts")).sort().map((e) => join(journeysDir, e));
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+}
+
+// src/util/loadJourneyFile.ts
+import { pathToFileURL } from "url";
+import { clearRegistry, getRegisteredJourneys } from "@usejourney/core";
+import { tsImport } from "tsx/esm/api";
+async function loadJourneyDefs(file) {
+  clearRegistry();
+  await tsImport(pathToFileURL(file).href, import.meta.url);
+  const defs = getRegisteredJourneys().slice();
+  clearRegistry();
+  return defs;
+}
+async function importJourneyFiles(files) {
+  clearRegistry();
+  for (const file of files) {
+    await tsImport(pathToFileURL(file).href, import.meta.url);
+  }
+}
+
+// src/commands/exportK6.ts
+function matches(def, tags) {
+  if (tags.length === 0) return true;
+  return tags.every((t) => def.options?.tags?.includes(t) === true);
+}
+function pickK6Options(file, matching) {
+  const withK6 = matching.filter((d) => d.options?.k6);
+  if (withK6.length === 0) return void 0;
+  if (withK6.length > 1) {
+    const names = withK6.map((d) => `"${d.name}"`).join(", ");
+    throw new Error(
+      `${file}: ${withK6.length} journeys declare k6 options (${names}). k6 'export const options' is module-scoped \u2014 split into separate files or remove all but one k6 config block.`
+    );
+  }
+  return withK6[0].options.k6;
+}
+async function runExportK6(opts) {
+  const target = isAbsolute(opts.path) ? opts.path : resolve(process.cwd(), opts.path);
+  const tags = opts.tags ?? [];
+  let info;
+  try {
+    info = await stat(target);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw new Error(`Path not found: ${opts.path}`);
+    }
+    throw err;
+  }
+  const isDir = info.isDirectory();
+  if (isDir && opts.out) {
+    throw new Error(
+      "--out is only valid with a single journey file. Use --out-dir for directories."
+    );
+  }
+  const files = isDir ? await discoverJourneyFiles(target) : [target];
+  if (files.length === 0) {
+    console.log(`No .journey.ts files found in ${opts.path}`);
+    return 0;
+  }
+  const work = [];
+  for (const file of files) {
+    const defs = await loadJourneyDefs(file);
+    work.push({ file, defs });
+  }
+  let exported = 0;
+  for (const { file, defs } of work) {
+    const matching = defs.filter((d) => matches(d, tags));
+    if (matching.length === 0) {
+      if (tags.length > 0) console.log(`Skipped (no matching journey) \u2192 ${file}`);
+      continue;
+    }
+    const k6Options = pickK6Options(file, matching);
+    const result = await exportToK6({
+      journeyFile: file,
+      ...opts.out !== void 0 ? { outFile: opts.out } : {},
+      ...opts.outDir !== void 0 ? { outDir: opts.outDir } : {},
+      ...k6Options !== void 0 ? { k6Options } : {}
+    });
+    console.log(`Wrote k6 script \u2192 ${result.outFile}`);
+    exported++;
+  }
+  if (exported === 0 && tags.length > 0) {
+    console.log(`No journeys matched tags: ${tags.join(", ")}`);
+  }
+  return 0;
+}
+
+// src/commands/exportPostman.ts
+import { mkdir, stat as stat2, writeFile } from "fs/promises";
+import { basename, dirname, isAbsolute as isAbsolute2, join as join2, resolve as resolve2 } from "path";
+import {
+  clearActiveEnvironment,
+  collectPipeline,
+  collectSubPipeline,
+  listEnvironments as listEnvironments2,
+  loadConfig as loadConfig2,
+  loadEnvironment,
+  resolveConfigPaths as resolveConfigPaths2,
+  setActiveEnvironment
+} from "@usejourney/core";
+import {
+  ENV_PROXY,
+  buildCollection,
+  buildEnvironment,
+  buildFolder
+} from "@usejourney/postman-adapter";
+var MAX_SUB_DEPTH = 8;
+function firstIdentParam(src) {
+  const s = src.trim();
+  const bare = /^(?:async\s+)?([A-Za-z_$][\w$]*)\s*=>/.exec(s);
+  if (bare) return bare[1];
+  const paren = /^(?:async\s+)?(?:function\b[^(]*)?\(([^)]*)\)/.exec(s);
+  if (!paren) return void 0;
+  const first = paren[1].split(",")[0].trim();
+  return /^[A-Za-z_$][\w$]*$/.test(first) ? first : void 0;
+}
+function buildInputThread(call) {
+  if (typeof call.inputs !== "function") return void 0;
+  const inputParam = firstIdentParam(call.handle.__def.body.toString());
+  if (!inputParam) return void 0;
+  return { inputsSrc: call.inputs.toString(), inputParam };
+}
+async function resolveSubInputs(call) {
+  const raw = call.inputs;
+  if (raw === void 0) return void 0;
+  try {
+    const value = typeof raw === "function" ? await raw() : raw;
+    return value && typeof value === "object" ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveSubCache(call, inputs) {
+  if (call.cacheKey === void 0 || call.cache === "off") return {};
+  let resolvedKey;
+  try {
+    const rk = typeof call.cacheKey === "function" ? call.cacheKey(inputs) : call.cacheKey;
+    if (typeof rk !== "string") return {};
+    resolvedKey = rk;
+  } catch {
+    return {};
+  }
+  return {
+    cacheKey: `${call.handle.name}:${resolvedKey}`,
+    ...call.cacheTtlMs !== void 0 ? { cacheTtlMs: call.cacheTtlMs } : {}
+  };
+}
+async function toExportNodes(nodes, depth) {
+  const out = [];
+  for (const node of nodes) {
+    if (node.kind === "step") {
+      out.push({ kind: "step", def: node.def });
+      continue;
+    }
+    const name = node.def.name ?? node.def.handle.name;
+    const inputs = await resolveSubInputs(node.def);
+    let childNodes = [];
+    if (depth < MAX_SUB_DEPTH) {
+      try {
+        const childPipeline = await collectSubPipeline(node.def);
+        childNodes = await toExportNodes(childPipeline, depth + 1);
+      } catch {
+      }
+    }
+    const cache = resolveSubCache(node.def, inputs);
+    const inputThread = buildInputThread(node.def);
+    out.push({
+      kind: "sub",
+      name,
+      ...inputs ? { inputs } : {},
+      ...inputThread ?? {},
+      ...cache,
+      ...node.def.after ? { after: node.def.after } : {},
+      ...node.def.assert ? { assert: node.def.assert } : {},
+      nodes: childNodes
+    });
+  }
+  return out;
+}
+var BUNDLE_BASENAME = "journeys.postman_collection.json";
+function matches2(def, tags) {
+  if (tags.length === 0) return true;
+  return tags.every((t) => def.options?.tags?.includes(t) === true);
+}
+function uniqueFolderName(name, seen) {
+  const n = seen.get(name) ?? 0;
+  seen.set(name, n + 1);
+  if (n === 0) return name;
+  console.warn(`Duplicate journey name "${name}" across files \u2014 renamed to "${name} (${n + 1})".`);
+  return `${name} (${n + 1})`;
+}
+async function exportEnvironment(environmentsDir, envName, outDir) {
+  const values = await loadEnvironment(environmentsDir, envName);
+  const env = buildEnvironment(envName, values);
+  const outFile = join2(outDir, `${envName}.postman_environment.json`);
+  await mkdir(dirname(outFile), { recursive: true });
+  await writeFile(outFile, JSON.stringify(env, null, 2), "utf8");
+  return outFile;
+}
+async function runExportPostman(opts) {
+  const target = isAbsolute2(opts.path) ? opts.path : resolve2(process.cwd(), opts.path);
+  const tags = opts.tags ?? [];
+  let info;
+  try {
+    info = await stat2(target);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw new Error(`Path not found: ${opts.path}`);
+    }
+    throw err;
+  }
+  const isDir = info.isDirectory();
+  if (isDir && opts.out && !opts.bundle) {
+    throw new Error(
+      "--out is only valid with a single journey file, or with --bundle. Use --out-dir for per-file directory output."
+    );
+  }
+  const files = isDir ? await discoverJourneyFiles(target) : [target];
+  if (files.length === 0) {
+    console.log(`No .journey.ts files found in ${opts.path}`);
+    return 0;
+  }
+  let environmentsDir;
+  if (opts.env || opts.allEnvs) {
+    try {
+      const loaded = await loadConfig2(opts.projectDir ?? process.cwd());
+      environmentsDir = resolveConfigPaths2(loaded).environmentsDir;
+    } catch {
+      throw new Error(
+        "Could not load journey.config.json. --env/--all-envs require a Journey project."
+      );
+    }
+  }
+  setActiveEnvironment("__postman_export__", ENV_PROXY);
+  let exported = 0;
+  const writtenEnvs = /* @__PURE__ */ new Set();
+  async function writeEnvs(envOutDir) {
+    if (!environmentsDir) return;
+    if (opts.allEnvs && !writtenEnvs.has("__all__")) {
+      writtenEnvs.add("__all__");
+      const envNames = await listEnvironments2(environmentsDir);
+      for (const envName of envNames) {
+        const envFile = await exportEnvironment(environmentsDir, envName, envOutDir);
+        console.log(`Wrote Postman environment \u2192 ${envFile}`);
+      }
+    } else if (opts.env && !writtenEnvs.has(opts.env)) {
+      writtenEnvs.add(opts.env);
+      const envFile = await exportEnvironment(environmentsDir, opts.env, envOutDir);
+      console.log(`Wrote Postman environment \u2192 ${envFile}`);
+    }
+  }
+  try {
+    if (opts.bundle) {
+      const mergedFolders = [];
+      const seenNames = /* @__PURE__ */ new Map();
+      for (const file of files) {
+        const defs = await loadJourneyDefs(file);
+        const matching = defs.filter((d) => matches2(d, tags));
+        if (matching.length === 0) {
+          if (tags.length > 0) console.log(`Skipped (no matching journey) \u2192 ${file}`);
+          continue;
+        }
+        for (const def of matching) {
+          const pipeline = await collectPipeline(def);
+          const nodes = await toExportNodes(pipeline, 0);
+          const folder = await buildFolder(def.name, nodes, {
+            ...opts.threadState !== void 0 ? { threadState: opts.threadState } : {},
+            ...opts.lenient !== void 0 ? { lenient: opts.lenient } : {}
+          });
+          folder.name = uniqueFolderName(folder.name, seenNames);
+          mergedFolders.push(folder);
+        }
+      }
+      if (mergedFolders.length === 0) {
+        if (tags.length > 0) console.log(`No journeys matched tags: ${tags.join(", ")}`);
+        return 0;
+      }
+      const outFile = opts.out ? resolve2(process.cwd(), opts.out) : opts.outDir ? resolve2(process.cwd(), opts.outDir, BUNDLE_BASENAME) : resolve2(process.cwd(), BUNDLE_BASENAME);
+      const collection = buildCollection(opts.name ?? "journeys", mergedFolders, {
+        reset: opts.threadState ?? false
+      });
+      const collectionOutDir = dirname(outFile);
+      await mkdir(collectionOutDir, { recursive: true });
+      await writeFile(outFile, JSON.stringify(collection, null, 2), "utf8");
+      console.log(`Wrote Postman collection \u2192 ${outFile}`);
+      exported++;
+      await writeEnvs(opts.outDir ? resolve2(process.cwd(), opts.outDir) : collectionOutDir);
+      return 0;
+    }
+    for (const file of files) {
+      const defs = await loadJourneyDefs(file);
+      const matching = defs.filter((d) => matches2(d, tags));
+      if (matching.length === 0) {
+        if (tags.length > 0) console.log(`Skipped (no matching journey) \u2192 ${file}`);
+        continue;
+      }
+      const fileBase = basename(file).replace(/\.journey\.ts$/, "");
+      const collectionName = opts.name ?? fileBase;
+      const folders = [];
+      for (const def of matching) {
+        const pipeline = await collectPipeline(def);
+        const nodes = await toExportNodes(pipeline, 0);
+        folders.push(
+          await buildFolder(def.name, nodes, {
+            ...opts.threadState !== void 0 ? { threadState: opts.threadState } : {},
+            ...opts.lenient !== void 0 ? { lenient: opts.lenient } : {}
+          })
+        );
+      }
+      const collection = buildCollection(collectionName, folders, {
+        reset: opts.threadState ?? false
+      });
+      const json = JSON.stringify(collection, null, 2);
+      const outFile = opts.out ? resolve2(process.cwd(), opts.out) : opts.outDir ? resolve2(process.cwd(), opts.outDir, `${fileBase}.postman_collection.json`) : join2(dirname(file), `${fileBase}.postman_collection.json`);
+      const collectionOutDir = dirname(outFile);
+      await mkdir(collectionOutDir, { recursive: true });
+      await writeFile(outFile, json, "utf8");
+      console.log(`Wrote Postman collection \u2192 ${outFile}`);
+      exported++;
+      await writeEnvs(opts.outDir ? resolve2(process.cwd(), opts.outDir) : collectionOutDir);
+    }
+  } finally {
+    clearActiveEnvironment();
+  }
+  if (exported === 0 && tags.length > 0) {
+    console.log(`No journeys matched tags: ${tags.join(", ")}`);
+  }
+  return 0;
+}
+
+// src/commands/generate.ts
+import { stat as stat3 } from "fs/promises";
+import { loadConfig as loadConfig3, resolveConfigPaths as resolveConfigPaths3 } from "@usejourney/core";
+import { generate } from "@usejourney/codegen";
+async function runGenerate(projectDir) {
+  const loaded = await loadConfig3(projectDir);
+  const { specPath, generatedDir, journeysDir } = resolveConfigPaths3(loaded);
+  try {
+    await stat3(specPath);
+  } catch {
+    throw new Error(`Spec file not found at ${specPath}`);
+  }
+  const result = await generate({ specPath, outDir: generatedDir });
+  console.log(
+    `Regenerated ${result.operationCount} operations \u2192 ${result.modelsPath}, ${result.endpointsPath}`
+  );
+  await stat3(journeysDir).catch(() => void 0);
+}
+
+// src/commands/init.ts
+import { access, copyFile, mkdir as mkdir2, readdir as readdir2, writeFile as writeFile2 } from "fs/promises";
+import { basename as basename2, isAbsolute as isAbsolute3, join as join3, resolve as resolve3 } from "path";
+import { generate as generate2, loadSpec } from "@usejourney/codegen";
+async function isEmpty(dir) {
+  try {
+    const entries = await readdir2(dir);
+    return entries.length === 0;
+  } catch (err) {
+    if (err.code === "ENOENT") return true;
+    throw err;
+  }
+}
+async function runInit(opts) {
+  const projectDir = isAbsolute3(opts.dir) ? opts.dir : resolve3(process.cwd(), opts.dir);
+  const empty = await isEmpty(projectDir);
+  if (!empty && !opts.force) {
+    throw new Error(
+      `Target directory ${projectDir} is not empty. Pass --force to scaffold anyway.`
+    );
+  }
+  const specSource = isAbsolute3(opts.spec) ? opts.spec : resolve3(process.cwd(), opts.spec);
+  try {
+    await access(specSource);
+  } catch {
+    throw new Error(`Spec file not found: ${specSource}`);
+  }
+  await loadSpec(specSource);
+  const specDestName = basename2(specSource);
+  const specDest = join3(projectDir, specDestName);
+  await mkdir2(projectDir, { recursive: true });
+  await mkdir2(join3(projectDir, "generated"), { recursive: true });
+  await mkdir2(join3(projectDir, "journeys"), { recursive: true });
+  await mkdir2(join3(projectDir, "environments"), { recursive: true });
+  await mkdir2(join3(projectDir, ".journey", "cache"), { recursive: true });
+  await copyFile(specSource, specDest);
+  const config = {
+    name: basename2(projectDir),
+    spec: specDestName,
+    generatedDir: "generated",
+    journeysDir: "journeys",
+    environmentsDir: "environments"
+  };
+  await writeFile2(
+    join3(projectDir, "journey.config.json"),
+    `${JSON.stringify(config, null, 2)}
+`,
+    "utf8"
+  );
+  await writeFile2(join3(projectDir, ".gitignore"), `.journey/cache/
+node_modules/
+`, "utf8");
+  await writeFile2(
+    join3(projectDir, "package.json"),
+    `${JSON.stringify({ name: basename2(projectDir), private: true, type: "module" }, null, 2)}
+`,
+    "utf8"
+  );
+  const generated = await generate2({
+    specPath: specDest,
+    outDir: join3(projectDir, "generated")
+  });
+  console.log(
+    `Initialized Journey project at ${projectDir} (${generated.operationCount} operations).`
+  );
+  if (generated.operationCount === 0) {
+    console.warn(
+      "journey: warning \u2014 spec parsed but contained 0 operations. The generated endpoints.ts will be empty."
+    );
+  }
+}
+
+// src/commands/run.ts
+import { watch } from "fs/promises";
+import { dirname as dirname3, isAbsolute as isAbsolute4, join as join5, resolve as resolve4 } from "path";
+import {
+  clearActiveEnvironment as clearActiveEnvironment2,
+  createConsoleLogger,
+  createSubJourneyCache,
+  loadConfig as loadConfig4,
+  loadEnvironment as loadEnvironment2,
+  loggerFromEnv,
+  pruneRuns,
+  resolveBaseUrl,
+  resolveConfigPaths as resolveConfigPaths4,
+  runAllRegistered,
+  setActiveEnvironment as setActiveEnvironment2,
+  writeRun
+} from "@usejourney/core";
+
+// src/report.ts
+function printResults(results) {
+  for (const r of results) {
+    const marker = r.ok ? "\u2713" : "\u2717";
+    console.log(`${marker} ${r.name} (${r.durationMs}ms)`);
+    for (const s of r.steps) {
+      const sm = s.ok ? "  \u2713" : "  \u2717";
+      const reqStr = s.request ? ` ${s.request.method} ${s.request.url}` : "";
+      const status = s.response ? ` \u2192 ${s.response.status}` : "";
+      console.log(`${sm} ${s.name}${reqStr}${status} (${s.durationMs}ms)`);
+      if (!s.ok && s.error) console.log(`      ${s.error}`);
+    }
+  }
+  const passed = results.filter((r) => r.ok).length;
+  const failed = results.length - passed;
+  console.log(`
+${passed} passed, ${failed} failed`);
+}
+function overallOk(results) {
+  return results.every((r) => r.ok);
+}
+
+// src/util/projectCoreLink.ts
+import { existsSync, readFileSync } from "fs";
+import { mkdir as mkdir3, symlink } from "fs/promises";
+import { dirname as dirname2, join as join4 } from "path";
+import { fileURLToPath } from "url";
+function locateJourneyCoreDir() {
+  let dir = dirname2(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 50; depth++) {
+    const pkgJson = join4(dir, "node_modules", "@usejourney", "core", "package.json");
+    if (existsSync(pkgJson)) {
+      JSON.parse(readFileSync(pkgJson, "utf8"));
+      return dirname2(pkgJson);
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error("ensureProjectCoreLink: could not locate the CLI-bundled @usejourney/core");
+}
+var cachedCoreDir;
+async function ensureProjectCoreLink(projectDir) {
+  const link = join4(projectDir, "node_modules", "@usejourney", "core");
+  if (existsSync(link)) return;
+  if (!cachedCoreDir) cachedCoreDir = locateJourneyCoreDir();
+  await mkdir3(dirname2(link), { recursive: true });
+  const type = process.platform === "win32" ? "junction" : "dir";
+  await symlink(cachedCoreDir, link, type);
+}
+
+// src/commands/run.ts
+var insecureAgent;
+async function enableInsecureTls() {
+  if (!insecureAgent) {
+    const { Agent, setGlobalDispatcher } = await import("undici");
+    insecureAgent = new Agent({ connect: { rejectUnauthorized: false } });
+    setGlobalDispatcher(insecureAgent);
+    console.error("journey: WARNING \u2014 TLS verification disabled (--insecure)");
+  }
+  return insecureAgent;
+}
+async function runCommand(opts) {
+  const loaded = await loadConfig4(opts.projectDir);
+  const paths = resolveConfigPaths4(loaded);
+  clearActiveEnvironment2();
+  const envName = opts.env ?? loaded.config.defaultEnvironment;
+  if (envName) {
+    const values = await loadEnvironment2(paths.environmentsDir, envName);
+    setActiveEnvironment2(envName, values);
+  }
+  const files = opts.all ? await discoverJourneyFiles(paths.journeysDir) : (opts.files ?? []).map((f) => isAbsolute4(f) ? f : resolve4(process.cwd(), f));
+  if (files.length === 0) {
+    throw new Error("No journey files to run.");
+  }
+  await ensureProjectCoreLink(opts.projectDir);
+  await importJourneyFiles(files);
+  const ctx = {};
+  const baseUrl = resolveBaseUrl(loaded.config);
+  if (baseUrl) ctx.baseUrl = baseUrl;
+  const logger = opts.debug ? createConsoleLogger() : loggerFromEnv();
+  if (logger) ctx.logger = logger;
+  if (opts.insecure || loaded.config.tlsRejectUnauthorized === false) {
+    ctx.dispatcher = await enableInsecureTls();
+  }
+  const subCache = createSubJourneyCache(opts.cache ?? "process", {
+    diskDir: join5(opts.projectDir, ".journey", "cache", "sub-journey")
+  });
+  if (subCache) ctx.subJourneyCache = subCache;
+  if (opts.cacheTtlMs !== void 0) ctx.subJourneyCacheTtlMs = opts.cacheTtlMs;
+  const results = await runAllRegistered(ctx);
+  printResults(results);
+  const cacheDir = join5(opts.projectDir, ".journey", "cache");
+  await writeRun(cacheDir, results);
+  await pruneRuns(cacheDir, loaded.config.runHistoryKeepCount);
+  if (!opts.watch) return overallOk(results) ? 0 : 1;
+  const DEBOUNCE_MS = 300;
+  let timer;
+  let running = false;
+  const abortCtrl = new AbortController();
+  const rerun = async () => {
+    if (running) return;
+    running = true;
+    process.stdout.write("\x1Bc");
+    try {
+      await runCommand({ ...opts, watch: false });
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+    } finally {
+      running = false;
+    }
+  };
+  const schedule = () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => void rerun(), DEBOUNCE_MS);
+  };
+  const dirs = /* @__PURE__ */ new Set([paths.journeysDir]);
+  for (const f of files) dirs.add(dirname3(f));
+  const watchers = [];
+  for (const dir of dirs) {
+    try {
+      watchers.push(watch(dir, { recursive: true, signal: abortCtrl.signal }));
+    } catch {
+    }
+  }
+  console.log(`
+Watching for changes in ${[...dirs].join(", ")}\u2026`);
+  console.log("Press Ctrl+C to stop.\n");
+  const consume = async (watcher) => {
+    try {
+      for await (const event of watcher) {
+        const e = event;
+        if (e.filename && (e.filename.endsWith(".ts") || e.filename.endsWith(".json"))) {
+          schedule();
+        }
+      }
+    } catch (err) {
+      if (err.name === "AbortError") return;
+      throw err;
+    }
+  };
+  const exitPromise = new Promise((res) => {
+    const handler = () => {
+      abortCtrl.abort();
+      if (timer) clearTimeout(timer);
+      res();
+    };
+    process.once("SIGINT", handler);
+    process.once("SIGTERM", handler);
+  });
+  await Promise.race([...watchers.map(consume), exitPromise]);
+  return 0;
+}
+
+// src/server/server.ts
+import { createServer } from "http";
+import { readFile as readFile2, readdir as readdir3, stat as stat5, unlink, writeFile as writeFile3 } from "fs/promises";
+import { isAbsolute as isAbsolute7, join as join9 } from "path";
+import {
+  JourneyConfigSchema,
+  createSubJourneyCache as createSubJourneyCache2,
+  listRuns,
+  loadConfig as loadConfig5,
+  listEnvironments as listEnvironments3,
+  readRun,
+  resolveConfigPaths as resolveConfigPaths5
+} from "@usejourney/core";
+import { collectOperations as collectOperations2, generate as generate3, loadSpec as loadSpec3, operationName } from "@usejourney/codegen";
+
+// src/server/runner.ts
+import { isAbsolute as isAbsolute5, join as join6, resolve as resolve5 } from "path";
+import {
+  clearActiveEnvironment as clearActiveEnvironment3,
+  createConsoleLogger as createConsoleLogger2,
+  loadEnvironment as loadEnvironment3,
+  loggerFromEnv as loggerFromEnv2,
+  pruneRuns as pruneRuns2,
+  resolveBaseUrl as resolveBaseUrl2,
+  runAllRegistered as runAllRegistered2,
+  setActiveEnvironment as setActiveEnvironment3,
+  writeRun as writeRun2
+} from "@usejourney/core";
+
+// src/server/consolePatch.ts
+import { inspect } from "util";
+function patchConsole(logger) {
+  if (!logger.onLog) return () => {
+  };
+  const orig = {
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error
+  };
+  const forward = (level, original, args) => {
+    try {
+      logger.onLog?.({ level, text: formatArgs(args) });
+    } catch {
+    }
+    original.apply(console, args);
+  };
+  console.log = (...args) => forward("info", orig.log, args);
+  console.info = (...args) => forward("info", orig.info, args);
+  console.warn = (...args) => forward("warn", orig.warn, args);
+  console.error = (...args) => forward("error", orig.error, args);
+  return () => {
+    console.log = orig.log;
+    console.info = orig.info;
+    console.warn = orig.warn;
+    console.error = orig.error;
+  };
+}
+function formatArgs(args) {
+  return args.map((a) => {
+    if (typeof a === "string") return a;
+    return inspect(a, { depth: 4, colors: false, compact: true });
+  }).join(" ");
+}
+
+// src/server/runner.ts
+async function runJourneyFile(opts) {
+  const abs = isAbsolute5(opts.file) ? opts.file : opts.file.includes("/") || opts.file.includes("\\") ? resolve5(process.cwd(), opts.file) : join6(opts.journeysDir, opts.file);
+  let dispatcher;
+  if (opts.loaded.config.tlsRejectUnauthorized === false) {
+    dispatcher = await enableInsecureTls();
+  }
+  clearActiveEnvironment3();
+  const envName = opts.env ?? opts.loaded.config.defaultEnvironment;
+  if (envName) {
+    const values = await loadEnvironment3(opts.environmentsDir, envName);
+    setActiveEnvironment3(envName, values);
+  }
+  await ensureProjectCoreLink(opts.loaded.projectDir);
+  await importJourneyFiles([abs]);
+  const ctx = {};
+  const baseUrl = resolveBaseUrl2(opts.loaded.config);
+  if (baseUrl) ctx.baseUrl = baseUrl;
+  const logger = opts.logger ?? (opts.debug ? createConsoleLogger2() : loggerFromEnv2());
+  if (logger) ctx.logger = logger;
+  if (dispatcher !== void 0) ctx.dispatcher = dispatcher;
+  if (opts.signal !== void 0) ctx.signal = opts.signal;
+  if (opts.subJourneyCache !== void 0) ctx.subJourneyCache = opts.subJourneyCache;
+  if (opts.subJourneyCacheTtlMs !== void 0) {
+    ctx.subJourneyCacheTtlMs = opts.subJourneyCacheTtlMs;
+  }
+  const unpatchConsole = logger ? patchConsole(logger) : () => {
+  };
+  let results;
+  try {
+    results = await runAllRegistered2(ctx, {
+      ...opts.runId !== void 0 ? { runId: opts.runId } : {},
+      ...opts.upToStepIdx !== void 0 ? { upToStepIdx: opts.upToStepIdx } : {}
+    });
+  } finally {
+    unpatchConsole();
+  }
+  const cacheDir = join6(opts.loaded.projectDir, ".journey", "cache");
+  await writeRun2(cacheDir, results);
+  await pruneRuns2(cacheDir, opts.loaded.config.runHistoryKeepCount);
+  return results;
+}
+
+// src/server/planner.ts
+import { isAbsolute as isAbsolute6, join as join7, resolve as resolve6 } from "path";
+import {
+  clearActiveEnvironment as clearActiveEnvironment4,
+  loadEnvironment as loadEnvironment4,
+  planJourney,
+  setActiveEnvironment as setActiveEnvironment4
+} from "@usejourney/core";
+async function planJourneyFile(opts) {
+  const abs = isAbsolute6(opts.file) ? opts.file : opts.file.includes("/") || opts.file.includes("\\") ? resolve6(process.cwd(), opts.file) : join7(opts.journeysDir, opts.file);
+  clearActiveEnvironment4();
+  const envName = opts.env ?? opts.loaded.config.defaultEnvironment;
+  if (envName) {
+    const values = await loadEnvironment4(opts.environmentsDir, envName);
+    setActiveEnvironment4(envName, values);
+  }
+  await ensureProjectCoreLink(opts.loaded.projectDir);
+  const defs = await loadJourneyDefs(abs);
+  const journeys = [];
+  for (const def of defs) {
+    journeys.push({ name: def.name, steps: await planJourney(def) });
+  }
+  return journeys;
+}
+
+// src/server/specDrift.ts
+import { readFile, stat as stat4 } from "fs/promises";
+import { join as join8 } from "path";
+import { collectOperations, loadSpec as loadSpec2 } from "@usejourney/codegen";
+function parseGeneratedEndpoints(source) {
+  const out = [];
+  const re = /^\s*([a-zA-Z_$][a-zA-Z0-9_$]*)\s*:\s*\{\s*method:\s*"([A-Z]+)"\s*,\s*path:\s*"([^"]+)"\s*,\s*operationId:\s*"([^"]+)"\s*\}/gm;
+  let m;
+  while (m = re.exec(source)) {
+    const [, , method, path, operationId] = m;
+    out.push({ method, path, operationId });
+  }
+  return out;
+}
+async function computeSpecDrift(specPath, generatedDir) {
+  const [spec, generated] = await Promise.all([readSpecOps(specPath), readGenerated(generatedDir)]);
+  if (!spec || !generated) {
+    return {
+      added: [],
+      removed: [],
+      hasGenerated: generated !== void 0,
+      hasSpec: spec !== void 0,
+      count: 0
+    };
+  }
+  const specKey = /* @__PURE__ */ new Map();
+  for (const op of spec) {
+    specKey.set(`${op.method.toUpperCase()} ${op.path}`, {
+      method: op.method.toUpperCase(),
+      path: op.path,
+      operationId: op.operationId
+    });
+  }
+  const genKey = /* @__PURE__ */ new Map();
+  for (const op of generated) {
+    genKey.set(`${op.method} ${op.path}`, op);
+  }
+  const added = [];
+  for (const [k, v] of specKey) {
+    if (!genKey.has(k)) added.push(v);
+  }
+  const removed = [];
+  for (const [k, v] of genKey) {
+    if (!specKey.has(k)) removed.push(v);
+  }
+  return {
+    added,
+    removed,
+    hasGenerated: true,
+    hasSpec: true,
+    count: added.length + removed.length
+  };
+}
+async function readSpecOps(specPath) {
+  try {
+    await stat4(specPath);
+  } catch {
+    return void 0;
+  }
+  try {
+    const doc = await loadSpec2(specPath);
+    return collectOperations(doc);
+  } catch {
+    return void 0;
+  }
+}
+async function readGenerated(generatedDir) {
+  try {
+    const source = await readFile(join8(generatedDir, "endpoints.ts"), "utf8");
+    return parseGeneratedEndpoints(source);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/server/runBroadcaster.ts
+var RunBroadcaster = class {
+  runId;
+  events = [];
+  subscribers = /* @__PURE__ */ new Set();
+  currentStepIdx = -1;
+  nextRequestSeq = 0;
+  // Tags each in-flight RequestLog with its monotonic sequence so onResponse /
+  // onError emit the matching `requestIdx`. Per-step uniqueness isn't enough —
+  // helpers (auth bootstrap, fan-out) make multiple requests inside one step.
+  requestSeqs = /* @__PURE__ */ new WeakMap();
+  completed = false;
+  completedAt;
+  constructor(runId) {
+    this.runId = runId;
+  }
+  get isCompleted() {
+    return this.completed;
+  }
+  /**
+   * Core-level logger that feeds everything into the event buffer. `stepIdx`
+   * is tracked locally from `onStepStart` and attached to intervening
+   * request/response/error events so SSE consumers don't need to correlate
+   * by timing.
+   */
+  toLogger() {
+    return {
+      onRunStart: (e) => {
+        this.emit({ kind: "run:start", runId: e.runId, journeyNames: e.journeyNames });
+      },
+      onPlanned: (e) => {
+        this.emit({
+          kind: "step:planned",
+          runId: e.runId,
+          journeyIdx: e.journeyIdx,
+          journeyName: e.journeyName,
+          stepIdxOffset: e.stepIdxOffset,
+          steps: e.steps
+        });
+      },
+      onStepStart: (e) => {
+        this.currentStepIdx = e.stepIdx;
+        this.emit({
+          kind: "step:start",
+          runId: e.runId,
+          journeyIdx: e.journeyIdx,
+          journeyName: e.journeyName,
+          stepIdx: e.stepIdx,
+          name: e.name
+        });
+      },
+      onRequest: (req) => {
+        const requestIdx = this.nextRequestSeq++;
+        this.requestSeqs.set(req, requestIdx);
+        this.emit({
+          kind: "request",
+          runId: this.runId,
+          stepIdx: this.currentStepIdx,
+          requestIdx,
+          method: req.method,
+          url: req.url,
+          headers: req.headers,
+          ...req.body !== void 0 ? { body: req.body } : {}
+        });
+      },
+      onResponse: (req, res) => {
+        this.emit({
+          kind: "response",
+          runId: this.runId,
+          stepIdx: this.currentStepIdx,
+          requestIdx: this.requestSeqs.get(req) ?? -1,
+          status: res.status,
+          headers: res.headers,
+          body: res.body,
+          durationMs: res.durationMs
+        });
+      },
+      onError: (req, err, durationMs) => {
+        this.emit({
+          kind: "error",
+          runId: this.runId,
+          stepIdx: this.currentStepIdx,
+          requestIdx: this.requestSeqs.get(req) ?? -1,
+          message: err instanceof Error ? err.message : String(err),
+          durationMs
+        });
+      },
+      onLog: (e) => {
+        this.emit({
+          kind: "log",
+          runId: this.runId,
+          stepIdx: this.currentStepIdx,
+          level: e.level,
+          text: e.text
+        });
+      },
+      onStepEnd: (e) => {
+        this.emit({
+          kind: "step:end",
+          runId: e.runId,
+          journeyIdx: e.journeyIdx,
+          stepIdx: e.stepIdx,
+          ok: e.ok,
+          durationMs: e.durationMs,
+          ...e.error !== void 0 ? { error: e.error } : {}
+        });
+      },
+      onGroupStart: (e) => {
+        this.emit({
+          kind: "group:start",
+          runId: e.runId,
+          journeyIdx: e.journeyIdx,
+          name: e.name,
+          childJourneyName: e.childJourneyName,
+          stepIdx: e.stepIdx,
+          firstChildStepIdx: e.firstChildStepIdx,
+          cacheStatus: e.cacheStatus,
+          ...e.resolvedKey !== void 0 ? { resolvedKey: e.resolvedKey } : {}
+        });
+      },
+      onGroupEnd: (e) => {
+        this.emit({
+          kind: "group:end",
+          runId: e.runId,
+          journeyIdx: e.journeyIdx,
+          name: e.name,
+          childJourneyName: e.childJourneyName,
+          stepIdx: e.stepIdx,
+          lastChildStepIdx: e.lastChildStepIdx,
+          ok: e.ok,
+          durationMs: e.durationMs,
+          ...e.error !== void 0 ? { error: e.error } : {}
+        });
+      },
+      onRunEnd: (e) => {
+        this.emit({
+          kind: "run:end",
+          runId: e.runId,
+          ok: e.ok,
+          durationMs: e.durationMs,
+          results: e.results
+        });
+        this.complete();
+      }
+    };
+  }
+  /**
+   * Emits a fatal error (e.g. a failure to load the journey file, before any
+   * step events fire). Translates to a `run:end` ok=false so clients stop
+   * waiting.
+   */
+  fail(message) {
+    this.emit({
+      kind: "run:end",
+      runId: this.runId,
+      ok: false,
+      durationMs: 0,
+      results: [{ name: "error", ok: false }]
+    });
+    this.emit({
+      kind: "error",
+      runId: this.runId,
+      stepIdx: -1,
+      requestIdx: -1,
+      message,
+      durationMs: 0
+    });
+    this.complete();
+  }
+  /**
+   * Wires a ServerResponse as a long-lived SSE subscriber. Replays the buffered
+   * events, then holds the connection open for new ones. If the run is already
+   * complete, the connection is closed immediately after replay so the client
+   * moves on without blocking.
+   */
+  subscribe(res) {
+    res.writeHead(200, {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache",
+      connection: "keep-alive",
+      "x-accel-buffering": "no",
+      "access-control-allow-origin": "*"
+    });
+    for (const ev of this.events) {
+      writeEvent(res, ev);
+    }
+    if (this.completed) {
+      res.end();
+      return;
+    }
+    const heartbeat = setInterval(() => {
+      try {
+        res.write(": keep-alive\n\n");
+      } catch {
+      }
+    }, 15e3);
+    const sub = { res, heartbeat };
+    this.subscribers.add(sub);
+    res.on("close", () => {
+      clearInterval(heartbeat);
+      this.subscribers.delete(sub);
+    });
+  }
+  emit(event) {
+    this.events.push(event);
+    for (const sub of this.subscribers) {
+      try {
+        writeEvent(sub.res, event);
+      } catch {
+      }
+    }
+  }
+  complete() {
+    if (this.completed) return;
+    this.completed = true;
+    this.completedAt = Date.now();
+    abortControllers.delete(this.runId);
+    for (const sub of this.subscribers) {
+      try {
+        clearInterval(sub.heartbeat);
+        sub.res.end();
+      } catch {
+      }
+    }
+    this.subscribers.clear();
+  }
+  /** True when this broadcaster is ready to be evicted from the registry. */
+  canEvict(graceMs) {
+    if (!this.completed) return false;
+    if (this.completedAt === void 0) return true;
+    return Date.now() - this.completedAt > graceMs;
+  }
+};
+function writeEvent(res, event) {
+  res.write(`event: ${event.kind}
+`);
+  res.write(`data: ${JSON.stringify(event)}
+
+`);
+}
+var EVICTION_GRACE_MS = 5 * 60 * 1e3;
+var registry = /* @__PURE__ */ new Map();
+var abortControllers = /* @__PURE__ */ new Map();
+function newRunId() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  return `run_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function registerBroadcaster(runId) {
+  evictStale();
+  const b = new RunBroadcaster(runId);
+  registry.set(runId, b);
+  return b;
+}
+function getBroadcaster(runId) {
+  evictStale();
+  return registry.get(runId);
+}
+function evictStale(graceMs = EVICTION_GRACE_MS) {
+  for (const [id, b] of registry) {
+    if (b.canEvict(graceMs)) {
+      registry.delete(id);
+      abortControllers.delete(id);
+    }
+  }
+}
+function registerAbortController(runId, controller) {
+  abortControllers.set(runId, controller);
+}
+function clearAbortController(runId) {
+  abortControllers.delete(runId);
+}
+function abortRun(runId) {
+  const controller = abortControllers.get(runId);
+  if (!controller) return false;
+  controller.abort(new Error("run aborted by user"));
+  return true;
+}
+
+// src/server/server.ts
+function makeCacheResolver(mode) {
+  let processCache;
+  let processInit = false;
+  return (projectDir) => {
+    const diskDir = join9(projectDir, ".journey", "cache", "sub-journey");
+    if (mode === "process") {
+      if (!processInit) {
+        processCache = createSubJourneyCache2("process", { diskDir });
+        processInit = true;
+      }
+      return processCache;
+    }
+    return createSubJourneyCache2(mode, { diskDir });
+  };
+}
+function send(res, status, body) {
+  res.writeHead(status, { "content-type": "application/json", "access-control-allow-origin": "*" });
+  res.end(JSON.stringify(body));
+}
+async function countEndpoints(generatedDir) {
+  try {
+    await stat5(generatedDir);
+  } catch {
+    return 0;
+  }
+  try {
+    const { readFile: readFile3 } = await import("fs/promises");
+    const { join: join10 } = await import("path");
+    const content = await readFile3(join10(generatedDir, "endpoints.ts"), "utf8");
+    const matches3 = content.match(/^\s{2}[a-zA-Z_$][a-zA-Z0-9_$]*:\s*\{/gm);
+    return matches3 ? matches3.length : 0;
+  } catch {
+    return 0;
+  }
+}
+async function countJourneys(journeysDir) {
+  try {
+    const { readdir: readdir4 } = await import("fs/promises");
+    const entries = await readdir4(journeysDir);
+    return entries.filter((e) => e.endsWith(".journey.ts")).length;
+  } catch {
+    return 0;
+  }
+}
+async function buildProjectSummary(loaded) {
+  const paths = resolveConfigPaths5(loaded);
+  const [endpoints, journeys, envs] = await Promise.all([
+    countEndpoints(paths.generatedDir),
+    countJourneys(paths.journeysDir),
+    listEnvironments3(paths.environmentsDir)
+  ]);
+  return {
+    projectDir: loaded.projectDir,
+    config: {
+      ...loaded.config.name !== void 0 ? { name: loaded.config.name } : {},
+      spec: loaded.config.spec,
+      ...loaded.config.baseUrl !== void 0 ? { baseUrl: loaded.config.baseUrl } : {},
+      ...loaded.config.defaultEnvironment !== void 0 ? { defaultEnvironment: loaded.config.defaultEnvironment } : {},
+      tlsRejectUnauthorized: loaded.config.tlsRejectUnauthorized
+    },
+    counts: {
+      endpoints,
+      journeys,
+      environments: envs.length
+    }
+  };
+}
+var PATCHABLE_CONFIG_KEYS = ["tlsRejectUnauthorized"];
+async function patchProjectConfig(projectDir, patch) {
+  const configPath = join9(projectDir, "journey.config.json");
+  const raw = await readFile2(configPath, "utf8");
+  const current = JSON.parse(raw);
+  for (const key of Object.keys(patch)) {
+    if (!PATCHABLE_CONFIG_KEYS.includes(key)) {
+      throw new Error(`config key "${key}" is not patchable via the API`);
+    }
+  }
+  const merged = { ...current };
+  for (const key of PATCHABLE_CONFIG_KEYS) {
+    if (Object.prototype.hasOwnProperty.call(patch, key)) {
+      merged[key] = patch[key];
+    }
+  }
+  const result = JourneyConfigSchema.safeParse(merged);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ");
+    throw new Error(`config patch failed validation: ${issues}`);
+  }
+  await writeFile3(configPath, `${JSON.stringify(merged, null, 2)}
+`, "utf8");
+  return await buildProjectSummary(await loadConfig5(projectDir));
+}
+async function buildTree(root) {
+  try {
+    const entries = await readdir3(root, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      if (entry.name.startsWith(".")) continue;
+      if (entry.isDirectory()) {
+        out.push({
+          name: entry.name,
+          type: "dir",
+          children: await buildTree(join9(root, entry.name))
+        });
+      } else {
+        out.push({ name: entry.name, type: "file" });
+      }
+    }
+    return out;
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+}
+async function buildProjectTree(loaded) {
+  const paths = resolveConfigPaths5(loaded);
+  const [journeys, environments, generated] = await Promise.all([
+    buildTree(paths.journeysDir),
+    buildTree(paths.environmentsDir),
+    buildTree(paths.generatedDir)
+  ]);
+  return {
+    projectDir: loaded.projectDir,
+    sections: [
+      { label: "journeys", dir: paths.journeysDir, children: journeys },
+      { label: "environments", dir: paths.environmentsDir, children: environments },
+      { label: "generated", dir: paths.generatedDir, children: generated }
+    ]
+  };
+}
+function normalizeParameters(params) {
+  if (!Array.isArray(params)) return [];
+  const out = [];
+  for (const p of params) {
+    if (!p || typeof p !== "object") continue;
+    const loc = p.in;
+    if (loc !== "query" && loc !== "path" && loc !== "header") continue;
+    if (typeof p.name !== "string") continue;
+    const entry = {
+      name: p.name,
+      in: loc,
+      required: p.required === true || loc === "path"
+    };
+    if (typeof p.description === "string") entry.description = p.description;
+    out.push(entry);
+  }
+  return out;
+}
+async function readEndpoints(specPath) {
+  try {
+    const doc = await loadSpec3(specPath);
+    const ops = collectOperations2(doc);
+    const paths = doc.paths ?? {};
+    const out = [];
+    for (const op of ops) {
+      const pathItem = paths[op.path];
+      const pathLevel = normalizeParameters(pathItem?.parameters);
+      const opLevel = normalizeParameters(
+        pathItem?.[op.method]?.parameters
+      );
+      const merged = /* @__PURE__ */ new Map();
+      for (const p of pathLevel) merged.set(`${p.in}:${p.name}`, p);
+      for (const p of opLevel) merged.set(`${p.in}:${p.name}`, p);
+      const rawOp = pathItem?.[op.method];
+      const rawOperationId = typeof rawOp?.operationId === "string" ? rawOp.operationId : void 0;
+      const entry = {
+        name: operationName(op.method, op.path, rawOperationId),
+        method: op.method.toUpperCase(),
+        path: op.path,
+        parameters: [...merged.values()]
+      };
+      if (rawOperationId) entry.operationId = rawOperationId;
+      out.push(entry);
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+async function readRequestBody(req) {
+  const chunks = [];
+  for await (const chunk of req) chunks.push(chunk);
+  const raw = Buffer.concat(chunks).toString("utf8");
+  if (!raw) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error("request body is not valid JSON");
+  }
+}
+async function proxyRequest(body) {
+  if (!body.method || !body.url) throw new Error("method and url are required");
+  const init = {
+    method: body.method,
+    ...body.headers ? { headers: body.headers } : {}
+  };
+  if (body.body !== void 0) {
+    init.body = typeof body.body === "string" ? body.body : JSON.stringify(body.body);
+  }
+  const started = Date.now();
+  const res = await fetch(body.url, init);
+  const respHeaders = {};
+  res.headers.forEach((v, k) => {
+    respHeaders[k] = v;
+  });
+  const ct = res.headers.get("content-type") ?? "";
+  const parsed = ct.includes("json") ? await res.json().catch(() => null) : await res.text();
+  return {
+    status: res.status,
+    headers: respHeaders,
+    body: parsed,
+    durationMs: Date.now() - started
+  };
+}
+async function route(req, res, projectDir, debug, setProjectDir, cacheFor, cacheTtlMs) {
+  if (req.method === "OPTIONS") {
+    res.writeHead(204, {
+      "access-control-allow-origin": "*",
+      "access-control-allow-methods": "GET,POST,PUT,PATCH,DELETE,OPTIONS",
+      "access-control-allow-headers": "content-type"
+    });
+    res.end();
+    return;
+  }
+  try {
+    const url = new URL(req.url ?? "/", "http://local");
+    if (url.pathname === "/api/project" && req.method === "GET") {
+      const loaded = await loadConfig5(projectDir);
+      send(res, 200, await buildProjectSummary(loaded));
+      return;
+    }
+    if (url.pathname === "/api/project/open" && req.method === "POST") {
+      const body = await readRequestBody(req);
+      const path = body?.path;
+      if (typeof path !== "string" || path.length === 0 || !isAbsolute7(path)) {
+        send(res, 400, { error: "body.path must be an absolute filesystem path" });
+        return;
+      }
+      let loaded;
+      try {
+        loaded = await loadConfig5(path);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        send(res, 400, { error: `Not a Journey project: ${message}` });
+        return;
+      }
+      setProjectDir(loaded.projectDir);
+      send(res, 200, await buildProjectSummary(loaded));
+      return;
+    }
+    if (url.pathname === "/api/project/config" && req.method === "PATCH") {
+      const body = await readRequestBody(req);
+      if (!body || typeof body !== "object") {
+        send(res, 400, { error: "request body must be a JSON object" });
+        return;
+      }
+      send(res, 200, await patchProjectConfig(projectDir, body));
+      return;
+    }
+    if (url.pathname === "/api/tree" && req.method === "GET") {
+      const loaded = await loadConfig5(projectDir);
+      send(res, 200, await buildProjectTree(loaded));
+      return;
+    }
+    if (url.pathname === "/api/endpoints" && req.method === "GET") {
+      const loaded = await loadConfig5(projectDir);
+      const { specPath } = resolveConfigPaths5(loaded);
+      const endpoints = await readEndpoints(specPath);
+      send(res, 200, { baseUrl: loaded.config.baseUrl, endpoints });
+      return;
+    }
+    if (url.pathname === "/api/request" && req.method === "POST") {
+      const body = await readRequestBody(req);
+      send(res, 200, await proxyRequest(body));
+      return;
+    }
+    const journeyFileMatch = url.pathname.match(/^\/api\/journeys\/([^/]+)$/);
+    if (journeyFileMatch) {
+      const file = decodeURIComponent(journeyFileMatch[1]);
+      if (!/^[a-zA-Z0-9_.-]+\.journey\.ts$/.test(file)) {
+        send(res, 400, { error: "invalid journey filename" });
+        return;
+      }
+      const loaded = await loadConfig5(projectDir);
+      const { journeysDir } = resolveConfigPaths5(loaded);
+      const filePath = join9(journeysDir, file);
+      if (req.method === "GET") {
+        try {
+          const source = await readFile2(filePath, "utf8");
+          send(res, 200, { file, source });
+        } catch (err) {
+          if (err.code === "ENOENT") {
+            send(res, 404, { error: "not found" });
+          } else throw err;
+        }
+        return;
+      }
+      if (req.method === "PUT") {
+        const body = await readRequestBody(req) ?? {};
+        if (typeof body.source !== "string") {
+          send(res, 400, { error: "body.source must be a string" });
+          return;
+        }
+        const { mkdir: mkdir4 } = await import("fs/promises");
+        await mkdir4(journeysDir, { recursive: true });
+        await writeFile3(filePath, body.source, "utf8");
+        send(res, 200, { file, bytes: Buffer.byteLength(body.source, "utf8") });
+        return;
+      }
+      if (req.method === "DELETE") {
+        try {
+          await unlink(filePath);
+          send(res, 200, { file, deleted: true });
+        } catch (err) {
+          if (err.code === "ENOENT") {
+            send(res, 404, { error: "not found" });
+          } else throw err;
+        }
+        return;
+      }
+    }
+    if (url.pathname === "/api/journeys" && req.method === "GET") {
+      const loaded = await loadConfig5(projectDir);
+      const { journeysDir } = resolveConfigPaths5(loaded);
+      const { readdir: readdir4 } = await import("fs/promises");
+      let files = [];
+      try {
+        const entries = await readdir4(journeysDir);
+        files = entries.filter((e) => e.endsWith(".journey.ts")).sort();
+      } catch {
+        files = [];
+      }
+      send(res, 200, { journeysDir, files });
+      return;
+    }
+    if (url.pathname === "/api/environments" && req.method === "GET") {
+      const loaded = await loadConfig5(projectDir);
+      const { environmentsDir } = resolveConfigPaths5(loaded);
+      const names = await listEnvironments3(environmentsDir);
+      const out = [];
+      for (const name of names) {
+        try {
+          const raw = await readFile2(join9(environmentsDir, `${name}.json`), "utf8");
+          const values = JSON.parse(raw);
+          const normalized = {};
+          for (const [k, v] of Object.entries(values))
+            normalized[k] = typeof v === "string" ? v : JSON.stringify(v);
+          out.push({ name, values: normalized });
+        } catch {
+          out.push({ name, values: {} });
+        }
+      }
+      send(res, 200, { defaultEnvironment: loaded.config.defaultEnvironment, environments: out });
+      return;
+    }
+    const envMatch = url.pathname.match(/^\/api\/environments\/([^/]+)$/);
+    if (envMatch) {
+      const name = decodeURIComponent(envMatch[1]);
+      if (!/^[a-zA-Z0-9_.-]+$/.test(name)) {
+        send(res, 400, { error: "invalid environment name" });
+        return;
+      }
+      const loaded = await loadConfig5(projectDir);
+      const { environmentsDir } = resolveConfigPaths5(loaded);
+      const file = join9(environmentsDir, `${name}.json`);
+      if (req.method === "PUT") {
+        const body = await readRequestBody(req);
+        if (!body || typeof body !== "object" || Array.isArray(body)) {
+          send(res, 400, { error: "body must be a JSON object" });
+          return;
+        }
+        await writeFile3(file, `${JSON.stringify(body, null, 2)}
+`, "utf8");
+        send(res, 200, { name, values: body });
+        return;
+      }
+      if (req.method === "DELETE") {
+        try {
+          await unlink(file);
+          send(res, 200, { name, deleted: true });
+        } catch (err) {
+          if (err.code === "ENOENT") {
+            send(res, 404, { error: "not found" });
+          } else {
+            throw err;
+          }
+        }
+        return;
+      }
+    }
+    const journeyPlanMatch = url.pathname.match(/^\/api\/journeys\/([^/]+)\/plan$/);
+    if (journeyPlanMatch && req.method === "GET") {
+      const file = decodeURIComponent(journeyPlanMatch[1]);
+      const env = url.searchParams.get("env") ?? void 0;
+      const loaded = await loadConfig5(projectDir);
+      const { journeysDir, environmentsDir } = resolveConfigPaths5(loaded);
+      try {
+        const journeys = await planJourneyFile({
+          loaded,
+          journeysDir,
+          environmentsDir,
+          file,
+          ...env !== void 0 ? { env } : {}
+        });
+        send(res, 200, { journeys });
+      } catch (err) {
+        send(res, 500, { error: err instanceof Error ? err.message : String(err) });
+      }
+      return;
+    }
+    const runMatch = url.pathname.match(/^\/api\/journeys\/([^/]+)\/run$/);
+    if (runMatch && req.method === "POST") {
+      const file = decodeURIComponent(runMatch[1]);
+      const body = await readRequestBody(req) ?? {};
+      const loaded = await loadConfig5(projectDir);
+      const { journeysDir, environmentsDir } = resolveConfigPaths5(loaded);
+      const runId = newRunId();
+      const broadcaster = registerBroadcaster(runId);
+      const abortController = new AbortController();
+      registerAbortController(runId, abortController);
+      const subJourneyCache = cacheFor(projectDir);
+      const runPromise = runJourneyFile({
+        loaded,
+        journeysDir,
+        environmentsDir,
+        file,
+        runId,
+        logger: broadcaster.toLogger(),
+        signal: abortController.signal,
+        ...body.env !== void 0 ? { env: body.env } : {},
+        ...typeof body.upToStepIdx === "number" ? { upToStepIdx: body.upToStepIdx } : {},
+        ...debug ? { debug: true } : {},
+        ...subJourneyCache !== void 0 ? { subJourneyCache } : {},
+        ...cacheTtlMs !== void 0 ? { subJourneyCacheTtlMs: cacheTtlMs } : {}
+      });
+      if (body.stream) {
+        runPromise.catch((err) => {
+          broadcaster.fail(err instanceof Error ? err.message : String(err));
+        }).finally(() => clearAbortController(runId));
+        send(res, 202, { runId });
+        return;
+      }
+      try {
+        const results = await runPromise;
+        send(res, 200, { runId, results });
+      } catch (err) {
+        broadcaster.fail(err instanceof Error ? err.message : String(err));
+        send(res, 500, { runId, error: err instanceof Error ? err.message : String(err) });
+      } finally {
+        clearAbortController(runId);
+      }
+      return;
+    }
+    const runAbortMatch = url.pathname.match(/^\/api\/runs\/([^/]+)\/abort$/);
+    if (runAbortMatch && req.method === "POST") {
+      const id = decodeURIComponent(runAbortMatch[1]);
+      if (abortRun(id)) {
+        send(res, 202, { runId: id, aborted: true });
+      } else {
+        send(res, 404, { error: "unknown or completed run" });
+      }
+      return;
+    }
+    if (url.pathname === "/api/runs" && req.method === "GET") {
+      const cacheDir = join9(projectDir, ".journey", "cache");
+      send(res, 200, await listRuns(cacheDir));
+      return;
+    }
+    const runEventsMatch = url.pathname.match(/^\/api\/runs\/([^/]+)\/events$/);
+    if (runEventsMatch && req.method === "GET") {
+      const id = decodeURIComponent(runEventsMatch[1]);
+      const broadcaster = getBroadcaster(id);
+      if (!broadcaster) {
+        send(res, 404, { error: "unknown run (already evicted or never started)" });
+        return;
+      }
+      broadcaster.subscribe(res);
+      return;
+    }
+    const runIdMatch = url.pathname.match(/^\/api\/runs\/([^/]+)$/);
+    if (runIdMatch && req.method === "GET") {
+      const id = decodeURIComponent(runIdMatch[1]);
+      const cacheDir = join9(projectDir, ".journey", "cache");
+      const record = await readRun(cacheDir, id);
+      if (!record) {
+        send(res, 404, { error: "run not found" });
+        return;
+      }
+      send(res, 200, record);
+      return;
+    }
+    if (url.pathname === "/api/spec/drift" && req.method === "GET") {
+      const loaded = await loadConfig5(projectDir);
+      const { specPath, generatedDir } = resolveConfigPaths5(loaded);
+      send(res, 200, await computeSpecDrift(specPath, generatedDir));
+      return;
+    }
+    if (url.pathname === "/api/generate" && req.method === "POST") {
+      const loaded = await loadConfig5(projectDir);
+      const { specPath, generatedDir } = resolveConfigPaths5(loaded);
+      try {
+        const result = await generate3({ specPath, outDir: generatedDir });
+        send(res, 200, {
+          operationCount: result.operationCount,
+          endpointsPath: result.endpointsPath,
+          modelsPath: result.modelsPath
+        });
+      } catch (err) {
+        send(res, 500, {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+      return;
+    }
+    if (url.pathname === "/api/health") {
+      send(res, 200, { ok: true });
+      return;
+    }
+    send(res, 404, { error: "not found" });
+  } catch (err) {
+    send(res, 500, { error: err instanceof Error ? err.message : String(err) });
+  }
+}
+async function startServer(opts) {
+  const host = opts.host ?? "127.0.0.1";
+  const port = opts.port ?? 5181;
+  const state = { projectDir: opts.projectDir };
+  const setProjectDir = (next) => {
+    state.projectDir = next;
+  };
+  const cacheFor = makeCacheResolver(opts.cache ?? "process");
+  const http = createServer((req, res) => {
+    void route(
+      req,
+      res,
+      state.projectDir,
+      opts.debug ?? false,
+      setProjectDir,
+      cacheFor,
+      opts.cacheTtlMs
+    );
+  });
+  await new Promise((resolve7, reject) => {
+    http.once("error", reject);
+    http.listen(port, host, () => resolve7());
+  });
+  const addr = http.address();
+  const actualPort = typeof addr === "object" && addr ? addr.port : port;
+  return {
+    url: `http://${host}:${actualPort}`,
+    port: actualPort,
+    close: () => new Promise((resolve7) => http.close(() => resolve7()))
+  };
+}
+
+// src/commands/serve.ts
+async function runServe(opts) {
+  if (opts.insecure) await enableInsecureTls();
+  const srv = await startServer({
+    projectDir: opts.projectDir,
+    ...opts.host !== void 0 ? { host: opts.host } : {},
+    ...opts.port !== void 0 ? { port: opts.port } : {},
+    ...opts.debug !== void 0 ? { debug: opts.debug } : {},
+    ...opts.cache !== void 0 ? { cache: opts.cache } : {},
+    ...opts.cacheTtlMs !== void 0 ? { cacheTtlMs: opts.cacheTtlMs } : {}
+  });
+  console.log(`Journey API listening at ${srv.url}`);
+  console.log(`For the GUI, run: pnpm --filter @usejourney/gui dev`);
+  await new Promise((resolve7) => {
+    const handler = () => {
+      console.log("Shutting down\u2026");
+      void srv.close().then(() => resolve7());
+    };
+    process.once("SIGINT", handler);
+    process.once("SIGTERM", handler);
+  });
+  return 0;
+}
+
+// src/index.ts
+function parseCacheMode(value) {
+  if (value === "off" || value === "run" || value === "process" || value === "disk") {
+    return value;
+  }
+  throw new Error(`--cache must be one of off|run|process|disk (got "${value}")`);
+}
+async function handle(fn) {
+  try {
+    const code = await fn() ?? 0;
+    process.exit(code);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`journey: ${msg}`);
+    process.exit(1);
+  }
+}
+function buildProgram() {
+  const program = new Command();
+  program.name("journey").description("Local-first API testing & orchestration tool").version("0.0.0");
+  program.command("init <dir>").requiredOption("--spec <path>", "OpenAPI spec file").option("--force", "Scaffold into a non-empty directory", false).description("Scaffold a new Journey project from an OpenAPI spec").action(
+    (dir, options) => handle(
+      () => runInit({
+        dir,
+        spec: options.spec,
+        ...options.force !== void 0 ? { force: options.force } : {}
+      })
+    )
+  );
+  program.command("generate").description("Regenerate typed endpoints/models from the spec").action(() => handle(() => runGenerate(process.cwd())));
+  program.command("run [journey-file...]").option("--env <name>", "Environment file to use").option("--all", "Run all journeys in the project", false).option("--debug", "Log every request and response to stderr", false).option("--watch", "Rerun on file changes", false).option(
+    "--insecure",
+    "Disable TLS certificate verification (for self-signed / corporate CAs)",
+    false
+  ).option(
+    "--cache <mode>",
+    "Sub-journey output cache: off|run|process|disk",
+    parseCacheMode,
+    "process"
+  ).option("--cache-ttl <ms>", "Default sub-journey cache TTL in ms", (v) => parseInt(v, 10)).description("Run one or more journeys (or --all)").action(
+    (files, options) => handle(
+      () => runCommand({
+        projectDir: process.cwd(),
+        files,
+        ...options.all !== void 0 ? { all: options.all } : {},
+        ...options.env !== void 0 ? { env: options.env } : {},
+        ...options.debug !== void 0 ? { debug: options.debug } : {},
+        ...options.watch !== void 0 ? { watch: options.watch } : {},
+        ...options.insecure !== void 0 ? { insecure: options.insecure } : {},
+        ...options.cache !== void 0 ? { cache: options.cache } : {},
+        ...options.cacheTtl !== void 0 ? { cacheTtlMs: options.cacheTtl } : {}
+      })
+    )
+  );
+  const exp = program.command("export").description("Export a journey to another format");
+  exp.command("k6 <path>").option("--out <path>", "Output file (single-file mode only)").option(
+    "--out-dir <path>",
+    "Output directory (used in directory mode; falls back to writing next to each source)"
+  ).option(
+    "--tag <tag>",
+    "Only export journeys with this tag (repeatable, AND across repeats)",
+    (v, prev = []) => [...prev, v],
+    []
+  ).description("Export one or more journeys as k6 scripts (path may be a file or directory)").action(
+    (path, options) => handle(
+      () => runExportK6({
+        path,
+        ...options.out !== void 0 ? { out: options.out } : {},
+        ...options.outDir !== void 0 ? { outDir: options.outDir } : {},
+        tags: options.tag
+      })
+    )
+  );
+  exp.command("postman <path>").option("--out <path>", "Output file (single-file mode only)").option(
+    "--out-dir <path>",
+    "Output directory (used in directory mode; falls back to writing next to each source)"
+  ).option(
+    "--tag <tag>",
+    "Only export journeys with this tag (repeatable, AND across repeats)",
+    (v, prev = []) => [...prev, v],
+    []
+  ).option("--name <name>", "Override the collection name").option("--env <name>", "Export named environment as a Postman environment file").option("--all-envs", "Export all environments as Postman environment files").option("--bundle", "Aggregate every matching journey (across all files) into one collection").option(
+    "--thread-state",
+    "Experimental: thread journey state through collection variables so sub-journey outputs reach later requests"
+  ).option(
+    "--lenient",
+    "With --thread-state: emit non-enforcing assertions (legacy swallow-all; a failing expect() stays a console line, not a red pm.test)"
+  ).description(
+    "Export one or more journeys as a Postman Collection v2.1.0 (path may be a file or directory)"
+  ).action(
+    (path, options) => handle(
+      () => runExportPostman({
+        path,
+        ...options.out !== void 0 ? { out: options.out } : {},
+        ...options.outDir !== void 0 ? { outDir: options.outDir } : {},
+        ...options.name !== void 0 ? { name: options.name } : {},
+        ...options.env !== void 0 ? { env: options.env } : {},
+        ...options.allEnvs !== void 0 ? { allEnvs: options.allEnvs } : {},
+        ...options.bundle !== void 0 ? { bundle: options.bundle } : {},
+        ...options.threadState !== void 0 ? { threadState: options.threadState } : {},
+        ...options.lenient !== void 0 ? { lenient: options.lenient } : {},
+        tags: options.tag
+      })
+    )
+  );
+  program.command("serve").option("--port <n>", "Port (default 5181)", (v) => parseInt(v, 10)).option("--host <host>", "Host (default 127.0.0.1)").option("--project <dir>", "Project directory (default: cwd)").option("--debug", "Log every request/response while running journeys", false).option(
+    "--insecure",
+    "Disable TLS certificate verification for journey runs triggered via the API",
+    false
+  ).option(
+    "--cache <mode>",
+    "Sub-journey output cache: off|run|process|disk",
+    parseCacheMode,
+    "process"
+  ).option("--cache-ttl <ms>", "Default sub-journey cache TTL in ms", (v) => parseInt(v, 10)).description("Run the GUI backend API for the current project").action(
+    (options) => {
+      const projectDir = options.project ? resolvePath(process.cwd(), options.project) : process.cwd();
+      return handle(
+        () => runServe({
+          projectDir,
+          ...options.port !== void 0 ? { port: options.port } : {},
+          ...options.host !== void 0 ? { host: options.host } : {},
+          ...options.debug !== void 0 ? { debug: options.debug } : {},
+          ...options.insecure !== void 0 ? { insecure: options.insecure } : {},
+          ...options.cache !== void 0 ? { cache: options.cache } : {},
+          ...options.cacheTtl !== void 0 ? { cacheTtlMs: options.cacheTtl } : {}
+        })
+      );
+    }
+  );
+  const envCmd = program.command("env").description("Environment management");
+  envCmd.command("list").description("List available environments").action(() => handle(() => runEnvList(process.cwd())));
+  return program;
+}
+var isDirectRun = import.meta.url === `file://${process.argv[1]}`;
+if (isDirectRun) {
+  buildProgram().parseAsync(process.argv);
+}
+export {
+  buildProgram
+};