@testsmith/api-spector 0.0.1

package/out/main/mock.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+"use strict";
+const promises = require("fs/promises");
+const path = require("path");
+const mockServer = require("./chunks/mock-server-ZB7zpXh9.js");
+require("http");
+require("crypto");
+const C = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m",
+  white: "\x1B[97m"
+};
+function color(str, ...codes) {
+  return process.stdout.isTTY ? codes.join("") + str + C.reset : str;
+}
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) continue;
+    const key = arg.slice(2);
+    const next = argv[i + 1];
+    if (!next || next.startsWith("--")) {
+      args[key] = true;
+    } else {
+      if (key === "name") {
+        const prev = args[key];
+        args[key] = Array.isArray(prev) ? [...prev, next] : [next];
+      } else {
+        args[key] = next;
+      }
+      i++;
+    }
+  }
+  return args;
+}
+async function loadWorkspace(wsPath) {
+  const raw = await promises.readFile(wsPath, "utf8");
+  return { workspace: JSON.parse(raw), dir: path.dirname(path.resolve(wsPath)) };
+}
+async function loadMocks(workspace, dir) {
+  const mocks = [];
+  for (const relPath of workspace.mocks ?? []) {
+    try {
+      const raw = await promises.readFile(path.join(dir, relPath), "utf8");
+      mocks.push(JSON.parse(raw));
+    } catch {
+      console.warn(color(`  [warn] Could not load mock: ${relPath}`, C.yellow));
+    }
+  }
+  return mocks;
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    console.log(
+      "\nUsage:\n  api-spector mock --workspace <path> [--name <server-name>]\n\nOptions:\n  --workspace <path>   Path to workspace.json (required)\n  --name <name>        Start only the named server (repeat for multiple)\n  --help               Show this message\n"
+    );
+    process.exit(0);
+  }
+  const wsPath = args.workspace;
+  if (!wsPath) {
+    console.error(color("Error: --workspace is required", C.red));
+    process.exit(1);
+  }
+  let workspace, wsDir;
+  try {
+    ;
+    ({ workspace, dir: wsDir } = await loadWorkspace(wsPath));
+  } catch {
+    console.error(color(`Error: could not read workspace: ${wsPath}`, C.red));
+    process.exit(1);
+  }
+  const allMocks = await loadMocks(workspace, wsDir);
+  if (allMocks.length === 0) {
+    console.error(color("  No mock servers defined in this workspace.", C.yellow));
+    process.exit(0);
+  }
+  const nameFilter = args.name ? (Array.isArray(args.name) ? args.name : [args.name]).map((n) => n.toLowerCase()) : null;
+  const toStart = nameFilter ? allMocks.filter((m) => nameFilter.includes(m.name.toLowerCase())) : allMocks;
+  if (toStart.length === 0) {
+    console.error(color(`  No mock servers matched the given --name filter.`, C.yellow));
+    console.log(color(`  Available: ${allMocks.map((m) => `"${m.name}"`).join(", ")}`, C.gray));
+    process.exit(1);
+  }
+  console.log("");
+  console.log(color("  Mock Servers", C.bold, C.white));
+  console.log(color(`  Workspace: ${wsPath}`, C.gray));
+  console.log("");
+  let started = 0;
+  for (const mock of toStart) {
+    try {
+      await mockServer.startMock(mock);
+      console.log(
+        color("  ✓", C.green, C.bold) + `  ${color(mock.name, C.white)}  ` + color(`http://127.0.0.1:${mock.port}`, C.cyan) + color(`  (${mock.routes.length} route${mock.routes.length !== 1 ? "s" : ""})`, C.gray)
+      );
+      for (const route of mock.routes) {
+        const delay = route.delay ? color(`  ${route.delay}ms`, C.gray) : "";
+        console.log(
+          color(`       ${route.method.padEnd(7)} ${route.path}`, C.gray) + color(`  →  ${route.statusCode}`, route.statusCode < 400 ? C.green : C.red) + delay
+        );
+      }
+      started++;
+    } catch (e) {
+      console.error(
+        color("  ✗", C.red, C.bold) + `  ${mock.name}  ` + color(e.message, C.red)
+      );
+    }
+  }
+  if (started === 0) {
+    process.exit(1);
+  }
+  console.log("");
+  console.log(color("  Press Ctrl+C to stop all servers.\n", C.gray));
+  async function shutdown() {
+    console.log(color("\n  Stopping mock servers…", C.gray));
+    await mockServer.stopAll();
+    process.exit(0);
+  }
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  setInterval(() => {
+  }, 1 << 30);
+}
+main().catch((err) => {
+  console.error(color(`Fatal: ${err.message}`, C.red));
+  process.exit(2);
+});

