@testsmith/api-spector 0.1.9 → 0.2.1

package/bin/cli.js

@@ -8,7 +8,7 @@ const [, , cmd = 'ui', ...rest] = process.argv
 
 function printHelp() {
   console.log('')
-  console.log('  api Spector — local-first API testing tool')
+  console.log('  API Spector — local-first API testing tool')
   console.log('')
   console.log('  Usage:')
   console.log('    api-spector ui                            Launch the app')
@@ -17,6 +17,9 @@ function printHelp() {
   console.log('    api-spector record --upstream <url>       Record API traffic as mock stubs')
   console.log('')
   console.log('  Options:')
+  console.log('    api-spector agents init <name>            Initialize AI agent files')
+  console.log('    api-spector agents list                   Show available agents')
+  console.log('')
   console.log('    api-spector run    --help                 Show run options')
   console.log('    api-spector mock   --help                 Show mock options')
   console.log('    api-spector record --help                 Show record options')
@@ -59,8 +62,15 @@ if (cmd === '--help' || cmd === '-h') {
     env: process.env,
   })
   proc.on('close', code => process.exit(code ?? 0))
+} else if (cmd === 'agents') {
+  const agentsPath = path.join(__dirname, '..', 'out', 'main', 'agents.js')
+  const proc = spawn(process.execPath, [agentsPath, ...rest], {
+    stdio: 'inherit',
+    env: process.env,
+  })
+  proc.on('close', code => process.exit(code ?? 0))
 } else {
-  console.error(`api Spector — unknown command: "${cmd}"`)
+  console.error(`API Spector — unknown command: "${cmd}"`)
   printHelp()
   process.exit(1)
 }

