@testsmith/api-spector 0.4.8 → 0.5.0

package/out/main/index.js

@@ -22,12 +22,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 const electron = require("electron");
-const handle = require("./chunks/handle-rimXXdJH.js");
+const handle = require("./chunks/handle-b6bp3fb0.js");
 const path = require("path");
-const fs = require("fs");
+const fs$1 = require("fs");
 const promises = require("fs/promises");
 const crypto = require("crypto");
-const requestExec = require("./chunks/request-exec-BH-M3KqZ.js");
+const requestExec = require("./chunks/request-exec-D_xyyt3_.js");
 const ipcValidate = require("./chunks/ipc-validate-k6KI8adf.js");
 const uuid = require("uuid");
 const jsYaml = require("js-yaml");
@@ -37,12 +37,19 @@ const requestCollection = require("./chunks/request-collection-CJoXpvOw.js");
 const mockServer = require("./chunks/mock-server-BxiXhP1m.js");
 const http = require("http");
 const WebSocket = require("ws");
-const soapHandler = require("./chunks/soap-handler-BXx842MN.js");
-const os = require("os");
-const snapshots = require("./chunks/snapshots-CtYxkSLz.js");
+const fs = require("node:fs");
+const os = require("node:os");
+const path$1 = require("node:path");
+const grpc = require("@grpc/grpc-js");
+const protoLoader = require("@grpc/proto-loader");
+const soapHandler = require("./chunks/soap-handler-BYkE6MyE.js");
+const promises$1 = require("node:fs/promises");
+const os$1 = require("os");
+const snapshots = require("./chunks/snapshots-BJiZNuRN.js");
 const simpleGit = require("simple-git");
 const recorder = require("./chunks/recorder-0Ij921El.js");
 require("tls");
+require("node:crypto");
 require("dayjs");
 require("vm");
 require("tv4");
@@ -50,6 +57,27 @@ require("jsonpath-plus");
 require("@xmldom/xmldom");
 require("ajv");
 require("https");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
+const os__namespace = /* @__PURE__ */ _interopNamespaceDefault(os);
+const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path$1);
+const grpc__namespace = /* @__PURE__ */ _interopNamespaceDefault(grpc);
+const protoLoader__namespace = /* @__PURE__ */ _interopNamespaceDefault(protoLoader);
 const LAST_WS_FILE = path.join(electron.app.getPath("userData"), "last-workspace.json");
 const RECENTS_FILE = path.join(electron.app.getPath("userData"), "recent-workspaces.json");
 const MAX_RECENTS = 10;
@@ -175,29 +203,29 @@ function readmeContents(workspaceFileName) {
   ].join("\n");
 }
 async function ensureReadme(workspaceDir2, workspaceFileName) {
-  const path$1 = path.join(workspaceDir2, "README.md");
+  const path$12 = path.join(workspaceDir2, "README.md");
   try {
-    await promises.readFile(path$1, "utf8");
+    await promises.readFile(path$12, "utf8");
     return;
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.warn("file-handler: could not check README.md", err);
       return;
     }
-    await atomicWrite(path$1, readmeContents(workspaceFileName));
+    await atomicWrite(path$12, readmeContents(workspaceFileName));
   }
 }
 async function ensureGitignore(workspaceDir2) {
-  const path$1 = path.join(workspaceDir2, ".gitignore");
+  const path$12 = path.join(workspaceDir2, ".gitignore");
   try {
-    await promises.readFile(path$1, "utf8");
+    await promises.readFile(path$12, "utf8");
     return;
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.warn("file-handler: could not check .gitignore", err);
       return;
     }
-    await atomicWrite(path$1, SPECTOR_GITIGNORE);
+    await atomicWrite(path$12, SPECTOR_GITIGNORE);
   }
 }
 async function ensureVscodeFileAssociation(workspaceDir2) {
@@ -266,6 +294,7 @@ Create a workspace in this folder and add "${path.basename(wsPath)}" to it? The
     workspaceFile = wsPath;
     await requestExec.loadGlobals(workspaceDir);
     await saveLastWorkspacePath(wsPath);
+    requestExec.setSecretsConfig(parsed.settings?.secrets);
     return { workspace: parsed, workspacePath: wsPath };
   });
   handle.handleIpc(ipc, handle.IPC.file.newWorkspace, async () => {
@@ -297,6 +326,7 @@ Create a workspace in this folder and add "${path.basename(wsPath)}" to it? The
   });
   handle.handleIpc(ipc, handle.IPC.file.saveWorkspace, async (_e, ws) => {
     if (!workspaceFile) return;
+    requestExec.setSecretsConfig(ws.settings?.secrets);
     await atomicWrite(workspaceFile, JSON.stringify(ws, null, 2));
     if (workspaceDir) await ensureVscodeFileAssociation(workspaceDir);
   });
