@testsmith/api-spector 0.3.5 → 0.3.7

package/bin/cli.js

@@ -27,7 +27,7 @@ const COMMANDS = {
 
 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')
@@ -58,7 +58,7 @@ if (cmd === '--help' || cmd === '-h') {
 
 const command = COMMANDS[cmd]
 if (!command) {
-  console.error(`API Spector — unknown command: "${cmd}"`)
+  console.error(`API Spector - unknown command: "${cmd}"`)
   printHelp()
   process.exit(1)
 }
@@ -144,7 +144,7 @@ function tryRepairElectron() {
   const zip = findCachedElectronZip(version)
   if (!zip) return 'no-zip'
 
-  console.error(`  Electron ${version} was already downloaded — repairing the`)
+  console.error(`  Electron ${version} was already downloaded - repairing the`)
   console.error('  installation from the local cache...')
   const distDir = path.join(electronDir, 'dist')
   try { fs.rmSync(distDir, { recursive: true, force: true }) } catch { /* best effort */ }
@@ -180,6 +180,10 @@ const TROUBLESHOOTING_URL =
 
 // ui: spawn electron with the app dir
 if (command.runner === 'electron') {
+  // Immediate feedback: on machines where antivirus scans Electron's binary
+  // at every launch (common on managed Windows), the window can take 10-30 s
+  // to appear — without this line the command looks hung.
+  console.log('Launching API Spector...')
   let loaded = loadElectron()
   let failedZip = null
 
@@ -194,7 +198,7 @@ if (command.runner === 'electron') {
 
   if (loaded.status !== 'ok') {
     console.error('')
-    console.error('  API Spector — failed to launch the UI.')
+    console.error('  API Spector - failed to launch the UI.')
     console.error('')
     if (loaded.status === 'not-installed') {
       console.error('  The electron package is not installed alongside API Spector.')
@@ -221,7 +225,7 @@ if (command.runner === 'electron') {
       if (failedZip) {
         console.error('  Electron\'s binary is missing. A downloaded copy exists at')
         console.error(`    ${failedZip}`)
-        console.error('  but it could not be extracted — the file may be corrupt (delete')
+        console.error('  but it could not be extracted - the file may be corrupt (delete')
         console.error('  it and reinstall), or antivirus is blocking the extraction.')
       } else {
         console.error('  Electron is installed, but its platform binary is missing and no')
@@ -231,7 +235,7 @@ if (command.runner === 'electron') {
         console.error('  Common causes on corporate machines:')
         console.error('')
         console.error('    - Proxy blocks github.com downloads. Note: npm\'s proxy settings')
-        console.error('      do NOT apply to electron\'s downloader — it needs:')
+        console.error('      do NOT apply to electron\'s downloader - it needs:')
         console.error('        ELECTRON_GET_USE_PROXY=1')
         console.error('        GLOBAL_AGENT_HTTPS_PROXY=http://your-proxy:port')
         console.error('      then: npm install -D @testsmith/api-spector --force')
@@ -241,7 +245,7 @@ if (command.runner === 'electron') {
         console.error('        NODE_EXTRA_CA_CERTS=/path/to/corporate-root-ca.pem')
         console.error('')
         console.error('    - ELECTRON_SKIP_BINARY_DOWNLOAD=1 set machine-wide (some IT')
-        console.error('      images do this) — unset it and reinstall.')
+        console.error('      images do this) - unset it and reinstall.')
       }
       console.error('')
       console.error('  Manual fix (works without any of the above): download')

package/out/main/agents.js

@@ -152,7 +152,7 @@ function listAgents() {
 }
 function printHelp() {
   console.log(`
-  ${cliCommon.colorAlways("api-spector agents", cliCommon.C.bold)} — manage AI agent configurations
+  ${cliCommon.colorAlways("api-spector agents", cliCommon.C.bold)} - manage AI agent configurations
 
   ${cliCommon.colorAlways("Commands:", cliCommon.C.bold)}
     agents init <name>    Scaffold agent instruction files in the current directory

package/out/main/chunks/environments-iM3SUM-4.js

@@ -0,0 +1,28 @@
+"use strict";
+function resolveEnvironmentChain(env, all) {
+  if (!env.extends) return env;
+  const chain = [env];
+  const seen = /* @__PURE__ */ new Set([env.name]);
+  let parentName = env.extends;
+  while (parentName && !seen.has(parentName)) {
+    const parent = all.find((e) => e.name === parentName);
+    if (!parent) break;
+    chain.push(parent);
+    seen.add(parent.name);
+    parentName = parent.extends;
+  }
+  if (chain.length === 1) return env;
+  const merged = /* @__PURE__ */ new Map();
+  for (const link of [...chain].reverse()) {
+    for (const v of link.variables) merged.set(v.key, v);
+  }
+  return { ...env, variables: [...merged.values()] };
+}
+function selectEnvironment(workspace, environments, requestedName) {
+  const name = requestedName ?? workspace.settings?.defaultEnvironment;
+  if (!name) return null;
+  const env = environments.find((e) => e.name.toLowerCase() === name.toLowerCase());
+  return env ? resolveEnvironmentChain(env, environments) : null;
+}
+exports.resolveEnvironmentChain = resolveEnvironmentChain;
+exports.selectEnvironment = selectEnvironment;

package/out/main/chunks/{handle-C0IQL-Vl.js → handle-BCnNIZZr.js}

@@ -13,7 +13,9 @@ const IPC = {
     saveEnvironment: "file:saveEnvironment",
     deleteWorkspaceFile: "file:deleteWorkspaceFile",
     saveMock: "file:saveMock",
-    loadMock: "file:loadMock"
+    loadMock: "file:loadMock",
+    loadHistory: "file:loadHistory",
+    saveHistory: "file:saveHistory"
   },
   // ─── Native dialogs ────────────────────────────────────────────────────────
   dialog: {
@@ -103,7 +105,9 @@ const IPC = {
     captureSnapshot: "contract:captureSnapshot",
     listSnapshots: "contract:listSnapshots",
     loadSnapshot: "contract:loadSnapshot",
-    deleteSnapshot: "contract:deleteSnapshot"
+    deleteSnapshot: "contract:deleteSnapshot",
+    recordResult: "contract:recordResult",
+    fuzz: "contract:fuzz"
   },
   // ─── Script hooks ──────────────────────────────────────────────────────────
   script: {

package/out/main/chunks/{import-C5Ngq8hk.js → import-DUKaMYGO.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const uuid = require("uuid");
-const soapHandler = require("./soap-handler-B9x_YCtj.js");
-require("./handle-C0IQL-Vl.js");
+const soapHandler = require("./soap-handler-h0dWIjOK.js");
+require("./handle-BCnNIZZr.js");
 require("https");
 require("http");
 require("@xmldom/xmldom");
@@ -58,7 +58,7 @@ function buildCollectionFromWsdl(name, parsed) {
     version: "1.0",
     id: uuid.v4(),
     name,
-    description: `Imported from WSDL — ${parsed.endpoints[0]?.address ?? parsed.targetNamespace}`,
+    description: `Imported from WSDL - ${parsed.endpoints[0]?.address ?? parsed.targetNamespace}`,
     rootFolder: {
       id: uuid.v4(),
       name: "root",
@@ -104,7 +104,7 @@ function buildMockFromWsdl(name, parsed, existingPorts = []) {
       statusCode: 200,
       headers: { "Content-Type": contentTypeForSoap(version) },
       body: "",
-      description: `SOAP ${version} — dispatched per operation`,
+      description: `SOAP ${version} - dispatched per operation`,
       script: soapHandler.buildMockDispatchScript(),
       // Externalized so workspace JSON stays compact: the dispatch script reads
       // these via the script-runner's `metadata` context binding instead of

package/out/main/chunks/{recorder-DFxJgn9c.js → recorder-0Ij921El.js}

@@ -208,7 +208,7 @@ function entriesToMockServer(entries, upstream, name, port) {
       path: e.request.path,
       statusCode: e.response.status,
       headers: respHeaders,
-      body: e.response.binary ? `[binary — recorded from ${upstream}${e.request.path}]` : e.response.body ?? "",
+      body: e.response.binary ? `[binary - recorded from ${upstream}${e.request.path}]` : e.response.body ?? "",
       description: `Recorded from ${upstream} at ${e.timestamp}`
     });
   }

package/out/main/chunks/request-collection-CBuPjBwa.js

@@ -0,0 +1,118 @@
+"use strict";
+function makeHook(req, collectionVars, hookType, scopeId, scopeAncestors, scopePath, mainRequestId) {
+  return { request: req, collectionVars, isHook: true, hookType, scopeId, scopeAncestors, scopePath, mainRequestId };
+}
+function buildFolderPlan(folder, requests, collectionVars, filterTags, scopeId, ancestorIds, parentPath, wrappers, isRoot) {
+  const result = [];
+  const scopePath = isRoot ? [] : [...parentPath, folder.name];
+  const folderReqs = folder.requestIds.map((id) => requests[id]).filter((r) => r && !r.disabled);
+  const beforeAllHooks = folderReqs.filter((r) => r.hookType === "beforeAll");
+  const beforeHooks = folderReqs.filter((r) => r.hookType === "before");
+  const afterHooks = folderReqs.filter((r) => r.hookType === "after");
+  const afterAllHooks = folderReqs.filter((r) => r.hookType === "afterAll");
+  const regularReqs = folderReqs.filter((r) => !r.hookType);
+  const myWrapper = { scopeId, ancestors: ancestorIds, scopePath, before: beforeHooks, after: afterHooks };
+  const allWrappers = [...wrappers, myWrapper];
+  for (const req of beforeAllHooks) {
+    result.push(makeHook(req, collectionVars, "beforeAll", scopeId, ancestorIds, scopePath));
+  }
+  for (const req of regularReqs) {
+    const tags = req.meta?.tags ?? [];
+    if (filterTags.length > 0 && !filterTags.some((t) => tags.includes(t))) continue;
+    for (const w of allWrappers) {
+      for (const hookReq of w.before) {
+        result.push(makeHook(hookReq, collectionVars, "before", w.scopeId, w.ancestors, w.scopePath, req.id));
+      }
+    }
+    result.push({ request: req, collectionVars, scopeId, scopeAncestors: ancestorIds, scopePath });
+    for (const w of [...allWrappers].reverse()) {
+      for (const hookReq of w.after) {
+        result.push(makeHook(hookReq, collectionVars, "after", w.scopeId, w.ancestors, w.scopePath, req.id));
+      }
+    }
+  }
+  for (const sub of folder.folders) {
+    const folderTags = sub.tags ?? [];
+    const effectiveFilter = filterTags.length === 0 ? filterTags : folderTags.some((t) => filterTags.includes(t)) ? [] : filterTags;
+    result.push(...buildFolderPlan(
+      sub,
+      requests,
+      collectionVars,
+      effectiveFilter,
+      sub.id,
+      [...ancestorIds, scopeId],
+      scopePath,
+      allWrappers,
+      false
+    ));
+  }
+  for (const req of afterAllHooks) {
+    result.push(makeHook(req, collectionVars, "afterAll", scopeId, ancestorIds, scopePath));
+  }
+  return result;
+}
+function folderPathTo(root, requestId) {
+  if (root.requestIds.includes(requestId)) return [root];
+  for (const sub of root.folders) {
+    const path = folderPathTo(sub, requestId);
+    if (path.length > 0) return [root, ...path];
+  }
+  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 path = folderPathTo(collection.rootFolder, requestId);
+  for (const folder of path) {
+    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 };
+}
+function buildRunPlan(collection, folderId, filterTags) {
+  const collectionVars = collection.collectionVariables ?? {};
+  {
+    return buildFolderPlan(
+      collection.rootFolder,
+      collection.requests,
+      collectionVars,
+      filterTags,
+      collection.rootFolder.id,
+      [],
+      [],
+      [],
+      true
+    );
+  }
+}
+exports.buildRunPlan = buildRunPlan;
+exports.getAllApplicableHooks = getAllApplicableHooks;
+exports.resolveInheritedAuthAndHeaders = resolveInheritedAuthAndHeaders;