@qawolf/cli 1.1.0 → 1.3.0

package/README.md

@@ -23,7 +23,7 @@ Try it without installing:
 npx @qawolf/cli --help
 ```
 
-Supported Node versions: active LTS and newer (currently Node 22+). See [nodejs.org](https://nodejs.org).
+Supported Node versions: Node 20.19+. Node 20 reached [end-of-life](https://endoflife.date/nodejs) on 2026-04-30 and no longer receives security updates; it remains supported here only for environments still pinned to Node 20. Prefer Node 22+ where possible.
 
 ### Standalone binaries
 

package/dist/cli.js

@@ -8514,7 +8514,7 @@ var require_BufferList = __commonJS((exports, module) => {
       this.head = this.tail = null;
       this.length = 0;
     };
-    BufferList.prototype.join = function join31(s3) {
+    BufferList.prototype.join = function join32(s3) {
       if (this.length === 0)
         return "";
       var p3 = this.head;
@@ -23070,7 +23070,7 @@ var require_BufferList2 = __commonJS((exports, module) => {
       this.head = this.tail = null;
       this.length = 0;
     };
-    BufferList.prototype.join = function join31(s3) {
+    BufferList.prototype.join = function join32(s3) {
       if (this.length === 0)
         return "";
       var p3 = this.head;
@@ -134044,7 +134044,7 @@ var require_snapshot_utils = __commonJS((exports, module) => {
 // node_modules/undici/lib/mock/snapshot-recorder.js
 var require_snapshot_recorder = __commonJS((exports, module) => {
   var { writeFile, readFile, mkdir } = __require("node:fs/promises");
-  var { dirname: dirname10, resolve: resolve9 } = __require("node:path");
+  var { dirname: dirname11, resolve: resolve9 } = __require("node:path");
   var { setTimeout: setTimeout3, clearTimeout: clearTimeout2 } = __require("node:timers");
   var { InvalidArgumentError: InvalidArgumentError3, UndiciError } = require_errors6();
   var { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } = require_snapshot_utils();
@@ -134239,7 +134239,7 @@ var require_snapshot_recorder = __commonJS((exports, module) => {
         throw new InvalidArgumentError3("Snapshot path is required");
       }
       const resolvedPath = resolve9(path4);
-      await mkdir(dirname10(resolvedPath), { recursive: true });
+      await mkdir(dirname11(resolvedPath), { recursive: true });
       const data2 = Array.from(this.#snapshots.entries()).map(([hash2, snapshot]) => ({
         hash: hash2,
         snapshot
@@ -155130,6 +155130,15 @@ function errorCode(err) {
 function isNoEntError(err) {
   return errorCode(err) === "ENOENT";
 }
+var missingPackagePattern = /Cannot find (?:package|module) '([^']+)'/;
+var pathLikeSpecifierPattern = /^(?:\.|\/|[A-Za-z]:[\\/])/;
+function extractMissingPackage(text) {
+  const specifier = missingPackagePattern.exec(text)?.[1];
+  if (specifier === undefined || pathLikeSpecifierPattern.test(specifier)) {
+    return;
+  }
+  return specifier;
+}
 
 // src/core/messages/auth.ts
 var authMessages = {
@@ -155264,6 +155273,10 @@ var flowsMessages = {
   title: "Flows",
   remoteTitle: "Remote Flows",
   flowCount: (count) => pluralize(count, "flow"),
+  list: {
+    remoteRequiresEnv: "--remote requires --env <env> to pick the environment to list",
+    flagsRequireRemote: "--env and --include-drafts require --remote"
+  },
   pull: {
     downloadingBundle: "Downloading flows bundle",
     fetchingEnvVars: "Fetching environment variables",
@@ -155391,7 +155404,10 @@ var runnerMessages = {
   retrying: (attempt, maxAttempts) => `Retrying (${attempt} of ${maxAttempts})...`,
   screenshot: (path) => `Screenshot: ${path}`,
   managedRuntimeNote: (dir) => `Using managed runtime — override with --deps <dir> or QAWOLF_RUNTIME_DIR:
-${dir}`
+${dir}`,
+  installingProjectDeps: (count) => `Installing ${pluralize(count, "project dependency", "project dependencies")}…`,
+  outerHopCandidateRejected: (dir, missing) => `outer-hop candidate rejected: ${dir} missing ${missing.join(", ")}`,
+  moduleNotFoundHint: (pkg, projectDir) => projectDir === undefined ? `Hint: '${pkg}' could not be resolved. Run from within your flows project so its dependencies can be found.` : `Hint: '${pkg}' could not be resolved. Ensure it is declared in ${projectDir}/package.json "dependencies" and run npm install in that project.`
 };
 // node_modules/env-paths/index.js
 import path from "node:path";
@@ -170010,7 +170026,8 @@ async function validateApiKey(deps) {
 }
 // src/shell/logger.ts
 var import_pino = __toESM(require_pino(), 1);
-import { join as join4 } from "node:path";
+import { mkdirSync as mkdirSync2, openSync } from "node:fs";
+import { dirname, join as join4 } from "node:path";
 function defaultLogPath() {
   return join4(envPaths("qawolf", { suffix: "" }).log, "cli.log");
 }