package/out/main/agents.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+"use strict";
+const promises = require("fs/promises");
+const path = require("path");
+const C = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  green: "\x1B[32m",
+  cyan: "\x1B[36m",
+  yellow: "\x1B[33m",
+  gray: "\x1B[90m",
+  red: "\x1B[31m"
+};
+function color(text, ...codes) {
+  return codes.join("") + text + C.reset;
+}
+const AGENTS = {
+  claude: {
+    name: "Claude Code",
+    description: "Skills for Claude Code (.claude/skills/)",
+    files: [
+      { src: "claude/skills/api-spector-functional-tests.md", dest: ".claude/skills/api-spector-functional-tests/SKILL.md" },
+      { src: "claude/skills/api-spector-security-tests.md", dest: ".claude/skills/api-spector-security-tests/SKILL.md" },
+      { src: "claude/skills/api-spector-generate-mocks.md", dest: ".claude/skills/api-spector-generate-mocks/SKILL.md" },
+      { src: "claude/skills/api-spector-api-audit.md", dest: ".claude/skills/api-spector-api-audit/SKILL.md" }
+    ]
+  },
+  copilot: {
+    name: "GitHub Copilot",
+    description: "Instructions for Copilot (.github/copilot-instructions.md)",
+    files: [
+      { src: "copilot/copilot-instructions.md", dest: ".github/copilot-instructions.md" }
+    ]
+  },
+  cursor: {
+    name: "Cursor",
+    description: "Rules for Cursor (.cursor/rules/api-spector.mdc)",
+    files: [
+      { src: "cursor/rules/api-spector.mdc", dest: ".cursor/rules/api-spector.mdc" }
+    ]
+  },
+  windsurf: {
+    name: "Windsurf",
+    description: "Rules for Windsurf (.windsurfrules)",
+    files: [
+      { src: "windsurf/windsurfrules", dest: ".windsurfrules" }
+    ]
+  },
+  aider: {
+    name: "Aider",
+    description: "Conventions for Aider (conventions.md)",
+    files: [
+      { src: "aider/conventions.md", dest: "conventions.md" }
+    ]
+  }
+};
+function sharedDocsForAgent(agentName) {
+  const destDir = {
+    claude: ".claude/docs",
+    copilot: ".github/docs",
+    cursor: ".cursor/docs",
+    windsurf: ".windsurf/docs",
+    aider: ".aider/docs"
+  };
+  const dir = destDir[agentName] ?? ".api-spector/docs";
+  return [
+    { src: "api-spector-scripting-reference.md", dest: `${dir}/api-spector-scripting-reference.md` },
+    { src: "collection-file-format.md", dest: `${dir}/collection-file-format.md` },
+    { src: "functional-testing-guide.md", dest: `${dir}/functional-testing-guide.md` },
+    { src: "security-testing-guide.md", dest: `${dir}/security-testing-guide.md` }
+  ];
+}
+function getPackageRoot() {
+  let dir = __dirname;
+  for (let i = 0; i < 5; i++) {
+    try {
+      require.resolve(path.join(dir, "package.json"));
+      return dir;
+    } catch {
+      dir = path.dirname(dir);
+    }
+  }
+  return path.join(__dirname, "..", "..");
+}
+function getTemplatesDir() {
+  return path.join(getPackageRoot(), "src", "cli", "agent-templates");
+}
+function getDocsDir() {
+  return path.join(getPackageRoot(), "docs", "ai");
+}
+async function fileExists(path2) {
+  try {
+    await promises.stat(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function copyFile(src, dest, cwd) {
+  const destPath = path.join(cwd, dest);
+  const existed = await fileExists(destPath);
+  await promises.mkdir(path.dirname(destPath), { recursive: true });
+  const content = await promises.readFile(src, "utf8");
+  if (existed) {
+    const existing = await promises.readFile(destPath, "utf8");
+    if (existing === content) return "exists";
+  }
+  await promises.writeFile(destPath, content, "utf8");
+  return existed ? "updated" : "created";
+}
+async function initAgent(agentName, cwd) {
+  const names = agentName === "all" ? Object.keys(AGENTS) : [agentName];
+  for (const name of names) {
+    const agent = AGENTS[name];
+    if (!agent) {
+      console.error(color(`  Unknown agent: "${name}"`, C.red));
+      console.error(`  Available: ${Object.keys(AGENTS).join(", ")}, all`);
+      process.exit(1);
+    }
+    console.log(color(`
+  ${agent.name}`, C.bold, C.cyan));
+    const templatesDir = getTemplatesDir();
+    for (const file of agent.files) {
+      const srcPath = path.join(templatesDir, file.src);
+      if (!await fileExists(srcPath)) {
+        console.log(color(`    skip ${file.dest} (template not found)`, C.yellow));
+        continue;
+      }
+      const result = await copyFile(srcPath, file.dest, cwd);
+      const icon = result === "created" ? color("+", C.green) : result === "updated" ? color("~", C.yellow) : color("=", C.gray);
+      const label = result === "exists" ? "unchanged" : result;
+      console.log(`    ${icon} ${file.dest} ${color(`(${label})`, C.gray)}`);
+    }
+  }
+  console.log(color(`
+  Shared documentation`, C.bold, C.cyan));
+  const docsDir = getDocsDir();
+  const allDocDests = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    for (const doc of sharedDocsForAgent(name)) {
+      if (allDocDests.has(doc.dest)) continue;
+      allDocDests.add(doc.dest);
+      const srcPath = path.join(docsDir, doc.src);
+      if (!await fileExists(srcPath)) {
+        console.log(color(`    skip ${doc.dest} (not found)`, C.yellow));
+        continue;
+      }
+      const result = await copyFile(srcPath, doc.dest, cwd);
+      const icon = result === "created" ? color("+", C.green) : result === "updated" ? color("~", C.yellow) : color("=", C.gray);
+      const label = result === "exists" ? "unchanged" : result;
+      console.log(`    ${icon} ${doc.dest} ${color(`(${label})`, C.gray)}`);
+    }
+  }
+  console.log(color("\n  Done. Your AI agent can now generate API Spector tests.\n", C.green));
+}
+function listAgents() {
+  console.log(color("\n  Available agents:\n", C.bold));
+  for (const [key, agent] of Object.entries(AGENTS)) {
+    console.log(`    ${color(key.padEnd(12), C.cyan)} ${agent.description}`);
+  }
+  console.log(`    ${color("all".padEnd(12), C.cyan)} Initialize all agents at once`);
+  console.log(color("\n  Usage: api-spector agents init <name>\n", C.gray));
+}
+function printHelp() {
+  console.log(`
+  ${color("api-spector agents", C.bold)} — manage AI agent configurations
+
+  ${color("Commands:", C.bold)}
+    agents init <name>    Scaffold agent instruction files in the current directory
+    agents list           Show available agents
+    agents --help         Show this message
+
+  ${color("Examples:", C.bold)}
+    api-spector agents init claude     Set up Claude Code skills
+    api-spector agents init copilot    Set up GitHub Copilot instructions
+    api-spector agents init all        Set up all agents at once
+
+  ${color("What this does:", C.gray)}
+    Copies AI instruction files into your project so your LLM coding tool
+    understands the API Spector scripting API and can generate functional
+    and security test plans.
+`);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const subCmd = args[0];
+  if (!subCmd || subCmd === "--help" || subCmd === "-h") {
+    printHelp();
+    process.exit(0);
+  }
+  if (subCmd === "list") {
+    listAgents();
+    process.exit(0);
+  }
+  if (subCmd === "init") {
+    const agentName = args[1]?.toLowerCase();
+    if (!agentName) {
+      console.error(color("  Missing agent name. Use: api-spector agents init <name>", C.red));
+      console.error(`  Available: ${Object.keys(AGENTS).join(", ")}, all`);
+      process.exit(1);
+    }
+    await initAgent(agentName, process.cwd());
+    process.exit(0);
+  }
+  console.error(color(`  Unknown sub-command: "${subCmd}"`, C.red));
+  printHelp();
+  process.exit(1);
+}
+main().catch((err) => {
+  console.error(color(`  Error: ${err.message}`, C.red));
+  process.exit(2);
+});

package/out/main/chunks/{request-handler-DAXUMRyd.js → request-collection-Dx0ZqB54.js}

@@ -30,6 +30,7 @@ const vm = require("vm");
 const tv4 = require("tv4");
 const jsonpathPlus = require("jsonpath-plus");
 const xmldom = require("@xmldom/xmldom");
+const Ajv = require("ajv");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {
@@ -46,6 +47,7 @@ function _interopNamespaceDefault(e) {
   n.default = e;
   return Object.freeze(n);
 }
+const crypto__namespace = /* @__PURE__ */ _interopNamespaceDefault(crypto);
 const vm__namespace = /* @__PURE__ */ _interopNamespaceDefault(vm);
 let globals = {};
 let currentDir = null;
@@ -185,11 +187,27 @@ function interpolate(str, vars) {
   });
 }
 function buildUrl(baseUrl, params, vars) {
-  const url = interpolate(baseUrl, vars);
-  const enabled = params.filter((p) => p.enabled && p.key);
-  if (!enabled.length) return url;
+  const templateTokens = /* @__PURE__ */ new Set();
+  baseUrl.replace(/\{\{([^}]+)\}\}/g, (_m, name) => {
+    templateTokens.add(String(name).trim());
+    return "";
+  });
+  const enabled = (params ?? []).filter((p) => p.enabled && p.key);
+  const pathRows = [];
+  const queryRows = [];
+  for (const p of enabled) {
+    const isPath = p.paramType === "path" || templateTokens.has(p.key);
+    if (isPath) pathRows.push(p);
+    else queryRows.push(p);
+  }
+  const mergedVars = pathRows.length ? {
+    ...vars,
+    ...Object.fromEntries(pathRows.map((p) => [p.key, interpolate(p.value, vars)]))
+  } : vars;
+  const url = interpolate(baseUrl, mergedVars);
+  if (!queryRows.length) return url;
   const sep = url.includes("?") ? "&" : "?";
-  const qs = enabled.map((p) => `${encodeURIComponent(interpolate(p.key, vars))}=${encodeURIComponent(interpolate(p.value, vars))}`).join("&");
+  const qs = queryRows.map((p) => `${encodeURIComponent(interpolate(p.key, vars))}=${encodeURIComponent(interpolate(p.value, vars))}`).join("&");
   return url + sep + qs;
 }
 async function buildEnvVars(environment) {
@@ -442,7 +460,44 @@ function buildAt(ctx, testResults, consoleOutput) {
     // Expect / assertions
     expect: (value) => makeAsserter(value, false),
     // JSONPath query: sp.jsonPath(data, '$.store.book[?(@.price < 10)].title')
-    jsonPath: (data, expr) => jsonpathPlus.JSONPath({ path: expr, json: data })
+    jsonPath: (data, expr) => jsonpathPlus.JSONPath({ path: expr, json: data }),
+    /**
+     * Generate a TOTP code from a base32-encoded secret.
+     *
+     * Usage in scripts:
+     *   const code = sp.totp("JBSWY3DPEHPK3PXP");
+     *   sp.environment.set("otp", code);
+     *
+     * Options (all optional):
+     *   digits   — code length (default 6)
+     *   period   — time step in seconds (default 30)
+     *   algorithm — "sha1" | "sha256" | "sha512" (default "sha1")
+     */
+    totp: (secret, options) => {
+      const digits = options?.digits ?? 6;
+      const period = options?.period ?? 30;
+      const algorithm = options?.algorithm ?? "sha1";
+      const base32chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+      const cleaned = secret.replace(/[\s=-]/g, "").toUpperCase();
+      let bits = "";
+      for (const c of cleaned) {
+        const val = base32chars.indexOf(c);
+        if (val < 0) throw new Error(`Invalid base32 character: ${c}`);
+        bits += val.toString(2).padStart(5, "0");
+      }
+      const keyBytes = Buffer.alloc(Math.floor(bits.length / 8));
+      for (let i = 0; i < keyBytes.length; i++) {
+        keyBytes[i] = parseInt(bits.slice(i * 8, i * 8 + 8), 2);
+      }
+      const counter = Math.floor(Date.now() / 1e3 / period);
+      const counterBuf = Buffer.alloc(8);
+      counterBuf.writeUInt32BE(Math.floor(counter / 4294967296), 0);
+      counterBuf.writeUInt32BE(counter >>> 0, 4);
+      const hmac = crypto__namespace.createHmac(algorithm, keyBytes).update(counterBuf).digest();
+      const offset = hmac[hmac.length - 1] & 15;
+      const binCode = (hmac[offset] & 127) << 24 | (hmac[offset + 1] & 255) << 16 | (hmac[offset + 2] & 255) << 8 | hmac[offset + 3] & 255;
+      return String(binCode % 10 ** digits).padStart(digits, "0");
+    }
   };
   if (ctx.response) {
     const resp = ctx.response;
@@ -695,6 +750,36 @@ async function fetchOAuth2Token(auth, vars) {
     refreshToken: json["refresh_token"] ? String(json["refresh_token"]) : void 0
   };
 }
+function buildProxyUri(proxy) {
+  const raw = proxy.url.trim();
+  if (!raw) throw new Error("Proxy URL is empty");
+  const normalized = normalizeProxyInput(raw);
+  const parsed = new URL(normalized);
+  if (proxy.auth && (proxy.auth.username || proxy.auth.password)) {
+    parsed.username = proxy.auth.username;
+    parsed.password = proxy.auth.password;
+  }
+  return parsed.toString();
+}
+function normalizeProxyInput(input) {
+  if (input.includes("=")) {
+    const entries = input.split(";").map((part) => part.trim()).filter(Boolean);
+    const map = /* @__PURE__ */ new Map();
+    for (const part of entries) {
+      const idx = part.indexOf("=");
+      if (idx <= 0 || idx === part.length - 1) continue;
+      const key = part.slice(0, idx).trim().toLowerCase();
+      const value = part.slice(idx + 1).trim();
+      if (value) map.set(key, value);
+    }
+    const picked = map.get("https") ?? map.get("http") ?? map.values().next().value;
+    if (picked) return ensureScheme(picked);
+  }
+  return ensureScheme(input);
+}
+function ensureScheme(value) {
+  return /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(value) ? value : `http://${value}`;
+}
 function maskPii(data, patterns) {
   if (!patterns.length) return data;
   try {
@@ -734,6 +819,102 @@ function maskHeaders(headers, patterns) {
   }
   return result;
 }
+function asObject(value) {
+  return value && typeof value === "object" ? value : null;
+}
+function readStringField(obj, key) {
+  const value = obj?.[key];
+  return typeof value === "string" && value ? value : void 0;
+}
+function safeProxySummary(proxy) {
+  if (!proxy?.url?.trim()) return "off";
+  try {
+    const normalized = buildProxyUri({ url: proxy.url });
+    const parsed = new URL(normalized);
+    const host = parsed.port ? `${parsed.hostname}:${parsed.port}` : parsed.hostname;
+    const auth = proxy.auth ? "yes" : "no";
+    return `${parsed.protocol}//${host} auth=${auth}`;
+  } catch {
+    return `invalid input "${proxy.url}"`;
+  }
+}
+function safeTlsSummary(tls) {
+  if (!tls) return "off";
+  const parts = [];
+  if (tls.rejectUnauthorized !== void 0) parts.push(`rejectUnauthorized=${String(tls.rejectUnauthorized)}`);
+  if (tls.caCertPath) parts.push(`ca=${tls.caCertPath}`);
+  if (tls.clientCertPath) parts.push(`cert=${tls.clientCertPath}`);
+  if (tls.clientKeyPath) parts.push(`key=${tls.clientKeyPath}`);
+  return parts.length ? parts.join(", ") : "on";
+}
+function formatRequestError(err, context) {
+  const obj = asObject(err);
+  const message = err instanceof Error ? err.message : String(err);
+  const code = readStringField(obj, "code");
+  const stack = err instanceof Error ? err.stack : void 0;
+  const causeObj = obj ? asObject(obj["cause"]) : null;
+  const causeMessage = readStringField(causeObj, "message");
+  const causeCode = readStringField(causeObj, "code");
+  const lines = [
+    `[request:send] ${context.method} ${context.resolvedUrl}`,
+    `[request:send] requestId=${context.requestId}`,
+    `[request:send] proxy=${safeProxySummary(context.proxy)}`,
+    `[request:send] tls=${safeTlsSummary(context.tls)}`,
+    `[request:send] error=${message}${code ? ` (code=${code})` : ""}`
+  ];
+  if (causeMessage) {
+    lines.push(`[request:send] cause=${causeMessage}${causeCode ? ` (code=${causeCode})` : ""}`);
+  }
+  if (stack) {
+    const preview = stack.split("\n").slice(0, 6).join("\n");
+    lines.push("[request:send] stack:");
+    lines.push(preview);
+  }
+  return lines.join("\n");
+}
+const schemaAjv = new Ajv({ allErrors: true, strict: false });
+function buildSchemaTestResults(schemaText, body) {
+  const trimmed = schemaText?.trim();
+  if (!trimmed) return [];
+  let schema;
+  try {
+    schema = JSON.parse(trimmed);
+  } catch {
+    return [{
+      name: "[schema] body matches schema",
+      passed: false,
+      error: "Schema is not valid JSON"
+    }];
+  }
+  let data;
+  try {
+    data = JSON.parse(body);
+  } catch {
+    return [{
+      name: "[schema] body matches schema",
+      passed: false,
+      error: "Response body is not valid JSON — cannot validate against schema"
+    }];
+  }
+  let validate;
+  try {
+    validate = schemaAjv.compile(schema);
+  } catch (e) {
+    return [{
+      name: "[schema] body matches schema",
+      passed: false,
+      error: `Schema compile error: ${e instanceof Error ? e.message : String(e)}`
+    }];
+  }
+  if (validate(data)) {
+    return [{ name: "[schema] body matches schema", passed: true }];
+  }
+  return (validate.errors ?? []).map((err) => ({
+    name: `[schema] body${err.instancePath ? ` at ${err.instancePath}` : ""}`,
+    passed: false,
+    error: err.message ?? "Schema violation"
+  }));
+}
 async function buildDispatcher(proxy, tls) {
   const connectOpts = {};
   let hasTls = false;
@@ -762,11 +943,10 @@ async function buildDispatcher(proxy, tls) {
     }
   }
   if (proxy?.url) {
-    const proxyUri = proxy.auth ? proxy.url.replace("://", `://${encodeURIComponent(proxy.auth.username)}:${encodeURIComponent(proxy.auth.password)}@`) : proxy.url;
-    const proxyConnect = { rejectUnauthorized: false, ...connectOpts };
     return new undici.ProxyAgent({
       uri: proxyUri,
-      connect: proxyConnect
+      requestTls: proxyConnect,
+      proxyTls: proxyConnect
     });
   }
   if (hasTls) {
@@ -785,6 +965,10 @@ function registerRequestHandler(ipc) {
       tls,
       piiMaskPatterns = []
     } = payload;
+    if (!req.headers) req.headers = [];
+    if (!req.params) req.params = [];
+    if (!req.body) req.body = { mode: "none" };
+    if (!req.auth) req.auth = { type: "none" };
     const start = Date.now();
     const liveGlobals = getGlobals();
     const mergedGlobals = { ...payloadGlobals, ...liveGlobals };
@@ -809,7 +993,7 @@ function registerRequestHandler(ipc) {
     let updatedEnvVars = { ...envVars };
     let updatedGlobals = { ...mergedGlobals };
     if (req.preRequestScript?.trim()) {
-      const result = await runScript(req.preRequestScript, {
+      const result = await runScript(interpolate(req.preRequestScript, vars), {
         envVars: { ...envVars },
         collectionVars: { ...collectionVars },
         globals: { ...mergedGlobals },
@@ -969,6 +1153,14 @@ function registerRequestHandler(ipc) {
         durationMs
       };
     } catch (err) {
+      const diagnostic = formatRequestError(err, {
+        requestId: req.id,
+        method: req.method,
+        resolvedUrl,
+        proxy,
+        tls
+      });
+      console.error(diagnostic);
       response = {
         status: 0,
         statusText: "Error",
@@ -976,14 +1168,15 @@ function registerRequestHandler(ipc) {
         body: "",
         bodySize: 0,
         durationMs: Date.now() - start,
-        error: err instanceof Error ? err.cause instanceof Error ? `${err.message}: ${err.cause.message}` : err.message : String(err)
+        error: diagnostic
       };
     }
+    const schemaTestResults = !response.error ? buildSchemaTestResults(req.schema, response.body) : [];
     let postTestResults = [];
     let postConsole = [];
     let postError;
     if (req.postRequestScript?.trim() && !response.error) {
-      const result = await runScript(req.postRequestScript, {
+      const result = await runScript(interpolate(req.postRequestScript, vars), {
         envVars: { ...updatedEnvVars },
         collectionVars: { ...updatedCollectionVars },
         globals: { ...updatedGlobals },
@@ -1000,8 +1193,16 @@ function registerRequestHandler(ipc) {
       patchGlobals(result.updatedGlobals);
       await persistGlobals();
     }
+    const combinedTestResults = [...schemaTestResults, ...postTestResults];
+    if (!response.error && response.status >= 400 && combinedTestResults.length === 0) {
+      combinedTestResults.push({
+        name: `HTTP status ${response.status} ${response.statusText}`.trim(),
+        passed: false,
+        error: `Request returned ${response.status} — no assertion was defined to verify the status code.`
+      });
+    }
     const scriptResult = {
-      testResults: postTestResults,
+      testResults: combinedTestResults,
       consoleOutput: [...decryptionWarnings, ...preScriptMeta.consoleOutput, ...postConsole],
       updatedEnvVars,
       updatedCollectionVars,
@@ -1027,12 +1228,78 @@ function registerRequestHandler(ipc) {
     };
   });
 }
+function collectTagged(folder, requests, collectionVars, filterTags, parentPath = [], isRoot = true) {
+  const results = [];
+  const scopePath = isRoot ? parentPath : [...parentPath, folder.name];
+  for (const reqId of folder.requestIds) {
+    const req = requests[reqId];
+    if (!req || req.hookType || req.disabled) continue;
+    const tags = req.meta?.tags ?? [];
+    if (filterTags.length > 0 && !filterTags.some((t) => tags.includes(t))) continue;
+    results.push({ request: req, collectionVars, scopePath });
+  }
+  for (const sub of folder.folders) {
+    const folderTags = sub.tags ?? [];
+    const effectiveTags = filterTags.length === 0 ? filterTags : folderTags.some((t) => filterTags.includes(t)) ? [] : filterTags;
+    results.push(...collectTagged(sub, requests, collectionVars, effectiveTags, scopePath, false));
+  }
+  return results;
+}
+function folderPathTo(root, requestId) {
+  if (root.requestIds.includes(requestId)) return [root];
+  for (const sub of root.folders) {
+    const path2 = folderPathTo(sub, requestId);
+    if (path2.length > 0) return [root, ...path2];
+  }
+  return [];
+}
+function getAllApplicableHooks(folderId, collection) {
+  function chainToFolder(root, targetId) {
+    if (root.id === targetId) return [root];
+    for (const sub of root.folders) {
+      const chain2 = chainToFolder(sub, targetId);
+      if (chain2.length) return [root, ...chain2];
+    }
+    return [];
+  }
+  const chain = chainToFolder(collection.rootFolder, folderId);
+  const beforeAll = [];
+  const before = [];
+  const after = [];
+  const afterAll = [];
+  for (const folder of chain) {
+    const reqs = folder.requestIds.map((id) => collection.requests[id]).filter((r) => r && !r.disabled);
+    beforeAll.push(...reqs.filter((r) => r.hookType === "beforeAll"));
+    before.push(...reqs.filter((r) => r.hookType === "before"));
+  }
+  for (const folder of [...chain].reverse()) {
+    const reqs = folder.requestIds.map((id) => collection.requests[id]).filter((r) => r && !r.disabled);
+    after.push(...reqs.filter((r) => r.hookType === "after"));
+    afterAll.push(...reqs.filter((r) => r.hookType === "afterAll"));
+  }
+  return { beforeAll, before, after, afterAll };
+}
+function resolveInheritedAuthAndHeaders(requestId, collection) {
+  let inheritedAuth = collection.auth && collection.auth.type !== "none" ? collection.auth : null;
+  let inheritedHeaders = collection.headers?.filter((h) => h.enabled && h.key) ?? [];
+  const path2 = folderPathTo(collection.rootFolder, requestId);
+  for (const folder of path2) {
+    if (folder.auth && folder.auth.type !== "none") inheritedAuth = folder.auth;
+    if (folder.headers?.length) {
+      inheritedHeaders = [...inheritedHeaders, ...folder.headers.filter((h) => h.enabled && h.key)];
+    }
+  }
+  return { auth: inheritedAuth, headers: inheritedHeaders };
+}
 exports.buildAuthHeaders = buildAuthHeaders;
 exports.buildDispatcher = buildDispatcher;
 exports.buildDynamicVars = buildDynamicVars;
 exports.buildEnvVars = buildEnvVars;
+exports.buildSchemaTestResults = buildSchemaTestResults;
 exports.buildUrl = buildUrl;
+exports.collectTagged = collectTagged;
 exports.fetchOAuth2Token = fetchOAuth2Token;
+exports.getAllApplicableHooks = getAllApplicableHooks;
 exports.getGlobals = getGlobals;
 exports.getSecret = getSecret;
 exports.initSecretStore = initSecretStore;
@@ -1047,5 +1314,6 @@ exports.performNtlmRequest = performNtlmRequest;
 exports.persistGlobals = persistGlobals;
 exports.registerRequestHandler = registerRequestHandler;
 exports.registerSecretHandlers = registerSecretHandlers;
+exports.resolveInheritedAuthAndHeaders = resolveInheritedAuthAndHeaders;
 exports.runScript = runScript;
 exports.setGlobals = setGlobals;