@@ -397,6 +427,7 @@ Create a workspace in this folder and add "${path.basename(wsPath)}" to it? The
       workspaceDir = path.dirname(wsPath);
       workspaceFile = wsPath;
       await requestExec.loadGlobals(workspaceDir);
+      requestExec.setSecretsConfig(workspace.settings?.secrets);
       return { workspace, workspacePath: wsPath };
     } catch {
       return null;
@@ -427,6 +458,7 @@ Create a workspace in this folder and add "${path.basename(wsPath)}" to it? The
     workspaceFile = wsPath;
     await requestExec.loadGlobals(workspaceDir);
     await saveLastWorkspacePath(wsPath);
+    requestExec.setSecretsConfig(parsed.settings?.secrets);
     return { workspace: parsed, workspacePath: wsPath };
   });
 }
@@ -446,6 +478,7 @@ async function tryOpenWorkspaceInDir(dir) {
     workspaceDir = dir;
     workspaceFile = wsPath;
     await requestExec.loadGlobals(workspaceDir);
+    requestExec.setSecretsConfig(workspace.settings?.secrets);
     return { workspace, workspacePath: wsPath };
   } catch {
     return null;
@@ -4637,6 +4670,79 @@ function registerOAuth2Handlers(ipc) {
     };
   });
 }
+const CALLBACK_PORT = 8250;
+const CALLBACK_PATH = "/oidc/callback";
+function registerVaultHandlers(ipc) {
+  handle.handleIpc(ipc, handle.IPC.vault.oidcLogin, async (_e, opts) => {
+    const address = (opts.address ?? "").replace(/\/+$/, "");
+    if (!address) throw new Error("Vault OIDC: address is required.");
+    const mount = opts.mount?.trim() || "oidc";
+    const redirectUri = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
+    const clientNonce = Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2);
+    const { fetch: nodeFetch, Agent } = await import("undici");
+    const dispatcher = opts.skipVerify ? new Agent({ connect: { rejectUnauthorized: false } }) : void 0;
+    const nsHeaders = opts.namespace ? { "X-Vault-Namespace": opts.namespace } : {};
+    const vault = async (path2, init = {}) => {
+      const res = await nodeFetch(`${address}/v1/${path2}`, {
+        ...init,
+        headers: { ...nsHeaders, ...init.headers },
+        ...dispatcher ? { dispatcher } : {}
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(`Vault ${res.status} on /v1/${path2}: ${body.slice(0, 300)}`);
+      }
+      return res.json();
+    };
+    const authUrlResp = await vault(`auth/${mount}/oidc/auth_url`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ redirect_uri: redirectUri, role: opts.role || void 0, client_nonce: clientNonce })
+    });
+    const authUrl = authUrlResp?.data?.auth_url;
+    if (!authUrl) throw new Error("Vault OIDC: no auth_url returned (check the mount, role, and allowed redirect URIs).");
+    const params = await new Promise((resolve2, reject) => {
+      const server = http.createServer((req, res) => {
+        const reqUrl = new URL(req.url ?? "/", `http://localhost:${CALLBACK_PORT}`);
+        if (!reqUrl.pathname.startsWith(CALLBACK_PATH)) {
+          res.writeHead(404);
+          res.end();
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end("<html><body><p>Vault sign-in complete. You may close this tab.</p></body></html>");
+        server.close();
+        const error = reqUrl.searchParams.get("error");
+        if (error) {
+          reject(new Error(`Vault OIDC error: ${error}`));
+          return;
+        }
+        resolve2(reqUrl.searchParams);
+      });
+      server.on("error", reject);
+      server.listen(CALLBACK_PORT, "127.0.0.1", () => {
+        electron.shell.openExternal(authUrl).catch(reject);
+      });
+      setTimeout(() => {
+        server.close();
+        reject(new Error("Vault OIDC sign-in timed out (5 min)."));
+      }, 5 * 60 * 1e3);
+    });
+    const code = params.get("code");
+    const state = params.get("state");
+    if (!code || !state) throw new Error("Vault OIDC: callback missing code/state.");
+    const cb = new URLSearchParams({ state, code, client_nonce: clientNonce });
+    const login = await vault(`auth/${mount}/oidc/callback?${cb.toString()}`);
+    const token = login?.auth?.client_token;
+    if (!token) throw new Error("Vault OIDC: callback did not return a client token.");
+    process.env.VAULT_TOKEN = token;
+    return {
+      ok: true,
+      expiresInSeconds: Number(login?.auth?.lease_duration ?? 0),
+      entityId: login?.auth?.entity_id ? String(login.auth.entity_id) : void 0
+    };
+  });
+}
 const connections = /* @__PURE__ */ new Map();
 function closeAllWsConnections() {
   for (const [, ws] of connections) {
@@ -4693,6 +4799,152 @@ function registerWsHandlers(ipc) {
     }
   });
 }