package/out/main/runner.js

@@ -0,0 +1,375 @@
+#!/usr/bin/env node
+"use strict";
+const promises = require("fs/promises");
+const path = require("path");
+const undici = require("undici");
+const scriptRunner = require("./chunks/script-runner-Ci5t2-bo.js");
+require("crypto");
+require("vm");
+require("dayjs");
+require("tv4");
+function buildJsonReport(results, summary, meta = {}) {
+  return JSON.stringify({
+    timestamp: meta.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    workspace: meta.workspace ?? null,
+    environment: meta.environment ?? null,
+    collection: meta.collection ?? null,
+    summary,
+    results: results.map((r) => ({
+      name: r.name,
+      method: r.method,
+      url: r.resolvedUrl,
+      status: r.status,
+      httpStatus: r.httpStatus ?? null,
+      durationMs: r.durationMs ?? null,
+      iterationLabel: r.iterationLabel ?? null,
+      error: r.error ?? null,
+      preScriptError: r.preScriptError ?? null,
+      postScriptError: r.postScriptError ?? null,
+      tests: r.testResults ?? [],
+      consoleOutput: r.consoleOutput ?? [],
+      request: r.sentRequest ?? null,
+      response: r.receivedResponse ?? null
+    }))
+  }, null, 2);
+}
+function buildJUnitReport(results, summary, meta = {}) {
+  const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  const suiteName = esc(meta.collection ?? "API Tests");
+  const totalSec = (summary.durationMs / 1e3).toFixed(3);
+  const ts = meta.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  const cases = results.map((r) => {
+    const label = r.iterationLabel ? ` #${r.iterationLabel}` : "";
+    const name = esc(r.name + label);
+    const classname = esc(`${r.method} ${r.resolvedUrl}`);
+    const timeSec = ((r.durationMs ?? 0) / 1e3).toFixed(3);
+    const failures = [];
+    if (r.status === "error") {
+      failures.push(`      <error message="${esc(r.error ?? "Network error")}" type="NetworkError" />`);
+    } else if (r.preScriptError) {
+      failures.push(`      <error message="${esc(r.preScriptError)}" type="PreScriptError" />`);
+    } else if (r.postScriptError) {
+      failures.push(`      <error message="${esc(r.postScriptError)}" type="PostScriptError" />`);
+    } else if (r.testResults?.length) {
+      for (const t of r.testResults) {
+        if (!t.passed) {
+          failures.push(
+            `      <failure message="${esc(t.name)}" type="AssertionError">${esc(t.error ?? "Assertion failed")}</failure>`
+          );
+        }
+      }
+    }
+    const inner = failures.length ? `
+${failures.join("\n")}
+    ` : "";
+    return `    <testcase name="${name}" classname="${classname}" time="${timeSec}">${inner}</testcase>`;
+  });
+  const lines = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    `<testsuites name="${suiteName}" tests="${summary.total}" failures="${summary.failed}" errors="${summary.errors}" time="${totalSec}">`,
+    `  <testsuite name="${suiteName}" tests="${summary.total}" failures="${summary.failed}" errors="${summary.errors}" time="${totalSec}" timestamp="${ts}">`,
+    ...cases,
+    "  </testsuite>",
+    "</testsuites>"
+  ];
+  return lines.join("\n") + "\n";
+}
+function collectTagged(folder, requests, collectionVars, filterTags) {
+  const results = [];
+  for (const reqId of folder.requestIds) {
+    const req = requests[reqId];
+    if (!req) continue;
+    const tags = req.meta?.tags ?? [];
+    if (filterTags.length > 0 && !filterTags.some((t) => tags.includes(t))) continue;
+    results.push({ request: req, collectionVars });
+  }
+  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));
+  }
+  return results;
+}
+const C = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m",
+  white: "\x1B[97m"
+};
+function color(str, ...codes) {
+  return process.stdout.isTTY ? codes.join("") + str + C.reset : str;
+}
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (!next || next.startsWith("--")) {
+        args[key] = true;
+      } else {
+        args[key] = next;
+        i++;
+      }
+    }
+  }
+  return args;
+}
+async function loadWorkspace(wsPath) {
+  const raw = await promises.readFile(wsPath, "utf8");
+  return { workspace: JSON.parse(raw), dir: path.dirname(path.resolve(wsPath)) };
+}
+async function loadCollections(workspace, dir) {
+  const cols = [];
+  for (const relPath of workspace.collections) {
+    try {
+      const raw = await promises.readFile(path.join(dir, relPath), "utf8");
+      cols.push(JSON.parse(raw));
+    } catch (_e) {
+      console.error(color(`  [warn] Could not load collection: ${relPath}`, C.yellow));
+    }
+  }
+  return cols;
+}
+async function loadEnvironments(workspace, dir) {
+  const envs = [];
+  for (const relPath of workspace.environments) {
+    try {
+      const raw = await promises.readFile(path.join(dir, relPath), "utf8");
+      envs.push(JSON.parse(raw));
+    } catch (_e) {
+    }
+  }
+  return envs;
+}
+async function executeRequest(req, collectionVars, envVars, globals, verbose) {
+  const base = {
+    requestId: req.id,
+    name: req.name,
+    method: req.method,
+    resolvedUrl: req.url,
+    status: "running"
+  };
+  let localVars = {};
+  let updatedEnvVars = { ...envVars };
+  let updatedCollectionVars = { ...collectionVars };
+  let updatedGlobals = { ...globals };
+  let preScriptError;
+  if (req.preRequestScript?.trim()) {
+    const r = await scriptRunner.runScript(req.preRequestScript, {
+      envVars: { ...envVars },
+      collectionVars: { ...collectionVars },
+      globals: { ...globals },
+      localVars: {}
+    });
+    preScriptError = r.error;
+    localVars = r.updatedLocalVars;
+    updatedEnvVars = r.updatedEnvVars;
+    updatedCollectionVars = r.updatedCollectionVars;
+    updatedGlobals = r.updatedGlobals;
+    scriptRunner.patchGlobals(r.updatedGlobals);
+    await scriptRunner.persistGlobals();
+    if (verbose && r.consoleOutput.length) r.consoleOutput.forEach((l) => console.log(color(`    [pre] ${l}`, C.gray)));
+    if (r.error) console.error(color(`    [pre-script error] ${r.error}`, C.red));
+  }
+  const vars = scriptRunner.mergeVars(updatedEnvVars, updatedCollectionVars, updatedGlobals, localVars);
+  const resolvedUrl = scriptRunner.buildUrl(req.url, req.params, vars);
+  base.resolvedUrl = resolvedUrl;
+  const start = Date.now();
+  try {
+    const authH = {};
+    if (req.auth.type === "bearer") {
+      let token = req.auth.token ?? "";
+      if (!token && req.auth.tokenSecretRef) token = await scriptRunner.getSecret(req.auth.tokenSecretRef) ?? "";
+      if (token) authH["Authorization"] = `Bearer ${scriptRunner.interpolate(token, vars)}`;
+    }
+    const headers = new undici.Headers();
+    for (const h of req.headers) {
+      if (h.enabled && h.key) headers.set(scriptRunner.interpolate(h.key, vars), scriptRunner.interpolate(h.value, vars));
+    }
+    for (const [k, v] of Object.entries(authH)) headers.set(k, v);
+    let body;
+    if (req.body.mode === "json" && req.body.json) {
+      body = scriptRunner.interpolate(req.body.json, vars);
+      if (!headers.has("content-type")) headers.set("Content-Type", "application/json");
+    } else if (req.body.mode === "raw" && req.body.raw) {
+      body = scriptRunner.interpolate(req.body.raw, vars);
+      if (!headers.has("content-type")) headers.set("Content-Type", req.body.rawContentType ?? "text/plain");
+    } else if (req.body.mode === "graphql" && req.body.graphql) {
+      const gql = req.body.graphql;
+      const gqlBody = { query: scriptRunner.interpolate(gql.query, vars) };
+      const rawVars = gql.variables?.trim();
+      if (rawVars) {
+        try {
+          gqlBody.variables = JSON.parse(scriptRunner.interpolate(rawVars, vars));
+        } catch {
+        }
+      }
+      if (gql.operationName?.trim()) gqlBody.operationName = gql.operationName.trim();
+      body = JSON.stringify(gqlBody);
+      if (!headers.has("content-type")) headers.set("Content-Type", "application/json");
+    }
+    const fetchResp = await undici.fetch(resolvedUrl, {
+      method: req.method,
+      headers,
+      body: ["GET", "HEAD"].includes(req.method) ? void 0 : body
+    });
+    const responseBody = await fetchResp.text();
+    const durationMs = Date.now() - start;
+    const respHeaders = {};
+    fetchResp.headers.forEach((v, k) => {
+      respHeaders[k] = v;
+    });
+    const response = {
+      status: fetchResp.status,
+      statusText: fetchResp.statusText,
+      headers: respHeaders,
+      body: responseBody,
+      bodySize: Buffer.byteLength(responseBody, "utf8"),
+      durationMs
+    };
+    let testResults = [];
+    let consoleOutput = [];
+    let postScriptError;
+    if (req.postRequestScript?.trim()) {
+      const r = await scriptRunner.runScript(req.postRequestScript, {
+        envVars: updatedEnvVars,
+        collectionVars: updatedCollectionVars,
+        globals: updatedGlobals,
+        localVars,
+        response
+      });
+      testResults = r.testResults;
+      consoleOutput = r.consoleOutput;
+      postScriptError = r.error;
+      scriptRunner.patchGlobals(r.updatedGlobals);
+      await scriptRunner.persistGlobals();
+      if (verbose && r.consoleOutput.length) r.consoleOutput.forEach((l) => console.log(color(`    [post] ${l}`, C.gray)));
+    }
+    const allPassed = testResults.every((t) => t.passed);
+    const status = postScriptError ? "error" : testResults.length > 0 ? allPassed ? "passed" : "failed" : "passed";
+    return { ...base, status, httpStatus: fetchResp.status, durationMs, testResults, consoleOutput, preScriptError, postScriptError };
+  } catch (err) {
+    return {
+      ...base,
+      status: "error",
+      durationMs: Date.now() - start,
+      error: err instanceof Error ? err.message : String(err),
+      preScriptError
+    };
+  }
+}
+function printResult(r, verbose) {
+  const icon = r.status === "passed" ? color("✓", C.green, C.bold) : r.status === "failed" ? color("✗", C.red, C.bold) : color("⚠", C.yellow, C.bold);
+  const http = r.httpStatus ? color(` ${r.httpStatus}`, r.httpStatus < 400 ? C.green : C.red) : "";
+  const dur = r.durationMs !== void 0 ? color(` ${r.durationMs}ms`, C.gray) : "";
+  const method = color(r.method.padEnd(7), C.cyan);
+  console.log(`  ${icon}  ${method}  ${r.name}${http}${dur}`);
+  if (verbose) console.log(color(`       ${r.resolvedUrl}`, C.gray));
+  if (r.testResults?.length) {
+    for (const t of r.testResults) {
+      const ti = t.passed ? color("  ✓", C.green) : color("  ✗", C.red);
+      console.log(`${ti} ${t.name}${t.error ? color(` — ${t.error}`, C.red) : ""}`);
+    }
+  }
+  if (r.error) console.log(color(`     Error: ${r.error}`, C.red));
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    console.log(
+      "\nUsage:\n  api-spector run --workspace <path> [--env <name>] [--tags <a,b>]\n                  [--collection <name>] [--output <path>] [--format json|junit]\n                  [--verbose] [--bail]\n"
+    );
+    process.exit(0);
+  }
+  const wsPath = args.workspace;
+  if (!wsPath) {
+    console.error(color("Error: --workspace is required", C.red));
+    process.exit(1);
+  }
+  const filterTags = args.tags ? args.tags.split(",").map((t) => t.trim()).filter(Boolean) : [];
+  const envName = args.env;
+  const colName = args.collection;
+  const verbose = Boolean(args.verbose);
+  const bail = Boolean(args.bail);
+  const outputPath = args.output;
+  const inferredFormat = outputPath && path.extname(outputPath).toLowerCase() === ".xml" ? "junit" : "json";
+  const outputFormat = args.format?.toLowerCase() === "junit" ? "junit" : inferredFormat;
+  let workspace, wsDir;
+  try {
+    ;
+    ({ workspace, dir: wsDir } = await loadWorkspace(wsPath));
+  } catch {
+    console.error(color(`Error: could not read workspace file: ${wsPath}`, C.red));
+    process.exit(1);
+  }
+  await scriptRunner.loadGlobals(wsDir);
+  const collections = await loadCollections(workspace, wsDir);
+  const environments = await loadEnvironments(workspace, wsDir);
+  const env = envName ? environments.find((e) => e.name.toLowerCase() === envName.toLowerCase()) ?? null : null;
+  if (envName && !env) {
+    console.warn(color(`Warning: environment "${envName}" not found. Running without environment.`, C.yellow));
+  }
+  console.log("");
+  console.log(color("  API Test Runner", C.bold, C.white));
+  console.log(color(`  Workspace:   ${wsPath}`, C.gray));
+  console.log(color(`  Environment: ${env?.name ?? "(none)"}`, C.gray));
+  if (filterTags.length) console.log(color(`  Tags:        ${filterTags.join(", ")}`, C.gray));
+  console.log("");
+  const summary = { total: 0, passed: 0, failed: 0, errors: 0, durationMs: 0 };
+  const allResults = [];
+  const totalStart = Date.now();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  let firstColName;
+  for (const col of collections) {
+    if (colName && col.name.toLowerCase() !== colName.toLowerCase()) continue;
+    const items = collectTagged(col.rootFolder, col.requests, col.collectionVariables ?? {}, filterTags);
+    if (items.length === 0) continue;
+    if (!firstColName) firstColName = col.name;
+    const envVars = await scriptRunner.buildEnvVars(env);
+    const globals = scriptRunner.getGlobals();
+    console.log(color(`  ┌ ${col.name}`, C.bold, C.white));
+    let bailed = false;
+    for (const item of items) {
+      const result = await executeRequest(item.request, item.collectionVars, envVars, globals, verbose);
+      printResult(result, verbose);
+      allResults.push(result);
+      summary.total++;
+      if (result.status === "passed") summary.passed++;
+      else if (result.status === "failed") summary.failed++;
+      else summary.errors++;
+      if (bail && (result.status === "failed" || result.status === "error")) {
+        console.log(color("\n  Bailing after first failure.", C.yellow));
+        bailed = true;
+        break;
+      }
+    }
+    console.log("");
+    if (bailed) break;
+  }
+  summary.durationMs = Date.now() - totalStart;
+  const passStr = color(`${summary.passed} passed`, C.green, C.bold);
+  const failStr = summary.failed > 0 ? color(` · ${summary.failed} failed`, C.red, C.bold) : "";
+  const errStr = summary.errors > 0 ? color(` · ${summary.errors} errors`, C.yellow, C.bold) : "";
+  const totalStr = color(` · ${summary.total} total · ${summary.durationMs}ms`, C.gray);
+  console.log(`  ${passStr}${failStr}${errStr}${totalStr}
+`);
+  if (outputPath) {
+    const meta = { workspace: wsPath, environment: env?.name ?? null, collection: firstColName, timestamp };
+    const report = outputFormat === "junit" ? buildJUnitReport(allResults, summary, meta) : buildJsonReport(allResults, summary, meta);
+    await promises.writeFile(path.resolve(outputPath), report, "utf8");
+    console.log(color(`  Report written: ${outputPath} (${outputFormat})
+`, C.gray));
+  }
+  process.exit(summary.failed + summary.errors > 0 ? 1 : 0);
+}
+main().catch((err) => {
+  console.error(color(`Fatal: ${err.message}`, C.red));
+  process.exit(2);
+});

