@testsmith/api-spector 0.7.6 → 0.7.8

package/out/main/lib.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const mockServer = require("./chunks/mock-server-C4kTFkod.js");
-const requestExec = require("./chunks/request-exec-CwJ8_OKC.js");
-const flowEngine = require("./chunks/flow-engine-BVzjz4lJ.js");
+const requestExec = require("./chunks/request-exec-Cv2jkrO1.js");
+const flowEngine = require("./chunks/flow-engine-BxwjEy37.js");
 require("node:http");
 require("node:crypto");
 require("node:vm");
@@ -11,13 +11,16 @@ require("@xmldom/xmldom");
 require("undici");
 require("fs/promises");
 require("tls");
-require("./chunks/handle-DRmKOL-s.js");
+require("./chunks/handle-Crv1i9hb.js");
 require("node:fs");
 require("node:os");
 require("node:path");
 require("node:fs/promises");
 require("tv4");
 require("jsonpath-plus");
+require("mqtt");
+require("ws");
+require("socket.io-client");
 require("ajv");
 const refKey = (ref) => `${ref.collectionId}:${ref.requestId}`;
 async function runFlowHeadless(input) {

package/out/main/perf-worker.js

@@ -0,0 +1,45 @@
+"use strict";
+const perfRun = require("./chunks/perf-run-uZBqnG3S.js");
+const requestExec = require("./chunks/request-exec-Cv2jkrO1.js");
+require("@grpc/grpc-js");
+require("@grpc/proto-loader");
+require("node:fs");
+require("node:os");
+require("node:path");
+require("./chunks/flow-engine-BxwjEy37.js");
+require("./chunks/request-collection-gkOYlWml.js");
+require("uuid");
+require("undici");
+require("fs/promises");
+require("tls");
+require("./chunks/handle-Crv1i9hb.js");
+require("node:crypto");
+require("node:fs/promises");
+require("dayjs");
+require("node:vm");
+require("tv4");
+require("jsonpath-plus");
+require("@xmldom/xmldom");
+require("mqtt");
+require("ws");
+require("socket.io-client");
+require("node:http");
+require("ajv");
+const port = process.parentPort;
+port.on("message", (e) => {
+  const msg = e.data;
+  if (msg.type === "stop") {
+    perfRun.stopPerfRun();
+    return;
+  }
+  if (msg.type !== "run" || !msg.payload) return;
+  void (async () => {
+    try {
+      if (msg.payload.secretsConfig) requestExec.setSecretsConfig(msg.payload.secretsConfig);
+      const result = await perfRun.runPerfPlan(msg.payload, (p) => port.postMessage({ type: "progress", p }));
+      port.postMessage({ type: "result", result });
+    } catch (err) {
+      port.postMessage({ type: "error", message: err instanceof Error ? err.message : String(err) });
+    }
+  })();
+});

package/out/main/perf.js

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+"use strict";
+const promises = require("node:fs/promises");
+const path = require("node:path");
+const requestExec = require("./chunks/request-exec-Cv2jkrO1.js");
+const environments = require("./chunks/environments-iM3SUM-4.js");
+const flowEngine = require("./chunks/flow-engine-BxwjEy37.js");
+const perfRun = require("./chunks/perf-run-uZBqnG3S.js");
+const perfReport = require("./chunks/perf-report-ChaO3K0w.js");
+const cliCommon = require("./chunks/cli-common-GnihVSjU.js");
+require("undici");
+require("fs/promises");
+require("tls");
+require("./chunks/handle-Crv1i9hb.js");
+require("node:fs");
+require("node:os");
+require("node:crypto");
+require("dayjs");
+require("node:vm");
+require("tv4");
+require("jsonpath-plus");
+require("@xmldom/xmldom");
+require("mqtt");
+require("ws");
+require("socket.io-client");
+require("node:http");
+require("ajv");
+require("@grpc/grpc-js");
+require("@grpc/proto-loader");
+require("./chunks/request-collection-gkOYlWml.js");
+require("uuid");
+require("./chunks/data-files-BYqhsoPe.js");
+function parseDurationSec(s) {
+  if (s == null) return void 0;
+  const str = String(s).trim();
+  if (/^\d+(\.\d+)?$/.test(str)) return Number(str);
+  let total = 0;
+  let matched = false;
+  for (const m of str.matchAll(/(\d+)\s*(h|m|s)/gi)) {
+    matched = true;
+    total += Number(m[1]) * (m[2].toLowerCase() === "h" ? 3600 : m[2].toLowerCase() === "m" ? 60 : 1);
+  }
+  return matched ? total : void 0;
+}
+function parseThreshold(spec) {
+  const m = spec.trim().match(/^(\S+)\s*(lt|lte|gt|gte|<=|>=|<|>)\s*([\d.]+)$/i);
+  if (!m) return null;
+  const opMap = { "<": "lt", "<=": "lte", ">": "gt", ">=": "gte", lt: "lt", lte: "lte", gt: "gt", gte: "gte" };
+  const metric = m[1];
+  const op = opMap[m[2].toLowerCase()];
+  const valid = ["iteration_p95", "iteration_p99", "req_p95", "error_rate", "throughput"];
+  if (!valid.includes(metric) || !op) return null;
+  return { metric, op, value: Number(m[3]) };
+}
+function fmtMs(v) {
+  return v < 1 ? "<1 ms" : v < 1e3 ? `${Math.round(v)} ms` : `${(v / 1e3).toFixed(2)} s`;
+}
+function applyOverrides(plan, args) {
+  const p = JSON.parse(JSON.stringify(plan));
+  const num = (k) => {
+    const v = args[k];
+    return typeof v === "string" && v.trim() !== "" && Number.isFinite(Number(v)) ? Number(v) : void 0;
+  };
+  const dur = (k) => typeof args[k] === "string" ? parseDurationSec(args[k]) : void 0;
+  if (typeof args.pattern === "string" && ["basic", "stepping", "arrivals", "custom"].includes(args.pattern)) p.pattern = args.pattern;
+  if (num("vus") !== void 0) p.basic.vus = num("vus");
+  if (dur("duration") !== void 0) {
+    p.basic.durationSec = dur("duration");
+    p.arrivals.durationSec = dur("duration");
+  }
+  if (dur("ramp-up") !== void 0) p.basic.rampUpSec = dur("ramp-up");
+  if (dur("ramp-down") !== void 0) p.basic.rampDownSec = dur("ramp-down");
+  if (num("rate") !== void 0) p.arrivals.rate = num("rate");
+  if (num("max-vus") !== void 0) p.arrivals.maxVus = num("max-vus");
+  if (num("start-users") !== void 0) p.stepping.startUsers = num("start-users");
+  if (num("step-users") !== void 0) p.stepping.stepUsers = num("step-users");
+  if (dur("step-duration") !== void 0) p.stepping.stepDurationSec = dur("step-duration");
+  if (num("max-users") !== void 0) p.stepping.maxUsers = num("max-users");
+  if (dur("timeout") !== void 0) p.timeoutSec = dur("timeout");
+  if (typeof args.think === "string") {
+    const t = args.think.trim();
+    const range = t.match(/^([\d.]+)\s*-\s*([\d.]+)$/);
+    if (range) p.thinkTime = { minSec: Number(range[1]), maxSec: Number(range[2]) };
+    else if (Number.isFinite(Number(t))) p.thinkTime = { minSec: Number(t), maxSec: Number(t) };
+  }
+  const thr = args.threshold;
+  if (thr !== void 0) {
+    const specs = Array.isArray(thr) ? thr : [thr];
+    const parsed = specs.map(parseThreshold).filter((x) => !!x);
+    p.thresholds = parsed;
+  }
+  return p;
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const positionals = [];
+  for (const a of argv) {
+    if (a.startsWith("--")) break;
+    positionals.push(a);
+  }
+  const sub = positionals[0];
+  const name = positionals[1];
+  const args = cliCommon.parseArgs(argv, ["threshold"]);
+  if (args.help || !sub || sub !== "run" && sub !== "list") {
+    console.log('\nUsage:\n  api-spector perf list --workspace <path>\n  api-spector perf run <plan> --workspace <path> [--vus N] [--duration 5m] [--rate N] [--threshold "iteration_p95 lt 500"] [--out report.html]\n');
+    process.exit(args.help ? 0 : 1);
+  }
+  const wsPath = args.workspace;
+  if (!wsPath) {
+    console.error(cliCommon.color("Error: --workspace is required", cliCommon.C.red));
+    process.exit(1);
+  }
+  let workspace, wsDir;
+  try {
+    ({ workspace, dir: wsDir } = await cliCommon.loadWorkspace(wsPath));
+  } catch {
+    console.error(cliCommon.color(`Error: could not read workspace: ${wsPath}`, cliCommon.C.red));
+    process.exit(1);
+  }
+  await requestExec.loadGlobals(wsDir);
+  requestExec.setSecretsConfig(workspace.settings?.secrets);
+  const plans = workspace.perfPlans ?? [];
+  if (sub === "list") {
+    if (plans.length === 0) {
+      console.log(cliCommon.color("  No performance plans in this workspace.", cliCommon.C.gray));
+      process.exit(0);
+    }
+    console.log("");
+    for (const pl of plans) {
+      const load2 = perfRun.deriveLoad(pl);
+      const tgt = pl.target.kind === "request" ? "request" : pl.target.kind === "sequence" ? "sequence" : "flow";
+      console.log(`  ${cliCommon.color(pl.name, cliCommon.C.bold, cliCommon.C.white)}  ${cliCommon.color(`(${tgt}, ${pl.pattern}, ~${load2.totalSec}s)`, cliCommon.C.gray)}`);
+    }
+    console.log("");
+    process.exit(0);
+  }
+  if (!name) {
+    console.error(cliCommon.color("Error: a plan name is required: api-spector perf run <plan>", cliCommon.C.red));
+    process.exit(1);
+  }
+  const basePlan = plans.find((pl) => pl.name.toLowerCase() === name.toLowerCase());
+  if (!basePlan) {
+    console.error(cliCommon.color(`Error: plan "${name}" not found. Run \`api-spector perf list\` to see plans.`, cliCommon.C.red));
+    process.exit(1);
+  }
+  const plan = applyOverrides(basePlan, args);
+  const collections = await cliCommon.loadCollections(workspace, wsDir, { onError: (relPath) => console.error(cliCommon.color(`  [warn] Could not load collection: ${relPath}`, cliCommon.C.yellow)) });
+  const environments$1 = await cliCommon.loadEnvironments(workspace, wsDir);
+  const env = environments.selectEnvironment(workspace, environments$1, args.environment ?? args.env);
+  const flowsAll = (await cliCommon.loadFlows(workspace, wsDir, () => {
+  })).map(flowEngine.normalizeFlow);
+  const globals = requestExec.getGlobals();
+  const payload = { plan, environment: env ?? null, globals, proxy: workspace.settings?.proxy, tls: workspace.settings?.tls };
+  let targetLabel = "";
+  if (plan.target.kind === "request") {
+    let found;
+    let foundCol;
+    for (const c of collections) {
+      const r = c.requests[plan.target.requestId];
+      if (r) {
+        found = r;
+        foundCol = c;
+        break;
+      }
+    }
+    if (!found) {
+      console.error(cliCommon.color("Error: the plan's request was not found in this workspace.", cliCommon.C.red));
+      process.exit(1);
+    }
+    const envVars = await requestExec.buildEnvVars(env);
+    payload.request = found;
+    payload.vars = { ...globals, ...foundCol?.collectionVariables ?? {}, ...envVars };
+    targetLabel = `${found.method} ${found.name}`;
+  } else if (plan.target.kind === "sequence") {
+    const seqCol = collections.find((c) => c.id === plan.target.collectionId);
+    if (!seqCol) {
+      console.error(cliCommon.color("Error: the plan's collection was not found in this workspace.", cliCommon.C.red));
+      process.exit(1);
+    }
+    payload.collection = seqCol;
+    targetLabel = `sequence: ${seqCol.name}${plan.target.folderId ? " / folder" : ""}`;
+  } else {
+    const flow = flowsAll.find((f) => f.id === plan.target.flowId);
+    if (!flow) {
+      console.error(cliCommon.color("Error: the plan's flow was not found in this workspace.", cliCommon.C.red));
+      process.exit(1);
+    }
+    payload.flow = flow;
+    payload.flows = flowsAll;
+    payload.collections = collections;
+    targetLabel = `flow: ${flow.name}`;
+  }
+  const load = perfRun.deriveLoad(plan);
+  const version = `v${"0.7.8"}`;
+  console.log("");
+  console.log(cliCommon.color("  API Performance" + (version ? ` ${version}` : ""), cliCommon.C.bold, cliCommon.C.white));
+  console.log(cliCommon.color(`  Plan:        ${plan.name}`, cliCommon.C.gray));
+  console.log(cliCommon.color(`  Target:      ${targetLabel}`, cliCommon.C.gray));
+  console.log(cliCommon.color(`  Pattern:     ${plan.pattern} (${load.executor}, ~${load.totalSec}s)`, cliCommon.C.gray));
+  console.log(cliCommon.color(`  Environment: ${env?.name ?? "(none)"}`, cliCommon.C.gray));
+  if (plan.thresholds.length) console.log(cliCommon.color(`  Thresholds:  ${plan.thresholds.map((t) => `${t.metric} ${t.op} ${t.value}`).join(", ")}`, cliCommon.C.gray));
+  console.log("");
+  const quiet = Boolean(args.quiet);
+  let lastPrint = 0;
+  const result = await perfRun.runPerfPlan(payload, (p) => {
+    if (quiet) return;
+    const now = Date.now();
+    if (now - lastPrint < 1e3) return;
+    lastPrint = now;
+    process.stdout.write(`\r  ${cliCommon.color("running", cliCommon.C.cyan)} ${Math.round(p.elapsedMs / 1e3)}s  iters ${p.iterations}  active ${p.activeVus}  ${p.iterationsPerSec.toFixed(1)}/s  p95 ${fmtMs(p.p95)}  failed ${p.iterationsFailed}   `);
+  }).catch((err) => {
+    console.error("\n" + cliCommon.color(`Error: ${err instanceof Error ? err.message : String(err)}`, cliCommon.C.red));
+    process.exit(1);
+  });
+  if (!quiet) process.stdout.write("\n\n");
+  const errorRate = result.iterations > 0 ? result.iterationsFailed / result.iterations * 100 : 0;
+  console.log(cliCommon.color("  Results", cliCommon.C.bold, cliCommon.C.white));
+  console.log(`    Throughput    ${cliCommon.color(result.iterationsPerSec.toFixed(1) + " iter/s", cliCommon.C.cyan)}  (${result.requestsPerSec.toFixed(1)} req/s)`);
+  console.log(`    Iteration p95 ${fmtMs(result.iterationLatency.p95)}   p99 ${fmtMs(result.iterationLatency.p99)}`);
+  console.log(`    Error rate    ${errorRate.toFixed(1)}%  (${result.iterationsFailed}/${result.iterations})`);
+  console.log(`    Peak users    ${result.peakVus}${result.droppedArrivals ? `   dropped ${result.droppedArrivals}` : ""}`);
+  console.log(`    Duration      ${fmtMs(result.durationMs)}`);
+  console.log("");
+  console.log(cliCommon.color("  Steps", cliCommon.C.bold, cliCommon.C.white));
+  for (const [i, s] of result.steps.entries()) {
+    const label = result.mode === "request" ? s.name : `${i + 1}. ${s.name}`;
+    console.log(`    ${label.padEnd(36).slice(0, 36)}  p95 ${fmtMs(s.latency.p95).padStart(8)}  ${cliCommon.color(s.failed ? `${s.failed} failed` : "ok", s.failed ? cliCommon.C.red : cliCommon.C.green)}`);
+  }
+  console.log("");
+  if (result.thresholds.length) {
+    console.log(cliCommon.color("  Thresholds", cliCommon.C.bold, cliCommon.C.white));
+    for (const t of result.thresholds) {
+      const actual = t.metric === "error_rate" ? `${t.actual.toFixed(1)}%` : t.metric === "throughput" ? t.actual.toFixed(1) : fmtMs(t.actual);
+      console.log(`    ${t.passed ? cliCommon.color("✓", cliCommon.C.green) : cliCommon.color("✗", cliCommon.C.red)} ${t.metric} ${t.op} ${t.value}  (actual ${actual})`);
+    }
+    console.log("");
+    console.log(result.passed ? cliCommon.color("  PASSED", cliCommon.C.green, cliCommon.C.bold) : cliCommon.color("  FAILED", cliCommon.C.red, cliCommon.C.bold));
+    console.log("");
+  }
+  const out = args.out;
+  if (out) {
+    const content = path.extname(out).toLowerCase() === ".json" ? JSON.stringify(result, null, 2) : perfReport.perfReportToHtml(result, { planName: plan.name, target: targetLabel, generatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    await promises.writeFile(out, content, "utf8");
+    console.log(cliCommon.color(`  Report written to ${out}`, cliCommon.C.gray));
+    console.log("");
+  }
+  if (args.json) console.log(JSON.stringify(result, null, 2));
+  process.exit(result.passed ? 0 : 1);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/out/main/runner.js

@@ -2,15 +2,16 @@
 "use strict";
 const promises = require("node:fs/promises");
 const path = require("node:path");
-const requestExec = require("./chunks/request-exec-CwJ8_OKC.js");
+const requestExec = require("./chunks/request-exec-Cv2jkrO1.js");
 const escape = require("./chunks/escape-DDVAlOvZ.js");
-const requestCollection = require("./chunks/request-collection-KGPuvN7o.js");
+const requestCollection = require("./chunks/request-collection-gkOYlWml.js");
+const runConcurrent = require("./chunks/run-concurrent-468tH0AX.js");
 const environments = require("./chunks/environments-iM3SUM-4.js");
 const cliCommon = require("./chunks/cli-common-GnihVSjU.js");
 require("undici");
 require("fs/promises");
 require("tls");
-require("./chunks/handle-DRmKOL-s.js");
+require("./chunks/handle-Crv1i9hb.js");
 require("node:fs");
 require("node:os");
 require("node:crypto");
@@ -19,6 +20,9 @@ require("node:vm");
 require("tv4");
 require("jsonpath-plus");
 require("@xmldom/xmldom");
+require("mqtt");
+require("ws");
+require("socket.io-client");
 require("node:http");
 require("ajv");
 require("uuid");
@@ -437,6 +441,58 @@ function buildSarifReport(results, _summary, meta = {}) {
     }]
   }, null, 2);
 }