+const calls = /* @__PURE__ */ new Map();
+function closeAllGrpcConnections() {
+  for (const [, c] of calls) {
+    try {
+      c.cancel();
+    } catch {
+    }
+  }
+  calls.clear();
+}
+const LOADER_OPTS = {
+  keepCase: true,
+  longs: String,
+  enums: String,
+  defaults: true,
+  oneofs: true
+};
+function resolveProtoFile(src) {
+  const importPaths = (src.importPaths ?? []).filter(Boolean);
+  if (src.protoPath) {
+    return { file: src.protoPath, includeDirs: [path__namespace.dirname(src.protoPath), ...importPaths] };
+  }
+  if (src.protoSource && src.protoSource.trim()) {
+    const dir = fs__namespace.mkdtempSync(path__namespace.join(os__namespace.tmpdir(), "apispector-proto-"));
+    const file = path__namespace.join(dir, "main.proto");
+    fs__namespace.writeFileSync(file, src.protoSource, "utf8");
+    return { file, includeDirs: [dir, ...importPaths] };
+  }
+  throw new Error("No proto source: paste a .proto or provide a file path.");
+}
+function loadPackage(src) {
+  const { file, includeDirs } = resolveProtoFile(src);
+  return protoLoader__namespace.loadSync(file, { ...LOADER_OPTS, includeDirs });
+}
+function enumerateServices(pkgDef) {
+  const services = [];
+  for (const [name, def] of Object.entries(pkgDef)) {
+    const methods = Object.entries(def).filter(([, m]) => m && typeof m === "object" && "requestStream" in m).map(([mName, m]) => {
+      const md = m;
+      return { name: mName, requestStream: !!md.requestStream, responseStream: !!md.responseStream };
+    });
+    if (methods.length) services.push({ name, methods });
+  }
+  return services;
+}
+function resolveService(grpcObj, serviceName) {
+  let node = grpcObj;
+  for (const part of serviceName.split(".")) {
+    node = node?.[part];
+    if (!node) throw new Error(`Service "${serviceName}" not found in the proto.`);
+  }
+  if (typeof node !== "function") throw new Error(`"${serviceName}" is not a service.`);
+  return node;
+}
+function normalizeTarget(url) {
+  return url.replace(/^[a-z0-9+.-]+:\/\//i, "").replace(/\/+$/, "");
+}
+function registerGrpcHandlers(ipc) {
+  handle.handleIpc(ipc, handle.IPC.grpc.loadProto, async (_e, src) => {
+    return { services: enumerateServices(loadPackage(src)) };
+  });
+  handle.handleIpc(ipc, handle.IPC.grpc.invoke, async (event, requestId, opts) => {
+    calls.get(requestId)?.cancel();
+    calls.delete(requestId);
+    const sendStatus = (status, extra = {}) => event.sender.send(handle.IPC.grpc.status, { requestId, status, ...extra });
+    const sendMessage = (data) => {
+      const message = {
+        id: uuid.v4(),
+        direction: "received",
+        data: typeof data === "string" ? data : JSON.stringify(data, null, 2),
+        timestamp: Date.now()
+      };
+      event.sender.send(handle.IPC.grpc.message, { requestId, message });
+    };
+    let pkgDef;
+    let ServiceCtor;
+    let request;
+    try {
+      pkgDef = loadPackage(opts);
+      const grpcObj = grpc__namespace.loadPackageDefinition(pkgDef);
+      ServiceCtor = resolveService(grpcObj, opts.serviceName);
+      request = opts.message.trim() ? JSON.parse(opts.message) : {};
+    } catch (err) {
+      sendStatus("error", { error: err instanceof Error ? err.message : String(err) });
+      return;
+    }
+    const serviceDef = ServiceCtor.service;
+    const methodKey = Object.keys(serviceDef).find((k) => k === opts.methodName) ?? Object.keys(serviceDef).find((k) => k.toLowerCase() === opts.methodName.toLowerCase());
+    if (!methodKey) {
+      sendStatus("error", { error: `Method "${opts.methodName}" not found on ${opts.serviceName}.` });
+      return;
+    }
+    const def = serviceDef[methodKey];
+    if (def.requestStream) {
+      sendStatus("error", { error: "Client-streaming methods are not supported yet." });
+      return;
+    }
+    const creds = opts.plaintext ? grpc__namespace.credentials.createInsecure() : grpc__namespace.credentials.createSsl();
+    const client = new ServiceCtor(normalizeTarget(opts.target), creds);
+    const metadata = new grpc__namespace.Metadata();
+    for (const [k, v] of Object.entries(opts.metadata ?? {})) metadata.set(k, v);
+    const statusName = (code) => Object.keys(grpc__namespace.status).find((k) => grpc__namespace.status[k] === code) ?? String(code);
+    const cleanup = () => {
+      calls.delete(requestId);
+      try {
+        client.close();
+      } catch {
+      }
+    };
+    sendStatus("running");
+    try {
+      const method = client[methodKey].bind(client);
+      if (def.responseStream) {
+        const call = method(request, metadata);
+        calls.set(requestId, { cancel: () => call.cancel() });
+        call.on("data", (d) => sendMessage(d));
+        call.on("error", (e) => {
+          sendStatus("error", { code: e.code, codeName: e.code !== void 0 ? statusName(e.code) : void 0, error: e.details || e.message });
+          cleanup();
+        });
+        call.on("status", (s) => {
+          if (s.code === grpc__namespace.status.OK) sendStatus("completed", { code: s.code, codeName: statusName(s.code) });
+          cleanup();
+        });
+      } else {
+        const call = method(request, metadata, (err, response) => {
+          if (err) {
+            sendStatus("error", { code: err.code, codeName: err.code !== void 0 ? statusName(err.code) : void 0, error: err.details || err.message });
+          } else {
+            sendMessage(response);
+            sendStatus("completed", { code: grpc__namespace.status.OK, codeName: "OK" });
+          }
+          cleanup();
+        });
+        calls.set(requestId, { cancel: () => call.cancel() });
+      }
+    } catch (err) {
+      sendStatus("error", { error: err instanceof Error ? err.message : String(err) });
+      cleanup();
+    }
+  });
+  handle.handleIpc(ipc, handle.IPC.grpc.cancel, async (_e, requestId) => {
+    calls.get(requestId)?.cancel();
+    calls.delete(requestId);
+  });
+}
 function isJsonContentType(ct) {
   return !!ct && /\bjson\b/i.test(ct);
 }
@@ -4983,6 +5235,26 @@ function registerDocsHandlers(ipc) {
     return generateMarkdown(payload);
   });
 }
