@testsmith/api-spector 0.1.9 → 0.2.0

package/out/main/chunks/{request-handler-DAXUMRyd.js → request-handler-AFBOd__c.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 templateTokens = /* @__PURE__ */ new Set();
+  baseUrl.replace(/\{\{([^}]+)\}\}/g, (_m, name) => {
+    templateTokens.add(String(name).trim());
+    return "";
+  });
   const enabled = params.filter((p) => p.enabled && p.key);
-  if (!enabled.length) return url;
+  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) {
@@ -809,7 +989,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 +1149,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 +1164,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 +1189,16 @@ function registerRequestHandler(ipc) {
       patchGlobals(result.updatedGlobals);
       await persistGlobals();
     }
+    const combinedTestResults = [...schemaTestResults, ...postTestResults];
+    if (!response.error && response.status >= 400 && !combinedTestResults.some((t) => !t.passed)) {
+      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,
@@ -1031,6 +1228,7 @@ exports.buildAuthHeaders = buildAuthHeaders;
 exports.buildDispatcher = buildDispatcher;
 exports.buildDynamicVars = buildDynamicVars;
 exports.buildEnvVars = buildEnvVars;
+exports.buildSchemaTestResults = buildSchemaTestResults;
 exports.buildUrl = buildUrl;
 exports.fetchOAuth2Token = fetchOAuth2Token;
 exports.getGlobals = getGlobals;

package/out/main/index.js

@@ -25,7 +25,7 @@ const electron = require("electron");
 const path = require("path");
 const fs = require("fs");
 const promises = require("fs/promises");
-const requestHandler = require("./chunks/request-handler-DAXUMRyd.js");
+const requestHandler = require("./chunks/request-handler-AFBOd__c.js");
 const uuid = require("uuid");
 const jsYaml = require("js-yaml");
 const undici = require("undici");
@@ -458,6 +458,39 @@ function schemaToExample(schema) {
       return null;
   }
 }
+function buildResponseSchema(operation, spec) {
+  const responses = operation.responses;
+  if (!responses || typeof responses !== "object") return void 0;
+  const codes = Object.keys(responses);
+  const ordered = [];
+  if (codes.includes("200")) ordered.push("200");
+  if (codes.includes("201")) ordered.push("201");
+  for (const code of codes.sort()) {
+    if (/^2\d\d$/.test(code) && !ordered.includes(code)) ordered.push(code);
+  }
+  for (const code of codes) {
+    if (/^2xx$/i.test(code) && !ordered.includes(code)) ordered.push(code);
+  }
+  if (codes.includes("default")) ordered.push("default");
+  for (const code of ordered) {
+    const responseObj = resolve(spec, responses[code]);
+    const content = responseObj?.content;
+    if (!content || typeof content !== "object") continue;
+    const mediaKeys = Object.keys(content);
+    const jsonKey = mediaKeys.find((k) => k.toLowerCase().split(";")[0].trim() === "application/json") ?? mediaKeys.find((k) => /[+/]json(\b|;)/i.test(k)) ?? mediaKeys.find((k) => k.toLowerCase().includes("json"));
+    if (!jsonKey) continue;
+    const rawSchema = content[jsonKey]?.schema;
+    if (!rawSchema) continue;
+    const resolved = resolve(spec, rawSchema);
+    if (!resolved || typeof resolved === "object" && Object.keys(resolved).length === 0) continue;
+    try {
+      return JSON.stringify(resolved, null, 2);
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
 function buildBody(operation, spec) {
   const content = resolve(spec, operation.requestBody?.content ?? {});
   if ("application/json" in content) {
@@ -475,6 +508,39 @@ function buildParams(operation) {
     description: p.description ?? ""
   }));
 }
+function buildPathParamRows(operation) {
+  return (operation.parameters ?? []).filter((p) => p.in === "path" && p.name).map((p) => {
+    const schema = p.schema ?? {};
+    let value;
+    if (p.example !== void 0) value = p.example;
+    else if (schema.example !== void 0) value = schema.example;
+    else if (schema.default !== void 0) value = schema.default;
+    else if (Array.isArray(schema.enum) && schema.enum.length) value = schema.enum[0];
+    else {
+      switch (schema.type) {
+        case "integer":
+        case "number":
+          value = 1;
+          break;
+        case "boolean":
+          value = true;
+          break;
+        default:
+          value = "";
+      }
+    }
+    return {
+      key: String(p.name),
+      value: value === null || value === void 0 ? "" : String(value),
+      enabled: true,
+      description: p.description ?? "",
+      paramType: "path"
+    };
+  });
+}
+function rewritePathTemplate(url) {
+  return url.replace(/\{([^/{}]+)\}/g, (_m, name) => `{{${name}}}`);
+}
 function buildHeaders(operation) {
   return (operation.parameters ?? []).filter((p) => p.in === "header").map((p) => ({
     key: p.name,
@@ -524,17 +590,24 @@ function buildCollection(spec) {
       const allParams = [...pathLevelParams, ...operation.parameters ?? []];
       const opWithParams = { ...operation, parameters: allParams };
       const security = operation.security ?? globalSecurity;
+      const params = [
+        ...buildPathParamRows(opWithParams),
+        ...buildParams(opWithParams)
+      ];
+      const rawOperation = pathItem[method];
+      const responseSchema = buildResponseSchema(rawOperation, spec);
       const req = {
         id: uuid.v4(),
         name: operation.summary ?? operation.operationId ?? `${method.toUpperCase()} ${pathStr}`,
         method: method.toUpperCase(),
-        url: `${baseUrl}${pathStr}`,
+        url: rewritePathTemplate(`${baseUrl}${pathStr}`),
         headers: buildHeaders(opWithParams),
-        params: buildParams(opWithParams),
+        params,
         auth: buildAuth(security, securitySchemes),
         body: buildBody(opWithParams, spec),
         description: operation.description ?? "",
-        meta: { tags }
+        meta: { tags },
+        ...responseSchema ? { schema: responseSchema } : {}
       };
       requests[req.id] = req;
       if (!foldersByTag[tag]) {
@@ -558,6 +631,32 @@ async function importOpenApi(filePath) {
 async function importOpenApiFromUrl(url) {
   return buildCollection(await loadSpecFromUrl(url));
 }
+function extractSchemas(spec) {
+  const entries = [];
+  for (const [pathStr, pathItem] of Object.entries(spec.paths ?? {})) {
+    for (const method of HTTP_METHODS$1) {
+      const operation = pathItem?.[method];
+      if (!operation) continue;
+      const schema = buildResponseSchema(operation, spec);
+      if (!schema) continue;
+      entries.push({
+        method: method.toUpperCase(),
+        pathTemplate: pathStr,
+        pathRewritten: rewritePathTemplate(pathStr),
+        schema,
+        operationId: operation.operationId,
+        summary: operation.summary
+      });
+    }
+  }
+  return entries;
+}
+async function extractSchemasFromFile(filePath) {
+  return extractSchemas(await loadSpec$1(filePath));
+}
+async function extractSchemasFromUrl(url) {
+  return extractSchemas(await loadSpecFromUrl(url));
+}
 function parseHeaders(headers) {
   return (headers ?? []).map((h) => ({
     key: h.name ?? "",
@@ -871,6 +970,18 @@ function registerImportHandlers(ipc) {
     if (result.canceled || !result.filePaths[0]) return null;
     return importBruno(result.filePaths[0]);
   });
+  ipc.handle("import:openapi-schemas", async () => {
+    const result = await electron.dialog.showOpenDialog({
+      title: "Load OpenAPI spec for schema sync",
+      filters: [{ name: "OpenAPI", extensions: ["json", "yaml", "yml"] }],
+      properties: ["openFile"]
+    });
+    if (result.canceled || !result.filePaths[0]) return null;
+    return extractSchemasFromFile(result.filePaths[0]);
+  });
+  ipc.handle("import:openapi-schemas-url", async (_event, url) => {
+    return extractSchemasFromUrl(url);
+  });
 }
 function safeName(name) {
   return name.replace(/[^\w\s]/g, " ").split(/\s+/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
@@ -2219,11 +2330,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) return new undici.Agent({ connect: connectOpts });
@@ -2243,7 +2353,7 @@ async function executeOne(req, collectionVars, envVars, globals, localVars, disp
   let updatedGlobals = { ...globals };
   let preScriptError;
   if (req.preRequestScript?.trim()) {
-    const r = await requestHandler.runScript(req.preRequestScript, {
+    const r = await requestHandler.runScript(requestHandler.interpolate(req.preRequestScript, vars), {
       envVars: { ...envVars },
       collectionVars: { ...collectionVars },
       globals: { ...globals },
@@ -2324,18 +2434,19 @@ async function executeOne(req, collectionVars, envVars, globals, localVars, disp
       bodySize: Buffer.byteLength(responseBody, "utf8"),
       durationMs
     };
-    let testResults = [];
+    const schemaTestResults = requestHandler.buildSchemaTestResults(req.schema, responseBody);
+    let testResults = [...schemaTestResults];
     let consoleOutput = [];
     let postScriptError;
     if (req.postRequestScript?.trim()) {
-      const r = await requestHandler.runScript(req.postRequestScript, {
+      const r = await requestHandler.runScript(requestHandler.interpolate(req.postRequestScript, vars), {
         envVars: updatedEnvVars,
         collectionVars: updatedCollectionVars,
         globals: updatedGlobals,
         localVars,
         response
       });
-      testResults = r.testResults;
+      testResults = [...schemaTestResults, ...r.testResults];
       consoleOutput = r.consoleOutput;
       postScriptError = r.error;
       updatedEnvVars = r.updatedEnvVars;
@@ -2346,7 +2457,19 @@ async function executeOne(req, collectionVars, envVars, globals, localVars, disp
       await requestHandler.persistGlobals();
     }
     const allPassed = testResults.every((t) => t.passed);
-    const status = postScriptError ? "error" : testResults.length > 0 ? allPassed ? "passed" : "failed" : "passed";
+    const httpFailed = fetchResp.status >= 400;
+    const hasTests = testResults.length > 0;
+    const status = postScriptError ? "error" : httpFailed ? "failed" : hasTests ? allPassed ? "passed" : "failed" : "skipped";
+    if (httpFailed && !testResults.some((t) => !t.passed)) {
+      testResults = [
+        ...testResults,
+        {
+          name: `HTTP status ${fetchResp.status} ${fetchResp.statusText}`.trim(),
+          passed: false,
+          error: `Request returned ${fetchResp.status} — no assertion was defined to verify the status code.`
+        }
+      ];
+    }
     const sentHeaders = {};
     headers.forEach((v, k) => {
       sentHeaders[k] = v;
@@ -2398,7 +2521,7 @@ function registerRunnerHandler(ipc) {
     const liveGlobals = requestHandler.getGlobals();
     const globals = { ...payloadGlobals, ...liveGlobals };
     const dispatcher = await buildDispatcher(proxy, tls);
-    const summary = { total: items.length, passed: 0, failed: 0, errors: 0, durationMs: 0 };
+    const summary = { total: items.length, passed: 0, failed: 0, errors: 0, skipped: 0, durationMs: 0 };
     const totalStart = Date.now();
     let runEnvVars = { ...envVars };
     let runCollectionVars = {};
@@ -2441,6 +2564,7 @@ function registerRunnerHandler(ipc) {
           isHook: item.isHook,
           hookType: item.hookType,
           scopeId: item.scopeId,
+          scopePath: item.scopePath,
           iterationLabel: item.iterationLabel
         };
         summary.failed++;
@@ -2452,7 +2576,8 @@ function registerRunnerHandler(ipc) {
         iterationLabel: item.iterationLabel,
         isHook: item.isHook,
         hookType: item.hookType,
-        scopeId: item.scopeId
+        scopeId: item.scopeId,
+        scopePath: item.scopePath
       };
       event.sender.send("runner:progress", { requestId: item.request.id, ...runningUpdate });
       const { result, updatedEnvVars, updatedCollectionVars, updatedGlobals, updatedLocalVars } = await executeOne(
@@ -2468,7 +2593,8 @@ function registerRunnerHandler(ipc) {
       runCollectionVars = updatedCollectionVars;
       runGlobals = updatedGlobals;
       runLocalVars = updatedLocalVars;
-      if (isHook && result.status !== "passed") {
+      const hookFailed = result.status === "failed" || result.status === "error";
+      if (isHook && hookFailed) {
         if (hookType === "beforeAll" && scopeId) {
           failedScopes.add(scopeId);
         } else if (hookType === "before" && mainRequestId) {
@@ -2477,13 +2603,15 @@ function registerRunnerHandler(ipc) {
       }
       if (result.status === "passed") summary.passed++;
       else if (result.status === "failed") summary.failed++;
+      else if (result.status === "skipped") summary.skipped++;
       else summary.errors++;
       event.sender.send("runner:progress", {
         ...result,
         iterationLabel: item.iterationLabel,
         isHook: item.isHook,
         hookType: item.hookType,
-        scopeId: item.scopeId
+        scopeId: item.scopeId,
+        scopePath: item.scopePath
       });
       if (requestDelay > 0 && item !== items[items.length - 1]) {
         await sleep(requestDelay);
@@ -3115,7 +3243,7 @@ async function executeContract(req, vars) {
 async function runConsumerContracts(requests, envVars, collectionVars = {}) {
   const vars = { ...envVars, ...collectionVars };
   const contractRequests = requests.filter(
-    (r) => r.contract && (r.contract.statusCode !== void 0 || r.contract.bodySchema || r.contract.headers?.length)
+    (r) => !r.disabled && r.contract && (r.contract.statusCode !== void 0 || r.contract.bodySchema || r.contract.headers?.length)
   );
   const start = Date.now();
   const results = await Promise.all(contractRequests.map((r) => executeContract(r, vars)));
@@ -3268,7 +3396,8 @@ function validateRequestAgainstSpec(spec, req, envVars, requestBaseUrl) {
 async function runProviderVerification(requests, envVars, specUrl, specPath, requestBaseUrl) {
   const spec = await loadSpec(specUrl, specPath);
   const start = Date.now();
-  const results = requests.map((req) => {
+  const activeRequests = requests.filter((r) => !r.disabled);
+  const results = activeRequests.map((req) => {
     const violations = validateRequestAgainstSpec(spec, req, envVars, requestBaseUrl);
     const url = req.url.replace(/\{\{([^}]+)\}\}/g, (_, k) => envVars[k] ?? `{{${k}}}`);
     return {
@@ -3399,7 +3528,7 @@ async function runBidirectional(requests, envVars, collectionVars = {}, specUrl,
   const vars = { ...envVars, ...collectionVars };
   const start = Date.now();
   const contractRequests = requests.filter(
-    (r) => r.contract && (r.contract.statusCode !== void 0 || r.contract.bodySchema || r.contract.headers?.length)
+    (r) => !r.disabled && r.contract && (r.contract.statusCode !== void 0 || r.contract.bodySchema || r.contract.headers?.length)
   );
   const results = await Promise.all(contractRequests.map(async (req) => {
     const url = requestHandler.buildUrl(req.url, req.params, vars);