@@ -170024,7 +170041,8 @@ function resolveStderrLevel(env2, verbose) {
 }
 function createLoggingSystem(opts) {
   const { stderrLevel, logPath } = opts;
-  const dest = import_pino.default.destination({ dest: logPath, mkdir: true, sync: false });
+  mkdirSync2(dirname(logPath), { recursive: true });
+  const dest = import_pino.default.destination({ fd: openSync(logPath, "a"), sync: false });
   const fileLogger = import_pino.default({ level: "debug" }, dest);
   const levelNums = {
     trace: 10,
@@ -171146,45 +171164,6 @@ async function getIdentity(apiKey, deps) {
   return { ok: true, data: parsed.data };
 }
 
-// src/shell/platform/getRemoteFlows.ts
-var remoteFlowSchema = exports_external.object({
-  executionTarget: exports_external.union([exports_external.string(), exports_external.record(exports_external.string(), exports_external.unknown())]),
-  id: exports_external.string(),
-  name: exports_external.string(),
-  path: exports_external.string(),
-  tags: exports_external.array(exports_external.string())
-});
-var remoteFlowsResponseSchema = exports_external.object({
-  flows: exports_external.array(remoteFlowSchema)
-});
-async function getRemoteFlows(apiKey, deps) {
-  const url2 = `${deps.baseUrl}/api/v0/flows?includeDrafts=false`;
-  let response;
-  try {
-    response = await deps.fetch(url2, {
-      headers: { Authorization: `Bearer ${apiKey}` },
-      signal: AbortSignal.timeout(15000)
-    });
-  } catch (error51) {
-    return { ok: false, error: { kind: "network", cause: toError(error51) } };
-  }
-  if (!response.ok) {
-    const body = await response.text().catch(() => "");
-    return {
-      ok: false,
-      error: { kind: "http", status: response.status, body }
-    };
-  }
-  const json2 = await response.json().catch(() => {
-    return;
-  });
-  const parsed = remoteFlowsResponseSchema.safeParse(json2);
-  if (!parsed.success) {
-    return { ok: false, error: { kind: "parse", cause: parsed.error } };
-  }
-  return { ok: true, data: parsed.data };
-}
-
 // src/shell/platform/types.ts
 var environmentListItemSchema = exports_external.object({
   envId: exports_external.string(),
@@ -171238,10 +171217,10 @@ async function listTeamStorageFiles(trpc, args, deps) {
 }
 
 // src/shell/platform/teamStorageAssets.ts
-import { dirname as dirname2, join as join8 } from "node:path";
+import { dirname as dirname3, join as join8 } from "node:path";
 
 // src/shell/platform/teamStorageAssetManifest.ts
-import { dirname } from "node:path";
+import { dirname as dirname2 } from "node:path";
 var assetManifestSchema = exports_external.object({
   version: exports_external.literal(1),
   files: exports_external.array(exports_external.object({
@@ -171285,7 +171264,7 @@ async function writeAssetManifest(assetsAbs, files, fs2) {
     }))
   };
   const path2 = assetManifestPath(assetsAbs);
-  await fs2.mkdir(dirname(path2), { recursive: true });
+  await fs2.mkdir(dirname2(path2), { recursive: true });
   await fs2.writeFile(path2, `${JSON.stringify(manifest, undefined, 2)}
 `);
 }
@@ -171451,7 +171430,7 @@ async function writeAssetSnapshot(args) {
   await args.deps.fs.mkdir(args.tmpAssets, { recursive: true });
   for (const { file: file2, relativePath } of args.safeFiles) {
     const dest = join8(args.tmpAssets, relativePath);
-    await args.deps.fs.mkdir(dirname2(dest), { recursive: true });
+    await args.deps.fs.mkdir(dirname3(dest), { recursive: true });
     if (args.reusable.has(relativePath)) {
       await args.deps.fs.copyFile(join8(args.assetsAbs, relativePath), dest);
       continue;
@@ -171490,14 +171469,6 @@ function createPlatformClient(apiKey, deps) {
         sleep: deps.sleep
       });
     },
-    async getRemoteFlows() {
-      return requestWithRetry({
-        call: () => getRemoteFlows(apiKey, deps),
-        backoffMs: requestBackoffMs2,
-        describe: (err) => describeRequestError(err, deps.baseUrl, "flows"),
-        sleep: deps.sleep
-      });
-    },
     getFlowsBundleUrl: getFlowsBundleUrlImpl,
     callPublicApi: makeCallPublicApiMethod(trpc, deps, requestBackoffMs2),
     async getEnvVars(envId) {
@@ -173618,7 +173589,7 @@ function registerAuthCommand(program2, signals) {
 // package.json
 var package_default = {
   name: "@qawolf/cli",
-  version: "1.1.0",
+  version: "1.3.0",
   description: "Run and manage QA Wolf flows from the terminal, CI, or an AI agent",
   keywords: [
     "automation",
@@ -173676,8 +173647,9 @@ var package_default = {
   dependencies: {
     "@clack/prompts": "1.5.1",
     "@napi-rs/keyring": "1.3.0",
+    "@oxc-node/core": "0.1.0",
     "@playwright/test": "1.60.0",
-    "@qawolf/api-contracts": "0.1.0",
+    "@qawolf/api-contracts": "0.2.0",
     "@qawolf/emails": "1.1.1",
     "@qawolf/flow-targets": "1.0.0",
     "@qawolf/flows": "0.1.1",
@@ -173709,7 +173681,7 @@ var package_default = {
     typescript: "6.0.3"
   },
   engines: {
-    node: ">=22.15.0"
+    node: ">=20.19.0"
   },
   packageManager: "bun@1.3.13"
 };
@@ -174035,15 +174007,15 @@ async function checkFileAssets(deps) {
 
 // src/domains/doctor/checks/nodeVersion.ts
 async function checkNodeVersion(deps) {
-  const minMajor = extractMajor(deps.enginesNode, /^>=\s*(\d+)/);
-  if (minMajor === undefined) {
+  const min = parseVersion(deps.enginesNode, /^>=\s*(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+  if (min === undefined) {
     return {
       name: "node-version",
       status: "fail",
       detail: doctorMessages.nodeVersion.couldNotParseEngines(deps.enginesNode)
     };
   }
-  const actual = extractMajor(deps.processVersion, /^v?(\d+)/);
+  const actual = parseVersion(deps.processVersion, /^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
   if (actual === undefined) {
     return {
       name: "node-version",
@@ -174051,7 +174023,7 @@ async function checkNodeVersion(deps) {
       detail: doctorMessages.nodeVersion.couldNotParseVersion(deps.processVersion)
     };
   }
-  if (actual < minMajor) {
+  if (compareVersions(actual, min) < 0) {
     return {
       name: "node-version",
       status: "fail",
@@ -174065,9 +174037,18 @@ async function checkNodeVersion(deps) {
     version: deps.processVersion.replace(/^v/, "")
   };
 }
-function extractMajor(input, pattern) {
-  const captured = input.trim().match(pattern)?.[1];
-  return captured === undefined ? undefined : Number.parseInt(captured, 10);
+function parseVersion(input, pattern) {
+  const match = input.trim().match(pattern);
+  if (match?.[1] === undefined)
+    return;
+  return [
+    Number.parseInt(match[1], 10),
+    match[2] === undefined ? 0 : Number.parseInt(match[2], 10),
+    match[3] === undefined ? 0 : Number.parseInt(match[3], 10)
+  ];
+}
+function compareVersions(a2, b2) {
+  return a2[0] - b2[0] || a2[1] - b2[1] || a2[2] - b2[2];
 }
 
 // src/domains/doctor/checks/npmRegistry.ts
@@ -174195,13 +174176,13 @@ function renderResults(ui, results) {
 }
 
 // src/domains/flows/ensureDeps.ts
-import { dirname as dirname3, join as join10 } from "node:path";
+import { dirname as dirname4, join as join10 } from "node:path";
 function findEnvDir(flowPath, fs2) {
-  let dir = dirname3(flowPath);
+  let dir = dirname4(flowPath);
   while (true) {
     if (fs2.existsSync(join10(dir, "package.json")))
       return dir;
-    const parent = dirname3(dir);
+    const parent = dirname4(dir);
     if (parent === dir)
       return;
     dir = parent;
@@ -174234,7 +174215,7 @@ import { fileURLToPath } from "url";
 
 // node_modules/fdir/dist/index.mjs
 import { createRequire as createRequire2 } from "module";
-import { basename, dirname as dirname4, normalize as normalize2, relative as relative2, resolve, sep as sep3 } from "path";
+import { basename, dirname as dirname5, normalize as normalize2, relative as relative2, resolve, sep as sep3 } from "path";
 import * as nativeFs from "fs";
 var __require2 = /* @__PURE__ */ createRequire2(import.meta.url);
 function cleanPath(path2) {
@@ -174398,7 +174379,7 @@ function build$2(options, isSynchronous) {
 function isRecursive(path2, resolved, state) {
   if (state.options.useRealPaths)
     return isRecursiveUsingRealPaths(resolved, state);
-  let parent = dirname4(path2);
+  let parent = dirname5(path2);
   let depth = 1;
   while (parent !== state.root && depth < 2) {
     const resolvedPath = state.symlinks.get(parent);
@@ -174406,7 +174387,7 @@ function isRecursive(path2, resolved, state) {
     if (isSameRoot)
       depth++;
     else
-      parent = dirname4(parent);
+      parent = dirname5(parent);
   }
   state.symlinks.set(path2, resolved);
   return depth > 1;
@@ -174602,7 +174583,7 @@ var Walker = class {
           } else {
             resolvedPath = useRealPaths ? resolvedPath : path2;
             const filename = basename(resolvedPath);
-            const directoryPath$1 = normalizePath(dirname4(resolvedPath), this.state.options);
+            const directoryPath$1 = normalizePath(dirname5(resolvedPath), this.state.options);
             resolvedPath = this.joinPath(filename, directoryPath$1);
             this.pushFile(resolvedPath, files, this.state.counts, filters);
           }
@@ -175680,14 +175661,80 @@ function handleFlowsList(ctx, pattern) {
 
 // src/domains/flows/listRemote.ts
 var import_picomatch2 = __toESM(require_picomatch2(), 1);
-async function flowsListRemote(ctx, pattern) {
-  const result = await ctx.platform.getRemoteFlows();
+
+// node_modules/@qawolf/api-contracts/dist/v1/ids.js
+var defaultIdSchemas = {
+  environment: exports_external.string().min(1).describe("The id of the environment."),
+  flow: exports_external.string().min(1).describe("The id of the flow."),
+  run: exports_external.string().min(1).describe("The id of the run.")
+};
+
+// node_modules/@qawolf/api-contracts/dist/v1/flow/index.js
+var makeListFlowsContract = (ids) => {
+  const input = exports_external.object({
+    environmentId: ids.environment,
+    includeDrafts: exports_external.boolean().default(false).describe("Include draft flows in the listing.")
+  });
+  const executionTarget = exports_external.union([exports_external.string().min(1), exports_external.record(exports_external.string(), exports_external.unknown())]).describe("The target the flow executes against, as a preset or object.");
+  const output = exports_external.object({
+    flows: exports_external.array(exports_external.object({
+      executionTarget,
+      flowId: ids.flow,
+      name: exports_external.string(),
+      path: exports_external.string().describe("The flow file path, relative to the repo."),
+      tags: exports_external.array(exports_external.string())
+    }))
+  });
+  return {
+    description: "List the flows of an environment at its latest reconciled commit.",
+    input,
+    kind: "read",
+    name: "flow.list",
+    output
+  };
+};
+
+// node_modules/@qawolf/api-contracts/dist/v1/run/index.js
+var makeCreateRunContract = (ids) => {
+  const input = exports_external.object({
+    environmentId: ids.environment,
+    environmentVariables: exports_external.record(exports_external.string(), exports_external.string()).optional(),
+    flowIds: exports_external.array(ids.flow).min(1),
+    ignoreRules: exports_external.boolean().default(false)
+  });
+  const output = exports_external.object({ runId: ids.run });
+  return {
+    description: "Create a run for selected flows in an environment.",
+    input,
+    kind: "write",
+    name: "run.create",
+    output
+  };
+};
+
+// node_modules/@qawolf/api-contracts/dist/v1/index.js
+var makeContractsV1 = (ids) => ({
+  flow: {
+    list: makeListFlowsContract(ids)
+  },
+  run: {
+    create: makeCreateRunContract(ids)
+  }
+});
+var publicContractsV1 = makeContractsV1(defaultIdSchemas);
+
+// src/domains/flows/listRemote.ts
+async function flowsListRemote(ctx, pattern, options) {
+  const result = await ctx.platform.callPublicApi(publicContractsV1.flow.list, {
+    environmentId: options.env,
+    includeDrafts: options.includeDrafts
+  });
   if (!result.ok) {
     return { error: result.error };
   }
   const matches = pattern ? import_picomatch2.default(pattern) : undefined;
   const items = result.value.flows.filter((f2) => !matches || matches(f2.path)).map((f2) => ({
-    id: f2.id,
+    flowId: f2.flowId,
     file: f2.path,
     name: f2.name,
     tags: f2.tags,
@@ -175717,7 +175764,7 @@ async function flowsListRemote(ctx, pattern) {
 }
 
 // src/domains/flows/pull/handler.ts
-import { dirname as dirname6, join as join23, resolve as resolve7 } from "node:path";
+import { dirname as dirname7, join as join23, resolve as resolve7 } from "node:path";
 
 // src/shell/manifest/io.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -176108,7 +176155,7 @@ async function writeEnvFile(envDir, vars, fs2 = makeDefaultFs()) {
 }
 
 // src/domains/flows/pull/extract.ts
-import { dirname as dirname5, resolve as resolve6 } from "node:path";
+import { dirname as dirname6, resolve as resolve6 } from "node:path";
 import { createGunzip } from "node:zlib";
 
 // node_modules/tar/dist/esm/index.min.js
@@ -179372,7 +179419,7 @@ async function handleEntry(args) {
     total: args.getTotal()
   });
   args.addTotal(size);
-  args.fs.mkdirSync(dirname5(target), { recursive: true });
+  args.fs.mkdirSync(dirname6(target), { recursive: true });
   const chunks = [];
   await new Promise((res, rej) => {
     entry.on("data", (chunk) => chunks.push(chunk));
@@ -179476,7 +179523,7 @@ async function handleFlowsPull(ctx, opts, deps) {
     return { error: validation.error };
   }
   const destAbs = resolve7(opts.out ?? join23(".qawolf", opts.env));
-  const assetsAbs = join23(dirname6(destAbs), "assets");
+  const assetsAbs = join23(dirname7(destAbs), "assets");
   await resolvedDeps.fs.mkdir(assetsAbs, { recursive: true });
   const yes = opts.yes ?? false;
   let archive;
@@ -180012,7 +180059,7 @@ async function defaultRunWebFlowDeps(cwd = process.cwd(), signals) {
 
 // src/domains/runtimeEnv/prepareRunDir.ts
 import { createHash as createHash3 } from "node:crypto";
-import { basename as basename4, dirname as dirname9, join as join28, resolve as resolve8, sep as sep4 } from "node:path";
+import { basename as basename4, dirname as dirname10, join as join28, resolve as resolve8, sep as sep4 } from "node:path";
 
 // src/shell/copyDir.ts
 import { cp, readdir as readdir2 } from "node:fs/promises";
@@ -180053,7 +180100,7 @@ async function readPackageJson(pkgPath, fs3) {
 }
 
 // src/domains/runtimeEnv/innerHop.ts
-import { dirname as dirname7, join as join26 } from "node:path";
+import { dirname as dirname8, join as join26 } from "node:path";
 
 // src/domains/runtimeEnv/symlinkDir.ts
 import { symlink } from "node:fs/promises";
@@ -180072,7 +180119,7 @@ async function populateInnerHop(args) {
     const segments = name.split("/");
     const target = join26(innerModules, ...segments);
     if (segments.length > 1) {
-      await fs3.mkdir(dirname7(target), { recursive: true });
+      await fs3.mkdir(dirname8(target), { recursive: true });
     }
     await createDirSymlink(join26(managedModules, ...segments), target);
   }
@@ -180080,33 +180127,40 @@ async function populateInnerHop(args) {
 
 // src/domains/runtimeEnv/outerHop.ts
 import { lstat } from "node:fs/promises";
-import { dirname as dirname8, join as join27 } from "node:path";
+import { dirname as dirname9, join as join27 } from "node:path";
 var executorPackageNames = new Set(pinnedPackages.map((p3) => p3.name));
 async function populateOuterHop(args) {
   const { projectDir, runDir, fs: fs3 } = args;
   if (projectDir === undefined)
-    return;
-  const nearestNm = await findNearestNodeModulesDir(projectDir);
-  if (nearestNm !== undefined) {
-    await createDirSymlink(nearestNm, join27(runDir, "node_modules"));
-    return;
-  }
+    return { mode: "none" };
   const installableDeps = await readInstallableDeps(projectDir, fs3);
-  if (Object.keys(installableDeps).length > 0) {
-    await installOuterDeps(runDir, installableDeps, fs3);
-  }
-}
-async function findNearestNodeModulesDir(startDir) {
+  const depNames = Object.keys(installableDeps);
+  const { satisfying, rejected } = await findSatisfyingNodeModulesDir(projectDir, depNames, fs3);
+  if (satisfying !== undefined) {
+    await createDirSymlink(satisfying, join27(runDir, "node_modules"));
+    return { mode: "symlink", nodeModulesDir: satisfying };
+  }
+  if (depNames.length === 0)
+    return { mode: "none" };
+  args.onInstallStart?.(depNames.length);
+  await installOuterDeps(runDir, installableDeps, fs3, args.install ?? spawnNpmInstall);
+  return { mode: "install", depCount: depNames.length, rejected };
+}
+async function findSatisfyingNodeModulesDir(startDir, depNames, fs3) {
+  const rejected = [];
   let dir = startDir;
   while (true) {
     const candidate = join27(dir, "node_modules");
     const stats = await lstatSafe(candidate);
     if (stats !== undefined && stats.isDirectory() && !stats.isSymbolicLink()) {
-      return candidate;
+      const missing = depNames.filter((name) => !fs3.existsSync(join27(candidate, name, "package.json")));
+      if (missing.length === 0)
+        return { satisfying: candidate, rejected };
+      rejected.push({ dir: candidate, missing });
     }
-    const parent = dirname8(dir);
+    const parent = dirname9(dir);
     if (parent === dir)
-      return;
+      return { satisfying: undefined, rejected };
     dir = parent;
   }
 }
@@ -180124,7 +180178,12 @@ async function readInstallableDeps(projectDir, fs3) {
   } catch {
     return {};
   }
-  const parsed = JSON.parse(content);
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return {};
+  }
   if (typeof parsed !== "object" || parsed === null)
     return {};
   const rawDeps = parsed["dependencies"];
@@ -180132,11 +180191,11 @@ async function readInstallableDeps(projectDir, fs3) {
     return {};
   return Object.fromEntries(Object.entries(rawDeps).filter(([name]) => !executorPackageNames.has(name)).filter((entry) => typeof entry[1] === "string"));
 }
-async function installOuterDeps(runDir, deps, fs3) {
+async function installOuterDeps(runDir, deps, fs3, install) {
   await fs3.writeFile(join27(runDir, "package.json"), JSON.stringify({ name: "qawolf-run", private: true, dependencies: deps }, undefined, 2));
   await fs3.writeFile(join27(runDir, ".npmrc"), `@qawolf:registry=https://registry.npmjs.org/
 `);
-  const result = await spawnNpmInstall(runDir);
+  const result = await install(runDir);
   if (result.exitCode !== 0) {
     throw new Error(`Failed to install project dependencies into ${runDir}: ${result.stderr.trim()}`);
   }
@@ -180158,10 +180217,16 @@ async function prepareRunDir(args) {
   if (projectDir !== undefined) {
     await writeExecSubpathImports({ execDir, fs: fs3 });
   }
-  await populateOuterHop({ projectDir, runDir, fs: fs3 });
+  const outerHop = await populateOuterHop({
+    projectDir,
+    runDir,
+    fs: fs3,
+    ...args.onInstallStart !== undefined ? { onInstallStart: args.onInstallStart } : {}
+  });
   return {
     files: stagedFiles,
     runDir,
+    outerHop,
     cleanup: () => fs3.rm(runDir, { recursive: true, force: true })
   };
 }
@@ -180181,7 +180246,7 @@ async function stageFlowFiles(args) {
   }
   if (files.length > 1) {
     return Promise.all(files.map(async (f3) => {
-      const dirHash = createHash3("sha256").update(dirname9(f3)).digest("hex").slice(0, 8);
+      const dirHash = createHash3("sha256").update(dirname10(f3)).digest("hex").slice(0, 8);
       const subDir = join28(execDir, dirHash);
       await fs3.mkdir(subDir, { recursive: true });
       const dest = join28(subDir, basename4(f3));
@@ -180244,8 +180309,143 @@ function resolveDepsRoot(args) {
   }, { fs: fs3 });
 }
 
-// src/shell/appium/createAppiumServer.ts
+// src/domains/emails/configureEmails.ts
+async function loadSdkDeps2(cwd) {
+  try {
+    const emailsPath = resolveFromEnvDir(cwd, "@qawolf/emails");
+    return await import(emailsPath);
+  } catch (err) {
+    throw new Error("Could not load @qawolf/emails. Install it in your project: `npm install @qawolf/emails` or `bun add @qawolf/emails`.", { cause: err });
+  }
+}
+async function configureEmails(config2, cwd, deps) {
+  const { createEmailsClient, configureEmailsClient } = deps ?? await loadSdkDeps2(cwd);
+  const client = await createEmailsClient({
+    ...config2,
+    pollForEmailsDefaultTimeoutMs: 60000,
+    waitForMessagesDefaultDelayMs: 1000
+  });
+  configureEmailsClient(client);
+  return client;
+}
+async function registerLazyEmailsClient(getInbox, cwd, deps) {
+  const { configureEmailsClient } = deps ?? await loadSdkDeps2(cwd);
+  configureEmailsClient({ getInbox });
+}
+
+// src/commands/flows/envVarDeps.ts
 import { join as join30 } from "node:path";
+function envFilePath(envDir) {
+  return join30(envDir, ".env");
+}
+async function readEnv(envDir, fs3) {
+  try {
+    return parseDotenv(await fs3.readFile(envFilePath(envDir)));
+  } catch (err) {
+    if (isNoEntError(err))
+      return {};
+    throw err;
+  }
+}
+async function writeEnv(envDir, fs3, vars) {
+  const target = envFilePath(envDir);
+  const tmp = `${target}.${process.pid}.tmp`;
+  await fs3.writeFile(tmp, serializeDotenv(vars), { mode: 384 });
+  await fs3.rename(tmp, target);
+}
+function makeEnvVarDeps(envDir, fs3) {
+  return {
+    setEnvironmentVariable: async (key, value) => {
+      const vars = await readEnv(envDir, fs3);
+      vars[key] = value;
+      await writeEnv(envDir, fs3, vars);
+      process.env[key] = value;
+    },
+    fetchLatestEnvironmentVariables: async () => {
+      const vars = await readEnv(envDir, fs3);
+      for (const [key, value] of Object.entries(vars)) {
+        process.env[key] = value;
+      }
+    }
+  };
+}
+
+// src/commands/flows/flowRuntimeDeps.ts
+async function maybeGetIdentityTeamId(platform) {
+  const identity = await platform.getIdentity();
+  return identity.ok ? identity.value.team.id : undefined;
+}
+function lazyGetInbox({
+  envDir,
+  ctx,
+  platform,
+  env: env2,
+  resolveApiKeyFn,
+  configureEmailsFn,
+  createPlatform
+}) {
+  let getInboxPromise;
+  async function configure() {
+    const explicitEmailerUrl = env2["EMAILER_URL"];
+    let teamId = env2["CLOUD_AGENTS_INBOX_TEAM_ID"];
+    const apiKeyResult = explicitEmailerUrl === undefined ? await resolveApiKeyFn(ctx.configDir, ctx.fs) : undefined;
+    if (teamId === undefined && platform !== undefined) {
+      teamId = await maybeGetIdentityTeamId(platform);
+    }
+    if (teamId === undefined && apiKeyResult !== undefined) {
+      const identityPlatform = createPlatform(apiKeyResult.key, {
+        baseUrl: ctx.apiBaseUrl,
+        fetch: globalThis.fetch,
+        ...ctx.log ? { logger: ctx.log("trpc") } : {}
+      });
+      teamId = await maybeGetIdentityTeamId(identityPlatform);
+    }
+    const teamIdPart = teamId !== undefined ? { teamId } : {};
+    if (explicitEmailerUrl !== undefined) {
+      const client2 = await configureEmailsFn({ emailerUrl: explicitEmailerUrl, ...teamIdPart }, envDir);
+      return client2.getInbox;
+    }
+    if (apiKeyResult === undefined) {
+      throw new Error("getInbox requires EMAILER_URL, QAWOLF_API_KEY, or stored QA Wolf credentials. Run 'qawolf auth login'.");
+    }
+    const client = await configureEmailsFn({ apiKey: apiKeyResult.key, url: `${ctx.apiBaseUrl}/api`, ...teamIdPart }, envDir);
+    return client.getInbox;
+  }
+  return async (...args) => {
+    getInboxPromise ??= configure();
+    const getInbox = await getInboxPromise;
+    return getInbox(...args);
+  };
+}
+async function createFlowRuntimeDeps({
+  envDir,
+  ctx,
+  platform,
+  env: env2 = process.env,
+  resolveApiKeyFn = resolveApiKey,
+  configureEmailsFn = configureEmails,
+  createPlatform = createPlatformClient
+}) {
+  const getInbox = lazyGetInbox({
+    envDir,
+    ctx,
+    platform,
+    env: env2,
+    resolveApiKeyFn,
+    configureEmailsFn,
+    createPlatform
+  });
+  try {
+    await registerLazyEmailsClient(getInbox, envDir);
+  } catch {}
+  return {
+    ...makeEnvVarDeps(envDir, ctx.fs),
+    getInbox
+  };
+}
+
+// src/shell/appium/createAppiumServer.ts
+import { join as join31 } from "node:path";
 
 // src/shell/appium/spawnAppium.ts
 import { spawn as spawn2 } from "node:child_process";
@@ -180320,7 +180520,7 @@ async function createAppiumServer(envDir, signals, params) {
   const spawnFn = params?.deps?.spawn ?? defaultSpawnAppium;
   const findFreePortFn = params?.deps?.findFreePort ?? findFreePort;
   const resolveAppiumBinFn = params?.deps?.resolveAppiumBin ?? resolveAppiumBin;
-  const appiumHome2 = params?.options?.appiumHome ?? join30(envPaths("qawolf").data, "appium");
+  const appiumHome2 = params?.options?.appiumHome ?? join31(envPaths("qawolf").data, "appium");
   const timeoutMs3 = params?.options?.startTimeoutMs ?? defaultStartTimeoutMs;
   const bin = resolveAppiumBinFn(envDir);
   const port = await findFreePortFn();
@@ -180659,12 +180859,12 @@ Install Android Studio and open Tools > SDK Manager.`);
 }
 
 // src/shell/manifest/lookup.ts
-import { basename as basename5, dirname as dirname10, relative as relative6 } from "node:path";
+import { basename as basename5, dirname as dirname11, relative as relative6 } from "node:path";
 async function findFlowStamp(flowAbsPath) {
   let envDir;
-  let current = dirname10(flowAbsPath);
-  while (current !== dirname10(current)) {
-    const parent2 = dirname10(current);
+  let current = dirname11(flowAbsPath);
+  while (current !== dirname11(current)) {
+    const parent2 = dirname11(current);
     if (basename5(parent2) === ".qawolf") {
       envDir = current;
       break;
@@ -180806,6 +181006,9 @@ function createAndroidLaunchContext({
 import path11 from "node:path";
 import { pathToFileURL } from "node:url";
 
+// src/shell/resolver/detectRuntimeCapabilities.ts
+import nodeModule2 from "node:module";
+
 // src/shell/resolver/registerFlowModuleResolver.ts
 import nodeModule from "node:module";
 
@@ -180872,6 +181075,50 @@ function registerFlowModuleResolver() {
   registerHooks({ resolve: flowResolveHook });
 }
 
+// src/shell/resolver/detectRuntimeCapabilities.ts
+function detectRuntimeCapabilities() {
+  return {
+    isBun: globalThis.Bun !== undefined,
+    hasSyncHooks: resolveRegisterHooks(nodeModule2) !== undefined,
+    hasNativeTypeScript: Boolean(process.features.typescript),
+    hasAsyncRegister: typeof nodeModule2.register === "function"
+  };
+}
+
+// src/shell/resolver/selectFlowLoaderStrategy.ts
+function selectFlowLoaderStrategy(caps) {
+  if (caps.isBun)
+    return "none";
+  if (caps.hasNativeTypeScript) {
+    return caps.hasSyncHooks ? "sync-alias" : "none";
+  }
+  return caps.hasAsyncRegister ? "oxc-transpile" : "unsupported";
+}
+
+// src/shell/resolver/registerFlowLoader.ts
+async function defaultRegisterOxcLoader() {
+  try {
+    await import("@oxc-node/core/register");
+  } catch (cause) {
+    throw new Error(`Failed to load the @oxc-node/core TypeScript loader needed to run flows on Node ${process.version}. Ensure @oxc-node/core is installed for this platform (${process.platform}-${process.arch}).`, { cause });
+  }
+}
+async function registerFlowLoader(deps = {}) {
+  const {
+    capabilities = detectRuntimeCapabilities(),
+    registerSyncAlias = registerFlowModuleResolver,
+    registerOxcLoader = defaultRegisterOxcLoader
+  } = deps;
+  const strategy = selectFlowLoaderStrategy(capabilities);
+  if (strategy === "sync-alias") {
+    registerSyncAlias();
+  } else if (strategy === "oxc-transpile") {
+    await registerOxcLoader();
+  } else if (strategy === "unsupported") {
+    throw new Error(`Running TypeScript flows requires Node 20.6+ (for module.register) or a runtime with native TypeScript support. Current runtime: ${process.version}. Upgrade Node to 20.6 or newer.`);
+  }
+}
+
 // src/domains/runner/executorPlugin.ts
 import path10 from "node:path";
 var executorImportDetect = /from ['"]@qawolf\/(?:flows|testkit|emails)/;
@@ -180971,7 +181218,7 @@ async function loadFlowDefault(args) {
     depsRoot = ""
   } = args;
   if (bundleFlow === undefined) {
-    registerFlowModuleResolver();
+    await registerFlowLoader();
     return importDefaultExport(pathToFileURL(flowPath).href, flowPath);
   }
   const code = await bundleFlow(flowPath, depsRoot);
@@ -181180,6 +181427,7 @@ async function runAndroidFlow({
     callback: async (flowDeps) => {
       const androidDeps = {
         ...Object.fromEntries(unsupportedAndroidDepNames.map((name) => [name, notSupported(name)])),
+        ...deps.flowRuntimeDeps,
         inputs: flowDeps.flowInputs,
         workflowInputs: flowDeps.flowInputs,
         setOutput: flowDeps.setOutput,
@@ -181390,6 +181638,7 @@ async function runWebFlow({
     callback: async (flowDeps) => {
       const webDeps = {
         ...Object.fromEntries(unsupportedWebDepNames.map((name) => [name, notSupported(name)])),
+        ...deps.flowRuntimeDeps,
         launch,
         launchWithGpu: launch,
         isGpuAvailable: () => false,
@@ -181422,18 +181671,18 @@ async function runWebFlow({
 }
 
 // src/shell/embeddedWorkerCli.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { basename as basename6, join as join31 } from "node:path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { basename as basename6, join as join32 } from "node:path";
 var embeddedCliPathEnv = "QAWOLF_EMBEDDED_CLI_PATH";
 function extractEmbeddedWorkerCli() {
   const assetPath = process.env[embeddedCliPathEnv];
   if (assetPath === undefined || assetPath === "")
     return;
-  const dir = join31(getDataDir(), "worker");
-  const dest = join31(dir, basename6(assetPath));
+  const dir = join32(getDataDir(), "worker");
+  const dest = join32(dir, basename6(assetPath));
   if (existsSync3(dest))
     return dest;
-  mkdirSync2(dir, { recursive: true });
+  mkdirSync3(dir, { recursive: true });
   writeFileSync2(dest, readFileSync2(assetPath));
   return dest;
 }
@@ -181583,7 +181832,7 @@ function makePooledDispatch(resolvedDir) {
 }
 
 // src/commands/flows/buildRunReporter.ts
-import { dirname as dirname11 } from "node:path";
+import { dirname as dirname12 } from "node:path";
 
 // src/shell/reporter/createConsoleReporter.ts
 import { styleText as styleText3 } from "node:util";
@@ -181675,6 +181924,12 @@ function createConsoleReporter(deps) {
       deps.stderr.write(`${formatted}
 
 `);
+      const missingPackage = extractMissingPackage(errStr);
+      if (missingPackage !== undefined) {
+        deps.stderr.write(`${styleText3("yellow", `${indent}${runnerMessages.moduleNotFoundHint(missingPackage, deps.projectDir)}`)}
+
+`);
+      }
       const counts = tests.total > 0 ? `${tests.passed}/${tests.total} tests ` : "";
       deps.stdout.write(`  ${styleText3("red", "✗")} ${counts}passed ${styleText3("dim", fmtDuration(durationMs))}
 `);
@@ -181727,7 +181982,7 @@ function createCompositeReporter(reporters) {
   };
 }
 // src/shell/reporter/createJUnitReporter.ts
-import { join as join32 } from "node:path";
+import { join as join33 } from "node:path";
 
 // src/shell/reporter/junitXml.ts
 function escapeXml(str) {
@@ -181766,7 +182021,7 @@ ${suites}`;
 
 // src/shell/reporter/createJUnitReporter.ts
 function resolveJUnitOutputPath(junit, outputDir) {
-  return typeof junit === "string" && junit.trim() !== "" ? junit : join32(outputDir, "junit-report.xml");
+  return typeof junit === "string" && junit.trim() !== "" ? junit : join33(outputDir, "junit-report.xml");
 }
 function createJUnitReporter(deps) {
   const flows = [];
@@ -181795,13 +182050,17 @@ function createJUnitReporter(deps) {
 function buildRunReporter(flags, deps) {
   const stdout2 = deps.stdout ?? process.stdout;
   const stderr = deps.stderr ?? process.stderr;
-  const console2 = createConsoleReporter({ stdout: stdout2, stderr });
+  const console2 = createConsoleReporter({
+    stdout: stdout2,
+    stderr,
+    ...deps.projectDir !== undefined ? { projectDir: deps.projectDir } : {}
+  });
   if (flags.junit === undefined)
     return console2;
   const junit = createJUnitReporter({
     outputPath: resolveJUnitOutputPath(flags.junit, flags.outputDir),
     writeFile: (path9, content) => {
-      deps.fs.mkdirSync(dirname11(path9), { recursive: true });
+      deps.fs.mkdirSync(dirname12(path9), { recursive: true });
       deps.fs.writeFileSync(path9, content);
     },
     stderr
@@ -181811,7 +182070,15 @@ function buildRunReporter(flags, deps) {
 
 // src/commands/flows/buildFlowsRunDeps.ts
 function buildFlowsRunDeps(args) {
-  const { ctx, resolvedDir, android, runWebFlowDeps, flags } = args;
+  const {
+    ctx,
+    resolvedDir,
+    android,
+    runWebFlowDeps,
+    flowRuntimeDeps,
+    flags,
+    projectDir
+  } = args;
   return {
     peekFlowMeta: makePeekFlowMeta(ctx.fs),
     installBrowsers: (innerCtx, browsers) => installBrowserList(innerCtx, browsers, {
@@ -181820,9 +182087,9 @@ function buildFlowsRunDeps(args) {
       playwrightCliPath: resolvePlaywrightCli(resolvedDir, process.platform)
     }),
     runWebFlow,
-    runWebFlowDeps,
+    runWebFlowDeps: { ...runWebFlowDeps, flowRuntimeDeps },
     runAndroidFlow,
-    runAndroidFlowDeps: android.deps,
+    runAndroidFlowDeps: { ...android.deps, flowRuntimeDeps },
     bootAndroid: android.boot,
     shutdownAndroid: android.shutdown,
     createPooledDispatch: makePooledDispatch(resolvedDir),
@@ -181832,7 +182099,8 @@ function buildFlowsRunDeps(args) {
     reporter: buildRunReporter(flags, {
       fs: ctx.fs,
       stdout: { write: (text3) => ctx.ui.write(text3) },
-      stderr: { write: (text3) => ctx.ui.write(text3) }
+      stderr: { write: (text3) => ctx.ui.write(text3) },
+      ...projectDir !== undefined ? { projectDir } : {}
     }),
     now: () => Date.now()
   };
@@ -181840,11 +182108,11 @@ function buildFlowsRunDeps(args) {
 
 // src/commands/flows/loadEnvFile.ts
 import { readFile } from "node:fs/promises";
-import { join as join33 } from "node:path";
+import { join as join34 } from "node:path";
 async function loadEnvFile(envDir) {
   let content;
   try {
-    content = await readFile(join33(envDir, ".env"), "utf8");
+    content = await readFile(join34(envDir, ".env"), "utf8");
   } catch (err) {
     if (isNoEntError(err))
       return;
@@ -181880,15 +182148,34 @@ async function runStagedFlows(args) {
     files,
     projectDir,
     depsRoot: runtimeEnv.depsRoot,
-    runRoot: runStagingRoot()
+    runRoot: runStagingRoot(),
+    onInstallStart: (depCount) => ctx.ui.info(runnerMessages.installingProjectDeps(depCount))
   });
+  if (staged.outerHop.mode === "install") {
+    const log31 = ctx.log("runner");
+    for (const candidate of staged.outerHop.rejected) {
+      log31.debug(runnerMessages.outerHopCandidateRejected(candidate.dir, candidate.missing));
+    }
+  }
   const unregisterCleanup = ctx.signals.register(staged.cleanup);
   try {
     const resolvedDir = runtimeEnv.depsRoot;
     await deps.configureTestkit(resolvedDir);
     const android = createAndroidDeps(resolvedDir, ctx.signals);
     const runWebFlowDeps = await deps.runWebFlowDeps(resolvedDir, ctx.signals);
-    return await deps.flowsRun(ctx, staged.files, flags, buildFlowsRunDeps({ ctx, resolvedDir, android, runWebFlowDeps, flags }));
+    const flowRuntimeDeps = await deps.createFlowRuntimeDeps({
+      envDir: resolvedDir,
+      ctx
+    });
+    return await deps.flowsRun(ctx, staged.files, flags, buildFlowsRunDeps({
+      ctx,
+      resolvedDir,
+      android,
+      runWebFlowDeps,
+      flowRuntimeDeps,
+      flags,
+      projectDir
+    }));
   } finally {
     unregisterCleanup();
     await staged.cleanup();
@@ -181903,6 +182190,7 @@ function makeDefaultDeps2(fs9) {
     prepareRunDir: (args) => prepareRunDir({ ...args, fs: fs9 }),
     configureTestkit,
     runWebFlowDeps: defaultRunWebFlowDeps,
+    createFlowRuntimeDeps,
     flowsRun
   };
 }
@@ -181924,7 +182212,7 @@ async function handleFlowsRun(ctx, pattern, flags, deps) {
 }
 
 // src/commands/flows/hybridRunDefaults.ts
-import { join as join34, resolve as resolve9 } from "node:path";
+import { join as join35, resolve as resolve9 } from "node:path";
 function makeDefaultHybridDeps(fs9) {
   return {
     expandPatterns: (patterns, cwd, logger) => expandPatterns(patterns, cwd, logger, fs9),
@@ -181933,7 +182221,8 @@ function makeDefaultHybridDeps(fs9) {
     prepareRunDir: (args) => prepareRunDir({ ...args, fs: fs9 }),
     configureTestkit,
     flowsRun,
-    runWebFlowDeps: defaultRunWebFlowDeps
+    runWebFlowDeps: defaultRunWebFlowDeps,
+    createFlowRuntimeDeps
   };
 }
 async function handleHybridFlowsRun(ctx, pattern, flags, deps) {
@@ -181942,7 +182231,7 @@ async function handleHybridFlowsRun(ctx, pattern, flags, deps) {
   if (validation !== "ok") {
     return { error: validation.error, exitCode: 2 };
   }
-  const envDir = resolve9(join34(".qawolf", flags.env));
+  const envDir = resolve9(join35(".qawolf", flags.env));
   const patternArgs = buildPatternArgs(pattern);
   const globFlows = () => resolvedDeps.expandPatterns(patternArgs, envDir, ctx.log("flows"));
   let files = await globFlows();
@@ -182015,7 +182304,16 @@ async function runWorker(signals) {
     if (input.flow.kind !== "web")
       throw new Error("worker subprocess currently supports web flows only");
     await configureTestkit(input.resolvedDir);
-    const runWebFlowDeps = await defaultRunWebFlowDeps(input.resolvedDir, signals);
+    const fs9 = makeDefaultFs();
+    const apiBaseUrl = process.env["QAWOLF_API_URL"]?.replace(/\/+$/, "") || "https://app.qawolf.com";
+    const flowRuntimeDeps = await createFlowRuntimeDeps({
+      envDir: input.resolvedDir,
+      ctx: { apiBaseUrl, configDir: getConfigDir(), fs: fs9 }
+    });
+    const runWebFlowDeps = {
+      ...await defaultRunWebFlowDeps(input.resolvedDir, signals),
+      flowRuntimeDeps
+    };
     const reporter = {};
     const deps = {
       peekFlowMeta: unavailable("peekFlowMeta"),
@@ -182048,8 +182346,8 @@ var listExamples = `
 Examples:
   $ qawolf flows list
   $ qawolf flows list "flows/checkout/**"
-  $ qawolf flows list --remote
-  $ qawolf flows list "**/checkout/**" --remote`;
+  $ qawolf flows list --remote --env staging
+  $ qawolf flows list "**/checkout/**" --remote --env staging --include-drafts`;
 var pullExamples = `
 Examples:
   $ qawolf flows pull --env staging
@@ -182061,9 +182359,23 @@ function registerFlowsCommand(program2, signals) {
   registerRunWorkerCommand(flows, signals);
   declareCommandKind(flows.command("list [pattern]"), "local", {
     kindNote: "read with --remote"
-  }).description("List flows matching [pattern] from the local project, or from QA Wolf with --remote").option("--remote", "List flows from the QA Wolf platform instead of the local project", false).addHelpText("after", listExamples).action((pattern, opts, command) => {
+  }).description("List flows matching [pattern] from the local project, or from a QA Wolf environment with --remote").option("--remote", "List flows from the QA Wolf platform instead of the local project", false).option("--env <env>", "Environment to list flows from (required with --remote)").option("--include-drafts", "Include draft flows in the listing (requires --remote)", false).addHelpText("after", listExamples).action((pattern, opts, command) => {
     if (opts.remote) {
-      return withAuthContext(signals, (ctx) => flowsListRemote(ctx, pattern))(opts, command);
+      const env3 = opts.env;
+      if (env3 === undefined) {
+        return withContext(signals, async () => ({
+          error: flowsMessages.list.remoteRequiresEnv
+        }))(opts, command);
+      }
+      return withAuthContext(signals, (ctx) => flowsListRemote(ctx, pattern, {
+        env: env3,
+        includeDrafts: opts.includeDrafts
+      }))(opts, command);
+    }
+    if (opts.env !== undefined || opts.includeDrafts) {
+      return withContext(signals, async () => ({
+        error: flowsMessages.list.flagsRequireRemote
+      }))(opts, command);
     }
     return withContext(signals, (ctx) => handleFlowsList(ctx, pattern))(opts, command);
   });
@@ -182073,7 +182385,7 @@ function registerFlowsCommand(program2, signals) {
 }
 
 // src/domains/init/init.ts
-import { dirname as dirname12, join as join35, relative as relative7 } from "node:path";
+import { dirname as dirname13, join as join36, relative as relative7 } from "node:path";
 
 // src/domains/init/templates.ts
 var qawolfConfigTs = `export default {
@@ -182111,9 +182423,9 @@ function makeDefaultInitDeps() {
 async function handleInit(ctx, opts, deps = makeDefaultInitDeps()) {
   ctx.ui.gap();
   ctx.ui.intro(initMessages.title);
-  const configPath = join35(deps.cwd, "qawolf.config.ts");
-  const flowPath = join35(deps.cwd, "src", "flows", "example.flow.ts");
-  const gitignorePath = join35(deps.cwd, ".qawolf", ".gitignore");
+  const configPath = join36(deps.cwd, "qawolf.config.ts");
+  const flowPath = join36(deps.cwd, "src", "flows", "example.flow.ts");
+  const gitignorePath = join36(deps.cwd, ".qawolf", ".gitignore");
   await writeWithPrompt(ctx, configPath, qawolfConfigTs, opts.yes, deps);
   await writeWithPrompt(ctx, flowPath, exampleFlowTs, opts.yes, deps);
   await writeWithPrompt(ctx, gitignorePath, qawolfGitignore, opts.yes, deps);
@@ -182132,12 +182444,12 @@ async function writeWithPrompt(ctx, filePath, content, yes, deps) {
       return;
     }
   }
-  await deps.fs.mkdir(dirname12(filePath), { recursive: true });
+  await deps.fs.mkdir(dirname13(filePath), { recursive: true });
   await deps.fs.writeFile(filePath, content);
   ctx.ui.step(initMessages.createdFile(relPath));
 }
 async function ensurePackageJson(ctx, yes, deps) {
-  const pkgPath = join35(deps.cwd, "package.json");
+  const pkgPath = join36(deps.cwd, "package.json");
   if (!await deps.fs.pathExists(pkgPath)) {
     const confirmed2 = await ctx.ui.confirm(initMessages.createPackageJsonPrompt, { yes });
     if (!confirmed2.ok || !confirmed2.value) {
@@ -182196,19 +182508,19 @@ Examples:
 }
 
 // src/commands/install/android.ts
-import { join as join38 } from "node:path";
+import { join as join39 } from "node:path";
 
 // src/domains/install/android/index.ts
 import { parseExecutionTarget as parseExecutionTarget4 } from "@qawolf/flow-targets";
 
 // src/domains/install/android/avd.ts
-import { join as join36 } from "node:path";
+import { join as join37 } from "node:path";
 async function installAvds(ctx, specs, deps) {
   const versionResult = await deps.spawn(deps.sdkManagerPath, ["--version"]);
   if (versionResult.exitCode !== 0) {
     throw new Error(installMessages.android.sdkmanagerNotFound(deps.sdkManagerPath));
   }
-  const licenseFile = join36(deps.androidHome, "licenses", "android-sdk-license");
+  const licenseFile = join37(deps.androidHome, "licenses", "android-sdk-license");
   if (deps.checkExists(licenseFile)) {
     ctx.ui.info(installMessages.android.licensesAlreadyAccepted);
   } else {
@@ -182222,7 +182534,7 @@ async function installAvds(ctx, specs, deps) {
   for (const spec of specs) {
     if (installedImages.has(spec.systemImage))
       continue;
-    const systemImg = join36(deps.androidHome, ...spec.systemImage.split(";"), "system.img");
+    const systemImg = join37(deps.androidHome, ...spec.systemImage.split(";"), "system.img");
     if (deps.checkExists(systemImg)) {
       ctx.ui.info(installMessages.android.systemImageAlreadyInstalled(spec.systemImage));
       installedImages.add(spec.systemImage);
@@ -182270,9 +182582,9 @@ async function installAvds(ctx, specs, deps) {
 }
 
 // src/domains/install/android/driver.ts
-import { join as join37 } from "node:path";
+import { join as join38 } from "node:path";
 var appiumEnv = {
-  APPIUM_HOME: join37(envPaths("qawolf").data, "appium")
+  APPIUM_HOME: join38(envPaths("qawolf").data, "appium")
 };
 async function installUiautomator2Driver(ctx, deps) {
   const listResult = await deps.spawn(deps.appiumBinPath, ["driver", "list", "--installed"], { env: appiumEnv });
@@ -182359,8 +182671,8 @@ async function handleInstallAndroid(ctx, pattern, envDir) {
     arch: process.arch,
     androidHome: androidHome2,
     checkExists: (path9) => fs9.existsSync(path9),
-    sdkManagerPath: join38(androidHome2, "cmdline-tools", "latest", "bin", "sdkmanager"),
-    avdManagerPath: join38(androidHome2, "cmdline-tools", "latest", "bin", "avdmanager"),
+    sdkManagerPath: join39(androidHome2, "cmdline-tools", "latest", "bin", "sdkmanager"),
+    avdManagerPath: join39(androidHome2, "cmdline-tools", "latest", "bin", "avdmanager"),
     expandPatterns: (patterns, cwd) => expandPatterns(patterns, cwd ?? process.cwd(), undefined, fs9),
     peekFlowMeta: makePeekFlowMeta(fs9),
     resolveDepsRoot: async (files) => envDir ?? (await resolveDepsRoot({ files, fs: fs9 })).depsRoot,
@@ -182506,39 +182818,6 @@ Examples:
   });
 }
 
-// node_modules/@qawolf/api-contracts/dist/v1/ids.js
-var defaultIdSchemas = {
-  environment: exports_external.string().min(1).describe("The id of the environment."),
-  flow: exports_external.string().min(1).describe("The id of the flow."),
-  run: exports_external.string().min(1).describe("The id of the run.")
-};
-
-// node_modules/@qawolf/api-contracts/dist/v1/run/index.js
-var makeCreateRunContract = (ids) => {
-  const input = exports_external.object({
-    environmentId: ids.environment,
-    environmentVariables: exports_external.record(exports_external.string(), exports_external.string()).optional(),
-    flowIds: exports_external.array(ids.flow).min(1),
-    ignoreRules: exports_external.boolean().default(false)
-  });
-  const output = exports_external.object({ runId: ids.run });
-  return {
-    description: "Create a run for selected flows in an environment.",
-    input,
-    kind: "write",
-    name: "run.create",
-    output
-  };
-};
-
-// node_modules/@qawolf/api-contracts/dist/v1/index.js
-var makeContractsV1 = (ids) => ({
-  run: {
-    create: makeCreateRunContract(ids)
-  }
-});
-var publicContractsV1 = makeContractsV1(defaultIdSchemas);
-
 // src/core/publicApi/flagSpecs.ts
 var kebabCase = (field) => field.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`);
 function flagKind(schema) {
@@ -182635,8 +182914,16 @@ function buildSpec(contract, path9) {
     contract
   };
 }
-function buildCommandSpecs(tree) {
-  const walk3 = (node2, path9) => Object.entries(node2).flatMap(([key, value]) => isContract(value) ? [buildSpec(value, [...path9, key])] : walk3(value, [...path9, key]));
+function buildCommandSpecs(tree, options = {}) {
+  const skip = options.skipContractNames;
+  const walk3 = (node2, path9) => Object.entries(node2).flatMap(([key, value]) => {
+    const childPath = [...path9, key];
+    if (!isContract(value))
+      return walk3(value, childPath);
+    if (skip?.has(childPath.join(".")))
+      return [];
+    return [buildSpec(value, childPath)];
+  });
   return walk3(tree, []);
 }
 
@@ -182707,6 +182994,7 @@ async function handlePublicApiCommand(ctx, spec, options) {
 var groupDescriptions = {
   run: "Trigger and manage QA Wolf runs on the platform"
 };
+var handWrittenContractNames = new Set(["flow.list"]);
 function resolveGroup(parent2, segment) {
   const existing = parent2.commands.find((command) => command.name() === segment);
   return existing ?? parent2.command(segment).description(groupDescriptions[segment] ?? `QA Wolf public API ${segment} commands`);
@@ -182732,7 +183020,9 @@ function registerSpec(program2, signals, spec, authDeps) {
   command.action((options, leaf) => withAuthContext(signals, (ctx) => handlePublicApiCommand(ctx, spec, options), authDeps ?? {})(options, leaf));
 }
 function registerPublicApiCommands(program2, signals, options = {}) {
-  const specs = buildCommandSpecs(options.contracts ?? publicContractsV1);
+  const specs = buildCommandSpecs(options.contracts ?? publicContractsV1, {
+    skipContractNames: handWrittenContractNames
+  });
   for (const spec of specs) {
     registerSpec(program2, signals, spec, options.authDeps);
   }
@@ -182773,4 +183063,4 @@ createProgram({ signals }).parseAsync().catch(() => {
     process.exitCode = 1;
 }).finally(() => flushAndExit(typeof process.exitCode === "number" ? process.exitCode : 0));
 
-//# debugId=1EAFDAECED4A4A1164756E2164756E21
+//# debugId=64AB4032821CC8E864756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qawolf/cli",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Run and manage QA Wolf flows from the terminal, CI, or an AI agent",
   "keywords": [
     "automation",
@@ -58,8 +58,9 @@
   "dependencies": {
     "@clack/prompts": "1.5.1",
     "@napi-rs/keyring": "1.3.0",
+    "@oxc-node/core": "0.1.0",
     "@playwright/test": "1.60.0",
-    "@qawolf/api-contracts": "0.1.0",
+    "@qawolf/api-contracts": "0.2.0",
     "@qawolf/emails": "1.1.1",
     "@qawolf/flow-targets": "1.0.0",
     "@qawolf/flows": "0.1.1",
@@ -91,7 +92,7 @@
     "typescript": "6.0.3"
   },
   "engines": {
-    "node": ">=22.15.0"
+    "node": ">=20.19.0"
   },
   "packageManager": "bun@1.3.13"
 }

package/skills/qawolf-cli/SKILL.md

@@ -41,7 +41,7 @@ write on timeout: it may have reached the server the first time.
 | `qawolf auth logout`      | local                      | Remove stored credentials                                                                                              |
 | `qawolf auth whoami`      | read                       | Show authentication status                                                                                             |
 | `qawolf doctor`           | local                      | Diagnose problems running flows locally                                                                                |
-| `qawolf flows list`       | local (read with --remote) | List flows matching [pattern] from the local project, or from QA Wolf with --remote                                    |
+| `qawolf flows list`       | local (read with --remote) | List flows matching [pattern] from the local project, or from a QA Wolf environment with --remote                      |
 | `qawolf flows pull`       | read                       | Download an environment's flows into the local .qawolf/<env>/ cache                                                    |
 | `qawolf flows run`        | local (read with --env)    | Run flows matching [pattern], or every flow when omitted; with --env, pull missing flows from that QA Wolf environment |
 | `qawolf init`             | local                      | Scaffold a QA Wolf project in the current directory                                                                    |