+function registerCoverageHandlers(ipc) {
+  handle.handleIpc(ipc, handle.IPC.coverage.loadSpec, async (_e, source) => {
+    if (source.text && source.text.trim()) {
+      const t = source.text.trim();
+      return t.startsWith("{") ? JSON.parse(t) : jsYaml.load(t);
+    }
+    if (source.url) {
+      const resp = await undici.fetch(source.url);
+      if (!resp.ok) throw new Error(`HTTP ${resp.status} fetching ${source.url}`);
+      const raw = await resp.text();
+      const ct = resp.headers.get("content-type") ?? "";
+      return ct.includes("yaml") || /\.ya?ml$/i.test(source.url) ? jsYaml.load(raw) : JSON.parse(raw);
+    }
+    if (source.path) {
+      const raw = await promises$1.readFile(source.path, "utf8");
+      return /\.ya?ml$/i.test(source.path) ? jsYaml.load(raw) : JSON.parse(raw);
+    }
+    throw new Error("No spec source: provide a file path, URL, or pasted text.");
+  });
+}
 function inferSchema(data) {
   if (data === null || data === void 0) return { type: "null" };
   if (typeof data === "boolean") return { type: "boolean" };
@@ -5019,7 +5291,7 @@ async function resolveSnapshotSpec(relPath) {
   const dir = getWorkspaceDir();
   if (!dir) throw new Error("No workspace open - cannot resolve snapshot.");
   const snap = await snapshots.loadSnapshot(dir, relPath);
-  const tmp = path.join(os.tmpdir(), `api-spector-${crypto.randomUUID()}.${snap.format === "yaml" ? "yaml" : "json"}`);
+  const tmp = path.join(os$1.tmpdir(), `api-spector-${crypto.randomUUID()}.${snap.format === "yaml" ? "yaml" : "json"}`);
   await promises.writeFile(tmp, snap.spec, "utf8");
   return { specPath: tmp };
 }
@@ -5051,7 +5323,7 @@ function registerContractHandlers(ipc) {
     }
     switch (mode) {
       case "consumer":
-        return snapshots.runConsumerContracts(requests, envVars, collectionVars);
+        return snapshots.runConsumerContracts(requests, envVars, collectionVars, providerBaseUrl);
       case "provider":
         return snapshots.runProviderVerification(requests, envVars, collectionVars, specUrl, specPath, requestBaseUrl);
       case "provider-live":
@@ -5520,7 +5792,7 @@ function isNewer(a, b) {
   return a2 > b2;
 }
 async function checkForUpdate() {
-  const current = "0.4.8";
+  const current = "0.5.0";
   try {
     const res = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(4e3) });
     if (!res.ok) return null;
@@ -5565,15 +5837,15 @@ function loadAppIcon() {
     path.join(__dirname, "../../build/icon.png")
   ];
   for (const p of pngCandidates) {
-    if (fs.existsSync(p)) return electron.nativeImage.createFromPath(p);
+    if (fs$1.existsSync(p)) return electron.nativeImage.createFromPath(p);
   }
   const svgCandidates = [
     path.join(electron.app.getAppPath(), "resources/icon.svg"),
     path.join(__dirname, "../../resources/icon.svg")
   ];
   for (const p of svgCandidates) {
-    if (fs.existsSync(p)) {
-      const dataUrl = "data:image/svg+xml;base64," + fs.readFileSync(p).toString("base64");
+    if (fs$1.existsSync(p)) {
+      const dataUrl = "data:image/svg+xml;base64," + fs$1.readFileSync(p).toString("base64");
       return electron.nativeImage.createFromDataURL(dataUrl);
     }
   }
@@ -5634,9 +5906,12 @@ electron.app.whenReady().then(async () => {
   registerRunnerHandler(electron.ipcMain);
   registerMockHandlers(electron.ipcMain);
   registerOAuth2Handlers(electron.ipcMain);
+  registerVaultHandlers(electron.ipcMain);
   registerWsHandlers(electron.ipcMain);
+  registerGrpcHandlers(electron.ipcMain);
   soapHandler.registerSoapHandlers(electron.ipcMain);
   registerDocsHandlers(electron.ipcMain);
+  registerCoverageHandlers(electron.ipcMain);
   registerContractHandlers(electron.ipcMain);
   registerGitHandlers(electron.ipcMain);
   registerRecordHandlers(electron.ipcMain, () => electron.BrowserWindow.getAllWindows()[0]?.webContents ?? null);
@@ -5653,5 +5928,6 @@ electron.app.on("window-all-closed", () => {
 });
 electron.app.on("before-quit", async () => {
   closeAllWsConnections();
+  closeAllGrpcConnections();
   await mockServer.stopAll();
 });

package/out/main/lib.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const mockServer = require("./chunks/mock-server-BxiXhP1m.js");
-const requestExec = require("./chunks/request-exec-BH-M3KqZ.js");
+const requestExec = require("./chunks/request-exec-D_xyyt3_.js");
 require("http");
 require("crypto");
 require("vm");
@@ -10,7 +10,11 @@ require("@xmldom/xmldom");
 require("undici");
 require("fs/promises");
 require("tls");
-require("./chunks/handle-rimXXdJH.js");
+require("./chunks/handle-b6bp3fb0.js");
+require("node:fs");
+require("node:os");
+require("node:path");
+require("node:crypto");
 require("path");
 require("tv4");
 require("jsonpath-plus");
@@ -31,7 +35,12 @@ exports.buildProtocolFaultTests = requestExec.buildProtocolFaultTests;
 exports.buildSchemaTestResults = requestExec.buildSchemaTestResults;
 exports.deriveRunStatus = requestExec.deriveRunStatus;
 exports.executeRunnerRequest = requestExec.executeRunnerRequest;
+exports.hasSecretScheme = requestExec.hasSecretScheme;
 exports.maskHeaders = requestExec.maskHeaders;
 exports.maskPii = requestExec.maskPii;
 exports.performHttpExchange = requestExec.performHttpExchange;
+exports.registerSecretProvider = requestExec.registerSecretProvider;
+exports.registeredSchemes = requestExec.registeredSchemes;
+exports.resolveExternalSecret = requestExec.resolveExternalSecret;
+exports.setSecretsConfig = requestExec.setSecretsConfig;
 exports.syntheticHttpFailure = requestExec.syntheticHttpFailure;

package/out/main/runner.js

@@ -2,13 +2,17 @@
 "use strict";
 const promises = require("fs/promises");
 const path = require("path");
-const requestExec = require("./chunks/request-exec-BH-M3KqZ.js");
+const requestExec = require("./chunks/request-exec-D_xyyt3_.js");
 const requestCollection = require("./chunks/request-collection-CJoXpvOw.js");
 const environments = require("./chunks/environments-iM3SUM-4.js");
 const cliCommon = require("./chunks/cli-common-BKYgsbGB.js");
 require("undici");
 require("tls");
-require("./chunks/handle-rimXXdJH.js");
+require("./chunks/handle-b6bp3fb0.js");
+require("node:fs");
+require("node:os");
+require("node:path");
+require("node:crypto");
 require("crypto");
 require("dayjs");
 require("vm");
@@ -387,6 +391,7 @@ async function main() {
     process.exit(1);
   }
   await requestExec.loadGlobals(wsDir);
+  requestExec.setSecretsConfig(workspace.settings?.secrets);
   const collections = await cliCommon.loadCollections(workspace, wsDir, {
     onError: (relPath) => console.error(cliCommon.color(`  [warn] Could not load collection: ${relPath}`, cliCommon.C.yellow))
   });
@@ -397,7 +402,7 @@ 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.4.8"}`;
+  const version = `v${"0.5.0"}`;
   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));
@@ -405,7 +410,7 @@ async function main() {
   if (filterTags.length) console.log(cliCommon.color(`  Tags:        ${filterTags.join(", ")}`, cliCommon.C.gray));
   console.log("");
   const envVarsSnapshot = await requestExec.buildEnvVars(env);
-  const secretValuesToMask = (env?.variables ?? []).filter((v) => v.secret && v.enabled).map((v) => envVarsSnapshot[v.key]).filter((v) => typeof v === "string" && v.length > 0);
+  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) {
     let out = s;
     for (const secret of secretValuesToMask) out = out.split(secret).join("***");

package/out/main/wsdl.js

@@ -4,10 +4,10 @@ const promises = require("fs/promises");
 const path = require("path");
 const https = require("https");
 const http = require("http");
-const soapHandler = require("./chunks/soap-handler-BXx842MN.js");
-const _import = require("./chunks/import-DcenB5Q_.js");
+const soapHandler = require("./chunks/soap-handler-BYkE6MyE.js");
+const _import = require("./chunks/import-BeY7gjWL.js");
 const cliCommon = require("./chunks/cli-common-BKYgsbGB.js");
-require("./chunks/handle-rimXXdJH.js");
+require("./chunks/handle-b6bp3fb0.js");
 require("@xmldom/xmldom");
 require("uuid");
 require("crypto");

package/out/preload/index.js

@@ -76,6 +76,10 @@ const IPC = {
     startFlow: "oauth2:startFlow",
     refreshToken: "oauth2:refreshToken"
   },
+  // ─── HashiCorp Vault (interactive OIDC login) ──────────────────────────────
+  vault: {
+    oidcLogin: "vault:oidcLogin"
+  },
   // ─── Mock servers ──────────────────────────────────────────────────────────
   mock: {
     start: "mock:start",
@@ -101,10 +105,28 @@ const IPC = {
     fetch: "wsdl:fetch",
     import: "wsdl:import"
   },
+  // ─── gRPC ──────────────────────────────────────────────────────────────────
+  grpc: {
+    /** Load a .proto (source or path) and enumerate its services/methods. */
+    loadProto: "grpc:loadProto",
+    /** Invoke a method (unary or server-streaming). Streams back messages. */
+    invoke: "grpc:invoke",
+    /** Cancel an in-flight call. */
+    cancel: "grpc:cancel",
+    /** Event: a received message frame. */
+    message: "grpc:message",
+    /** Event: call status change (running / completed / error, with code). */
+    status: "grpc:status"
+  },
   // ─── Docs generation ───────────────────────────────────────────────────────
   docs: {
     generate: "docs:generate"
   },
+  // ─── OpenAPI coverage ────────────────────────────────────────────────────────
+  coverage: {
+    /** Read + parse an OpenAPI spec (file path, URL, or raw text). */
+    loadSpec: "coverage:loadSpec"
+  },
   // ─── Contract testing ──────────────────────────────────────────────────────
   contract: {
     run: "contract:run",
@@ -242,6 +264,8 @@ const api = {
   pickOutputDir: () => electron.ipcRenderer.invoke(IPC.dialog.pickDir),
   saveGeneratedFiles: (files, outputDir) => electron.ipcRenderer.invoke(IPC.generate.save, files, outputDir),
   saveGeneratedFilesAsZip: (files, collectionName, target) => electron.ipcRenderer.invoke(IPC.generate.saveZip, files, collectionName, target),
+  // ─── HashiCorp Vault (interactive OIDC login) ─────────────────────────────
+  vaultOidcLogin: (opts) => electron.ipcRenderer.invoke(IPC.vault.oidcLogin, opts),
   // ─── OAuth 2.0 ────────────────────────────────────────────────────────────
   oauth2StartFlow: (auth, vars) => electron.ipcRenderer.invoke(IPC.oauth2.startFlow, auth, vars),
   oauth2RefreshToken: (auth, vars, refreshToken) => electron.ipcRenderer.invoke(IPC.oauth2.refreshToken, auth, vars, refreshToken),
@@ -282,6 +306,20 @@ const api = {
     electron.ipcRenderer.removeAllListeners(IPC.ws.message);
     electron.ipcRenderer.removeAllListeners(IPC.ws.status);
   },
+  // ─── gRPC ─────────────────────────────────────────────────────────────────
+  grpcLoadProto: (src) => electron.ipcRenderer.invoke(IPC.grpc.loadProto, src),
+  grpcInvoke: (requestId, opts) => electron.ipcRenderer.invoke(IPC.grpc.invoke, requestId, opts),
+  grpcCancel: (requestId) => electron.ipcRenderer.invoke(IPC.grpc.cancel, requestId),
+  onGrpcMessage: (cb) => {
+    electron.ipcRenderer.on(IPC.grpc.message, (_e, payload) => cb(payload));
+  },
+  onGrpcStatus: (cb) => {
+    electron.ipcRenderer.on(IPC.grpc.status, (_e, payload) => cb(payload));
+  },
+  offGrpcEvents: () => {
+    electron.ipcRenderer.removeAllListeners(IPC.grpc.message);
+    electron.ipcRenderer.removeAllListeners(IPC.grpc.status);
+  },
   // ─── Streamed responses (SSE / NDJSON / chunked) ──────────────────────────
   onRequestStreamEvent: (cb) => {
     electron.ipcRenderer.on(IPC.request.streamEvent, (_e, payload) => cb(payload));
@@ -298,6 +336,8 @@ const api = {
   wsdlImport: (opts) => electron.ipcRenderer.invoke(IPC.wsdl.import, opts),
   // ─── Docs generation ──────────────────────────────────────────────────────
   generateDocs: (payload) => electron.ipcRenderer.invoke(IPC.docs.generate, payload),
+  // ─── OpenAPI coverage ─────────────────────────────────────────────────────
+  coverageLoadSpec: (source) => electron.ipcRenderer.invoke(IPC.coverage.loadSpec, source),
   // ─── Contract testing ─────────────────────────────────────────────────────
   runContracts: (payload) => electron.ipcRenderer.invoke(IPC.contract.run, payload),
   inferContractSchema: (jsonBody) => electron.ipcRenderer.invoke(IPC.contract.inferSchema, jsonBody),