package/out/preload/index.js

@@ -0,0 +1,81 @@
+"use strict";
+const electron = require("electron");
+const api = {
+  // ─── Workspace / File ──────────────────────────────────────────────────────
+  openWorkspace: () => electron.ipcRenderer.invoke("file:openWorkspace"),
+  getLastWorkspace: () => electron.ipcRenderer.invoke("file:getLastWorkspace"),
+  saveWorkspace: (ws) => electron.ipcRenderer.invoke("file:saveWorkspace", ws),
+  newWorkspace: () => electron.ipcRenderer.invoke("file:newWorkspace"),
+  closeWorkspace: () => electron.ipcRenderer.invoke("file:closeWorkspace"),
+  loadCollection: (relPath) => electron.ipcRenderer.invoke("file:loadCollection", relPath),
+  saveCollection: (relPath, col) => electron.ipcRenderer.invoke("file:saveCollection", relPath, col),
+  loadEnvironment: (relPath) => electron.ipcRenderer.invoke("file:loadEnvironment", relPath),
+  saveEnvironment: (relPath, env) => electron.ipcRenderer.invoke("file:saveEnvironment", relPath, env),
+  // ─── HTTP execution ────────────────────────────────────────────────────────
+  sendRequest: (payload) => electron.ipcRenderer.invoke("request:send", payload),
+  // ─── Secrets (encrypted, master-key-based) ───────────────────────────────
+  checkMasterKey: () => electron.ipcRenderer.invoke("secret:checkMasterKey"),
+  setMasterKey: (value) => electron.ipcRenderer.invoke("secret:setMasterKey", value),
+  // ─── Globals ──────────────────────────────────────────────────────────────
+  getGlobals: () => electron.ipcRenderer.invoke("globals:get"),
+  setGlobals: (globals) => electron.ipcRenderer.invoke("globals:set", globals),
+  // ─── Runner ───────────────────────────────────────────────────────────────
+  runCollection: (payload) => electron.ipcRenderer.invoke("runner:start", payload),
+  onRunProgress: (cb) => {
+    electron.ipcRenderer.on("runner:progress", (_e, result) => cb(result));
+  },
+  offRunProgress: () => {
+    electron.ipcRenderer.removeAllListeners("runner:progress");
+  },
+  saveResults: (content, defaultName) => electron.ipcRenderer.invoke("results:save", content, defaultName),
+  // ─── Import ────────────────────────────────────────────────────────────────
+  importPostman: () => electron.ipcRenderer.invoke("import:postman"),
+  importOpenApi: () => electron.ipcRenderer.invoke("import:openapi"),
+  importOpenApiFromUrl: (url) => electron.ipcRenderer.invoke("import:openapi-url", url),
+  importInsomnia: () => electron.ipcRenderer.invoke("import:insomnia"),
+  importBruno: () => electron.ipcRenderer.invoke("import:bruno"),
+  // ─── Code generation ──────────────────────────────────────────────────────
+  generateCode: (opts) => electron.ipcRenderer.invoke("generate:code", opts),
+  pickOutputDir: () => electron.ipcRenderer.invoke("dialog:pickDir"),
+  saveGeneratedFiles: (files, outputDir) => electron.ipcRenderer.invoke("generate:save", files, outputDir),
+  saveGeneratedFilesAsZip: (files, collectionName, target) => electron.ipcRenderer.invoke("generate:saveZip", files, collectionName, target),
+  // ─── OAuth 2.0 ────────────────────────────────────────────────────────────
+  oauth2StartFlow: (auth, vars) => electron.ipcRenderer.invoke("oauth2:startFlow", auth, vars),
+  oauth2RefreshToken: (auth, vars, refreshToken) => electron.ipcRenderer.invoke("oauth2:refreshToken", auth, vars, refreshToken),
+  // ─── Mock servers ─────────────────────────────────────────────────────────────
+  mockStart: (server) => electron.ipcRenderer.invoke("mock:start", server),
+  mockStop: (id) => electron.ipcRenderer.invoke("mock:stop", id),
+  mockIsRunning: (id) => electron.ipcRenderer.invoke("mock:isRunning", id),
+  mockRunningIds: () => electron.ipcRenderer.invoke("mock:runningIds"),
+  saveMock: (relPath, server) => electron.ipcRenderer.invoke("file:saveMock", relPath, server),
+  loadMock: (relPath) => electron.ipcRenderer.invoke("file:loadMock", relPath),
+  mockUpdateRoutes: (id, routes) => electron.ipcRenderer.invoke("mock:updateRoutes", id, routes),
+  onMockHit: (cb) => {
+    electron.ipcRenderer.on("mock:hit", (_e, hit) => cb(hit));
+  },
+  offMockHit: () => {
+    electron.ipcRenderer.removeAllListeners("mock:hit");
+  },
+  // ─── WebSocket ────────────────────────────────────────────────────────────
+  wsConnect: (requestId, url, headers) => electron.ipcRenderer.invoke("ws:connect", requestId, url, headers),
+  wsSend: (requestId, data) => electron.ipcRenderer.invoke("ws:send", requestId, data),
+  wsDisconnect: (requestId) => electron.ipcRenderer.invoke("ws:disconnect", requestId),
+  onWsMessage: (cb) => {
+    electron.ipcRenderer.on("ws:message", (_e, payload) => cb(payload));
+  },
+  onWsStatus: (cb) => {
+    electron.ipcRenderer.on("ws:status", (_e, payload) => cb(payload));
+  },
+  offWsEvents: () => {
+    electron.ipcRenderer.removeAllListeners("ws:message");
+    electron.ipcRenderer.removeAllListeners("ws:status");
+  },
+  // ─── SOAP / WSDL ──────────────────────────────────────────────────────────
+  wsdlFetch: (url, extraHeaders) => electron.ipcRenderer.invoke("wsdl:fetch", url, extraHeaders ?? {}),
+  // ─── Docs generation ──────────────────────────────────────────────────────
+  generateDocs: (payload) => electron.ipcRenderer.invoke("docs:generate", payload),
+  // ─── Contract testing ─────────────────────────────────────────────────────
+  runContracts: (payload) => electron.ipcRenderer.invoke("contract:run", payload),
+  inferContractSchema: (jsonBody) => electron.ipcRenderer.invoke("contract:inferSchema", jsonBody)
+};
+electron.contextBridge.exposeInMainWorld("electron", api);