+const ASK_RE = /\{\{\s*@([^}]+?)\s*\}\}/g;
+function parseInner(inner) {
+  const m = /^(.*?)\[([^\]]*)\]\s*$/.exec(inner);
+  if (m) {
+    const choices = m[2].split(",").map((s) => s.trim()).filter(Boolean);
+    return { message: m[1].trim(), choices: choices.length ? choices : void 0 };
+  }
+  return { message: inner.trim() };
+}
+function extractAskVars(texts) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const text of texts) {
+    if (!text) continue;
+    for (const m of text.matchAll(ASK_RE)) {
+      const inner = m[1].trim();
+      const key = `@${inner}`;
+      if (seen.has(key)) continue;
+      const { message, choices } = parseInner(inner);
+      if (!message) continue;
+      seen.set(key, { key, message, choices });
+    }
+  }
+  return [...seen.values()];
+}
+function askVarsInRequest(req) {
+  const texts = [req.url];
+  for (const p of req.params ?? []) texts.push(p.key, p.value);
+  for (const h of req.headers ?? []) texts.push(h.key, h.value);
+  const b = req.body;
+  if (b) {
+    texts.push(b.json, b.raw);
+    if (b.graphql) texts.push(b.graphql.query, b.graphql.variables);
+    for (const f of b.form ?? []) texts.push(f.key, f.value);
+    if (b.soap) texts.push(b.soap.envelope);
+    if (b.grpc) texts.push(b.grpc.message);
+  }
+  try {
+    texts.push(JSON.stringify(req.auth ?? {}));
+  } catch {
+  }
+  return extractAskVars(texts);
+}
+function resolveAskValues(asks, answers) {
+  const out = {};
+  for (const a of asks) out[a.key] = answers[a.message] ?? "";
+  return out;
+}
+function missingAskMessages(asks, answers) {
+  const missing = [];
+  for (const a of asks) if (!(a.message in answers) && !missing.includes(a.message)) missing.push(a.message);
+  return missing;
+}
 function printResult(r, verbose) {
   const icon = r.status === "passed" ? cliCommon.color("✓", cliCommon.C.green, cliCommon.C.bold) : r.status === "failed" ? cliCommon.color("✗", cliCommon.C.red, cliCommon.C.bold) : r.status === "skipped" ? cliCommon.color("○", cliCommon.C.gray, cliCommon.C.bold) : cliCommon.color("⚠", cliCommon.C.yellow, cliCommon.C.bold);
   const http = r.httpStatus ? cliCommon.color(` ${r.httpStatus}`, r.httpStatus < 400 ? cliCommon.C.green : cliCommon.C.red) : "";
@@ -457,7 +513,7 @@ async function main() {
   const args = cliCommon.parseArgs(process.argv.slice(2));
   if (args.help) {
     console.log(
-      "\nUsage:\n  api-spector run --workspace <path> [--environment <name>] [--tags <a,b>]\n                  [--collection <name>] [--output <path>] [--format json|junit|html|sarif]\n                  [--verbose] [--bail]\n"
+      '\nUsage:\n  api-spector run --workspace <path> [--environment <name>] [--tags <a,b>]\n                  [--collection <name>] [--output <path>] [--format json|junit|html|sarif]\n                  [--ask "Message=value"] [--concurrency <n>] [--verbose] [--bail]\n\n  --ask "Message=value"  Supply an ask variable ({{@Message}}) for this run\n                         (repeatable). Requests whose ask variables are not\n                         supplied are skipped.\n  --concurrency <n>      Run n requests at a time (default 1 = sequential).\n                         Hooks run as barriers; best for independent requests.\n'
     );
     process.exit(0);
   }
@@ -495,13 +551,21 @@ async function main() {
   } else if (!envName && workspace.settings?.defaultEnvironment && !env) {
     console.warn(cliCommon.color(`Warning: default environment "${workspace.settings.defaultEnvironment}" not found. Running without environment.`, cliCommon.C.yellow));
   }
-  const version = `v${"0.7.6"}`;
+  const version = `v${"0.7.8"}`;
   console.log("");
   console.log(cliCommon.color("  API Test Runner" + (version ? ` ${version}` : ""), cliCommon.C.bold, cliCommon.C.white));
   console.log(cliCommon.color(`  Workspace:   ${wsPath}`, cliCommon.C.gray));
   console.log(cliCommon.color(`  Environment: ${env?.name ?? "(none)"}`, cliCommon.C.gray));
   if (filterTags.length) console.log(cliCommon.color(`  Tags:        ${filterTags.join(", ")}`, cliCommon.C.gray));
   console.log("");
+  const askAnswers = {};
+  const askArgRaw = args["ask"];
+  for (const entry of Array.isArray(askArgRaw) ? askArgRaw : askArgRaw ? [askArgRaw] : []) {
+    if (typeof entry !== "string") continue;
+    const eq = entry.indexOf("=");
+    if (eq > 0) askAnswers[entry.slice(0, eq).trim()] = entry.slice(eq + 1);
+  }
+  const concurrency = Math.max(1, Math.min(20, Math.floor(Number(args["concurrency"] ?? 1) || 1)));
   const envVarsSnapshot = await requestExec.buildEnvVars(env);
   const secretValuesToMask = (env?.variables ?? []).filter((v) => (v.secret || v.secretRef) && v.enabled).map((v) => envVarsSnapshot[v.key]).filter((v) => typeof v === "string" && v.length > 0);
   function redact(s) {
@@ -556,6 +620,7 @@ async function main() {
     let runGlobals = requestExec.getGlobals();
     let runCollectionVars = { ...col.collectionVariables };
     let runLocalVars = {};
+    const runFolderVars = {};
     console.log(cliCommon.color(`  ┌ ${col.name}`, cliCommon.C.bold, cliCommon.C.white));
     const workspaceTls = workspace.settings?.tls;
     const effectiveTls = col.tls ? { ...workspaceTls, ...col.tls } : workspaceTls;
@@ -580,9 +645,11 @@ async function main() {
       if (verbose && lines.length) lines.forEach((l) => console.log(cliCommon.color(`    [${phase}] ${l}`, cliCommon.C.gray)));
       if (phase === "pre" && error) console.error(cliCommon.color(`    [pre-script error] ${error}`, cliCommon.C.red));
     };
-    for (const item of items) {
+    if (concurrency <= 1) for (const item of items) {
       const { isHook, hookType, scopeId } = item;
       const skipReason = skipTracker.shouldSkip(item);
+      const itemAsks = askVarsInRequest(item.request);
+      const missingAsks = itemAsks.length ? missingAskMessages(itemAsks, askAnswers) : [];
       let result;
       if (skipReason) {
         result = {
@@ -599,13 +666,32 @@ async function main() {
           scopePath: item.scopePath,
           iterationLabel: item.iterationLabel
         };
+      } else if (missingAsks.length) {
+        result = {
+          requestId: item.request.id,
+          name: item.request.name,
+          method: item.request.method,
+          resolvedUrl: item.request.url,
+          status: "skipped",
+          error: `Ask variable(s) not provided: ${missingAsks.join(", ")} (use --ask "${missingAsks[0]}=value")`,
+          isHook,
+          hookType,
+          scopeId,
+          collection: item.collection,
+          scopePath: item.scopePath,
+          iterationLabel: item.iterationLabel
+        };
       } else {
         const out = await requestExec.executeRunnerRequest({
           req: item.request,
-          collectionVars: { ...item.collectionVars, ...runCollectionVars },
+          collectionVars: { ...item.collectionVars, ...runCollectionVars, ...resolveAskValues(itemAsks, askAnswers) },
           envVars: runEnvVars,
           globals: runGlobals,
           localVars: { ...runLocalVars, ...item.dataRow },
+          folderVars: {
+            ...item.folderVars ?? {},
+            ...item.folderId ? runFolderVars[item.folderId] ?? {} : {}
+          },
           dispatcher,
           piiMaskPatterns: piiPatterns,
           tls: effectiveTls,
@@ -618,6 +704,9 @@ async function main() {
         runCollectionVars = out.updatedCollectionVars;
         runGlobals = out.updatedGlobals;
         runLocalVars = out.updatedLocalVars;
+        if (item.folderId) {
+          runFolderVars[item.folderId] = { ...runFolderVars[item.folderId] ?? {}, ...out.updatedFolderVars };
+        }
         result.isHook = isHook;
         result.hookType = hookType;
         result.scopeId = scopeId;
@@ -644,6 +733,91 @@ async function main() {
         break;
       }
     }
+    else {
+      const resultsByIndex = new Array(items.length);
+      const preResult = (item, status, error) => ({
+        requestId: item.request.id,
+        name: item.request.name,
+        method: item.request.method,
+        resolvedUrl: item.request.url,
+        status,
+        error,
+        isHook: item.isHook,
+        hookType: item.hookType,
+        scopeId: item.scopeId,
+        collection: item.collection,
+        scopePath: item.scopePath,
+        iterationLabel: item.iterationLabel
+      });
+      const runItem = async (item, i) => {
+        const skipReason = skipTracker.shouldSkip(item);
+        const itemAsks = askVarsInRequest(item.request);
+        const missingAsks = itemAsks.length ? missingAskMessages(itemAsks, askAnswers) : [];
+        if (skipReason) {
+          resultsByIndex[i] = preResult(item, "failed", skipReason);
+          return;
+        }
+        if (missingAsks.length) {
+          resultsByIndex[i] = preResult(item, "skipped", `Ask variable(s) not provided: ${missingAsks.join(", ")}`);
+          return;
+        }
+        try {
+          const out = await requestExec.executeRunnerRequest({
+            req: item.request,
+            collectionVars: { ...item.collectionVars, ...runCollectionVars, ...resolveAskValues(itemAsks, askAnswers) },
+            envVars: runEnvVars,
+            globals: runGlobals,
+            localVars: { ...runLocalVars, ...item.dataRow },
+            folderVars: { ...item.folderVars ?? {}, ...item.folderId ? runFolderVars[item.folderId] ?? {} : {} },
+            dispatcher,
+            piiMaskPatterns: piiPatterns,
+            tls: effectiveTls,
+            expectStatus: item.expectStatus,
+            owaspTag: item.owaspTag
+          });
+          runEnvVars = { ...runEnvVars, ...out.updatedEnvVars };
+          runCollectionVars = { ...runCollectionVars, ...out.updatedCollectionVars };
+          runGlobals = { ...runGlobals, ...out.updatedGlobals };
+          runLocalVars = { ...runLocalVars, ...out.updatedLocalVars };
+          if (item.folderId) runFolderVars[item.folderId] = { ...runFolderVars[item.folderId] ?? {}, ...out.updatedFolderVars };
+          const result = out.result;
+          result.isHook = item.isHook;
+          result.hookType = item.hookType;
+          result.scopeId = item.scopeId;
+          result.collection = item.collection;
+          result.scopePath = item.scopePath;
+          result.iterationLabel = item.iterationLabel;
+          skipTracker.recordResult(item, result.status);
+          resultsByIndex[i] = result;
+        } catch (e) {
+          resultsByIndex[i] = preResult(item, "error", e instanceof Error ? e.message : String(e));
+          skipTracker.recordResult(item, "error");
+        }
+      };
+      await runConcurrent.runPlanConcurrent(concurrency, items, (it) => Boolean(it.isHook), runItem);
+      for (let i = 0; i < items.length; i++) {
+        const result = resultsByIndex[i];
+        if (!result) continue;
+        const item = items[i];
+        const scopeKey = (item.scopePath ?? []).join(" / ");
+        if (scopeKey !== lastPrintedScope) {
+          if (scopeKey) console.log(cliCommon.color(`    ${scopeKey}`, cliCommon.C.gray, cliCommon.C.bold));
+          lastPrintedScope = scopeKey;
+        }
+        printResult(result, verbose);
+        allResults.push(result);
+        summary.total++;
+        if (result.status === "passed") summary.passed++;
+        else if (result.status === "failed") summary.failed++;
+        else if (result.status === "skipped") summary.skipped++;
+        else summary.errors++;
+        if (bail && (result.status === "failed" || result.status === "error")) {
+          console.log(cliCommon.color("\n  Bailing after first failure.", cliCommon.C.yellow));
+          bailed = true;
+          break;
+        }
+      }
+    }
     console.log("");
     if (bailed) break;
   }