@testsmith/api-spector 0.2.3 → 0.2.5

package/out/main/index.js

@@ -25,19 +25,20 @@ const electron = require("electron");
 const path = require("path");
 const fs = require("fs");
 const promises = require("fs/promises");
-const requestCollection = require("./chunks/request-collection-DMVlm0PA.js");
+const requestCollection = require("./chunks/request-collection-CElFJzre.js");
 const authBuilder = require("./chunks/auth-builder-B7-LgcGr.js");
 const uuid = require("uuid");
 const jsYaml = require("js-yaml");
 const undici = require("undici");
 const JSZip = require("jszip");
-const mockServer = require("./chunks/mock-server-Cx-xG4pJ.js");
+const mockServer = require("./chunks/mock-server-DmdvwCgj.js");
 const http = require("http");
 const WebSocket = require("ws");
-const https = require("https");
+const soapHandler = require("./chunks/soap-handler-Cpj-JwyA.js");
 const os = require("os");
 const crypto = require("crypto");
 const snapshots = require("./chunks/snapshots-C7YbGHM7.js");
+const ipcValidate = require("./chunks/ipc-validate-CscN4HfG.js");
 const simpleGit = require("simple-git");
 const recorder = require("./chunks/recorder-DFxJgn9c.js");
 require("vm");
@@ -46,6 +47,7 @@ require("tv4");
 require("jsonpath-plus");
 require("@xmldom/xmldom");
 require("ajv");
+require("https");
 const LAST_WS_FILE = path.join(electron.app.getPath("userData"), "last-workspace.json");
 async function saveLastWorkspacePath(wsPath) {
   await promises.writeFile(LAST_WS_FILE, JSON.stringify({ path: wsPath }), "utf8");
@@ -63,10 +65,156 @@ let workspaceFile = null;
 function atomicWrite(path2, data) {
   return promises.writeFile(path2, data, "utf8");
 }
+const SPECTOR_GITIGNORE = [
+  "# API Spector — never commit secrets",
+  "*.secrets",
+  ".env",
+  ".env.local",
+  ".env.*.local",
+  "",
+  "# Dependencies",
+  "node_modules/",
+  "",
+  "# Generated API docs",
+  "api-docs.html",
+  "api-docs.md",
+  "docs/",
+  "",
+  "# Run reports (api-spector run --output)",
+  "reports/",
+  "*-report.json",
+  "*-report.xml",
+  "*-report.html",
+  "results.json",
+  "results.xml",
+  "results.html",
+  "coverage/",
+  "",
+  "# OS / editor",
+  ".DS_Store",
+  "Thumbs.db",
+  ".idea/",
+  ""
+].join("\n");
+function readmeContents(workspaceFileName) {
+  return [
+    `# API tests`,
+    ``,
+    `This folder is an [API Spector](https://github.com/testsmith-io/api-spector) workspace.`,
+    `Everything here is plain JSON — diff it, commit it, review it like any other code.`,
+    ``,
+    `## Layout`,
+    ``,
+    "```",
+    `${workspaceFileName}      ← workspace manifest (this is what you "open")`,
+    `collections/              ← your request collections`,
+    `environments/             ← per-env variable files (dev, staging, prod, …)`,
+    `mocks/                    ← saved mock servers (optional)`,
+    `contracts/                ← pinned OpenAPI snapshots (optional)`,
+    `.gitignore                ← excludes secrets, generated docs, run reports`,
+    `.vscode/settings.json     ← maps *.spector to JSON for editor highlighting`,
+    "```",
+    ``,
+    `## Open the workspace`,
+    ``,
+    "```bash",
+    `# launches the GUI in this folder`,
+    `npx -y @testsmith/api-spector ui`,
+    "```",
+    ``,
+    `## Run the tests from CI`,
+    ``,
+    "```bash",
+    `npx -y @testsmith/api-spector run \\`,
+    `  --workspace ./${workspaceFileName} \\`,
+    `  --environment ci \\`,
+    `  --output reports/results.xml --format junit`,
+    "```",
+    ``,
+    `Other useful commands:`,
+    ``,
+    `| Command | What it does |`,
+    `|---|---|`,
+    `| \`api-spector run\`       | Execute requests / assertions |`,
+    `| \`api-spector mock\`      | Start mock servers from this workspace |`,
+    `| \`api-spector contract\`  | Manage and run pinned contract snapshots |`,
+    `| \`api-spector wsdl\`      | Inspect a WSDL or import as collection / mock |`,
+    ``,
+    `## A note on secrets`,
+    ``,
+    `Secret values (passwords, OAuth client secrets, API keys) are stored in your`,
+    `OS keychain — **not** in this folder. Environment files only reference the`,
+    `keychain entry by name, so it's safe to commit them.`,
+    ``
+  ].join("\n");
+}
+async function ensureReadme(workspaceDir2, workspaceFileName) {
+  const path$1 = path.join(workspaceDir2, "README.md");
+  try {
+    await promises.readFile(path$1, "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));
+  }
+}
+async function ensureGitignore(workspaceDir2) {
+  const path$1 = path.join(workspaceDir2, ".gitignore");
+  try {
+    await promises.readFile(path$1, "utf8");
+    return;
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      console.warn("file-handler: could not check .gitignore", err);
+      return;
+    }
+    await atomicWrite(path$1, SPECTOR_GITIGNORE);
+  }
+}
+async function ensureVscodeFileAssociation(workspaceDir2) {
+  const dir = path.join(workspaceDir2, ".vscode");
+  const file = path.join(dir, "settings.json");
+  try {
+    const raw = await promises.readFile(file, "utf8");
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const associations = parsed["files.associations"] ?? {};
+    if (associations["*.spector"] === "json") return;
+    parsed["files.associations"] = { ...associations, "*.spector": "json" };
+    await atomicWrite(file, JSON.stringify(parsed, null, 2) + "\n");
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      console.warn("file-handler: could not read existing .vscode/settings.json", err);
+      return;
+    }
+    await promises.mkdir(dir, { recursive: true });
+    const fresh = { "files.associations": { "*.spector": "json" } };
+    await atomicWrite(file, JSON.stringify(fresh, null, 2) + "\n");
+  }
+}
+function dialogStartDir() {
+  return process.env.API_SPECTOR_LAUNCH_CWD || workspaceDir || void 0;
+}
+function defaultWorkspaceName() {
+  const cwd = process.env.API_SPECTOR_LAUNCH_CWD;
+  if (cwd) {
+    const base = cwd.split(/[\\/]/).filter(Boolean).pop();
+    if (base && /^[a-zA-Z0-9._-]+$/.test(base)) return `${base}.spector`;
+  }
+  return "my-workspace.spector";
+}
 function registerFileHandlers(ipc) {
   ipc.handle("file:openWorkspace", async () => {
     const result = await electron.dialog.showOpenDialog({
       title: "Open Workspace",
+      defaultPath: dialogStartDir(),
       filters: [{ name: "API Spector Workspace", extensions: ["spector", "json"] }],
       properties: ["openFile"]
     });
@@ -80,9 +228,11 @@ function registerFileHandlers(ipc) {
     return { workspace: JSON.parse(raw), workspacePath: wsPath };
   });
   ipc.handle("file:newWorkspace", async () => {
+    const startDir = dialogStartDir();
+    const defaultPath = startDir ? path.join(startDir, defaultWorkspaceName()) : defaultWorkspaceName();
     const result = await electron.dialog.showSaveDialog({
       title: "Create Workspace",
-      defaultPath: "my-workspace.spector",
+      defaultPath,
       filters: [{ name: "API Spector Workspace", extensions: ["spector", "json"] }]
     });
     if (result.canceled || !result.filePath) return null;
@@ -91,8 +241,9 @@ function registerFileHandlers(ipc) {
     await requestCollection.loadGlobals(workspaceDir);
     await promises.mkdir(path.join(workspaceDir, "collections"), { recursive: true });
     await promises.mkdir(path.join(workspaceDir, "environments"), { recursive: true });
-    const gitignore = "# API Spector — never commit secrets\n*.secrets\n.env.local\n\n# Dependencies\nnode_modules/\n";
-    await atomicWrite(path.join(workspaceDir, ".gitignore"), gitignore);
+    await ensureGitignore(workspaceDir);
+    await ensureVscodeFileAssociation(workspaceDir);
+    await ensureReadme(workspaceDir, path.basename(result.filePath));
     const ws = {
       version: "1.0",
       collections: [],
@@ -106,6 +257,7 @@ function registerFileHandlers(ipc) {
   ipc.handle("file:saveWorkspace", async (_e, ws) => {
     if (!workspaceFile) return;
     await atomicWrite(workspaceFile, JSON.stringify(ws, null, 2));
+    if (workspaceDir) await ensureVscodeFileAssociation(workspaceDir);
   });
   ipc.handle("file:loadCollection", async (_e, relPath) => {
     if (!workspaceDir) throw new Error("No workspace open");
@@ -129,6 +281,18 @@ function registerFileHandlers(ipc) {
     await promises.mkdir(path.dirname(fullPath), { recursive: true });
     await atomicWrite(fullPath, JSON.stringify(env, null, 2));
   });
+  ipc.handle("file:deleteWorkspaceFile", async (_e, relPath) => {
+    if (!workspaceDir) throw new Error("No workspace open");
+    const fullPath = path.resolve(workspaceDir, relPath);
+    if (!fullPath.startsWith(path.resolve(workspaceDir) + (process.platform === "win32" ? "\\" : "/"))) {
+      throw new Error(`Refusing to delete file outside the workspace: ${relPath}`);
+    }
+    try {
+      await promises.unlink(fullPath);
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  });
   ipc.handle("dialog:pickDir", async () => {
     const result = await electron.dialog.showOpenDialog({
       title: "Select Output Directory",
@@ -160,23 +324,51 @@ function registerFileHandlers(ipc) {
   ipc.handle("file:closeWorkspace", async () => {
     workspaceDir = null;
     workspaceFile = null;
-    await promises.writeFile(LAST_WS_FILE, JSON.stringify({ path: null }), "utf8").catch(() => {
+    await promises.writeFile(LAST_WS_FILE, JSON.stringify({ path: null }), "utf8").catch((err) => {
+      console.warn("file-handler: could not clear last-workspace pointer", err);
     });
   });
   ipc.handle("file:getLastWorkspace", async () => {
+    const cwd = process.env.API_SPECTOR_LAUNCH_CWD;
+    if (cwd) {
+      const fromCwd = await tryOpenWorkspaceInDir(cwd);
+      return fromCwd;
+    }
     const wsPath = await readLastWorkspacePath();
     if (!wsPath) return null;
     try {
+      const raw = await promises.readFile(wsPath, "utf8");
+      const workspace = JSON.parse(raw);
       workspaceDir = path.dirname(wsPath);
       workspaceFile = wsPath;
       await requestCollection.loadGlobals(workspaceDir);
-      const raw = await promises.readFile(wsPath, "utf8");
-      return { workspace: JSON.parse(raw), workspacePath: wsPath };
+      return { workspace, workspacePath: wsPath };
     } catch {
       return null;
     }
   });
 }
+async function tryOpenWorkspaceInDir(dir) {
+  let entries;
+  try {
+    entries = await promises.readdir(dir);
+  } catch {
+    return null;
+  }
+  const candidates = entries.filter((f) => f.endsWith(".spector"));
+  if (candidates.length !== 1) return null;
+  const wsPath = path.join(dir, candidates[0]);
+  try {
+    const raw = await promises.readFile(wsPath, "utf8");
+    const workspace = JSON.parse(raw);
+    workspaceDir = dir;
+    workspaceFile = wsPath;
+    await requestCollection.loadGlobals(workspaceDir);
+    return { workspace, workspacePath: wsPath };
+  } catch {
+    return null;
+  }
+}
 function getWorkspaceDir() {
   return workspaceDir;
 }
@@ -3100,7 +3292,8 @@ async function executeOne(req, collectionVars, envVars, globals, localVars, disp
       envVars: { ...envVars },
       collectionVars: { ...collectionVars },
       globals: { ...globals },
-      localVars: {}
+      localVars: {},
+      piiMaskPatterns
     });
     preScriptError = r.error;
     localVars = r.updatedLocalVars;
@@ -3138,6 +3331,25 @@ async function executeOne(req, collectionVars, envVars, globals, localVars, disp
     } else if (req.body.mode === "raw" && req.body.raw) {
       body = authBuilder.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: authBuilder.interpolate(gql.query, vars) };
+      const rawVars = gql.variables?.trim();
+      if (rawVars) {
+        try {
+          gqlBody.variables = JSON.parse(authBuilder.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");
+    } else if (req.body.mode === "soap" && req.body.soap) {
+      body = authBuilder.interpolate(req.body.soap.envelope, vars);
+      if (!headers.has("content-type")) headers.set("Content-Type", "text/xml; charset=utf-8");
+      if (req.body.soap.soapAction && !headers.has("soapaction")) {
+        headers.set("SOAPAction", req.body.soap.soapAction);
+      }
     }
     const methodHasBody = !["GET", "HEAD"].includes(req.method);
     const doFetch = (h) => undici.fetch(resolvedUrl, {
@@ -3169,16 +3381,17 @@ async function executeOne(req, collectionVars, envVars, globals, localVars, disp
     });
     const maskedBody = requestCollection.maskPii(responseBody, piiMaskPatterns);
     const maskedHeaders = requestCollection.maskHeaders(rawRespHeaders, piiMaskPatterns);
-    const response = {
+    const scriptResponse = {
       status: fetchResp.status,
       statusText: fetchResp.statusText,
-      headers: maskedHeaders,
-      body: maskedBody,
+      headers: rawRespHeaders,
+      body: responseBody,
       bodySize: Buffer.byteLength(responseBody, "utf8"),
       durationMs
     };
     const schemaTestResults = requestCollection.buildSchemaTestResults(req.schema, responseBody);
-    let testResults = [...schemaTestResults];
+    const protocolFaultTests = requestCollection.buildProtocolFaultTests(req.body.mode, responseBody);
+    let testResults = [...schemaTestResults, ...protocolFaultTests];
     let consoleOutput = [];
     let postScriptError;
     if (req.postRequestScript?.trim()) {
@@ -3187,9 +3400,10 @@ async function executeOne(req, collectionVars, envVars, globals, localVars, disp
         collectionVars: updatedCollectionVars,
         globals: updatedGlobals,
         localVars,
-        response
+        response: scriptResponse,
+        piiMaskPatterns
       });
-      testResults = [...schemaTestResults, ...r.testResults];
+      testResults = [...schemaTestResults, ...protocolFaultTests, ...r.testResults];
       consoleOutput = r.consoleOutput;
       postScriptError = r.error;
       updatedEnvVars = r.updatedEnvVars;
@@ -3202,7 +3416,7 @@ async function executeOne(req, collectionVars, envVars, globals, localVars, disp
     const allPassed = testResults.every((t) => t.passed);
     const httpFailed = fetchResp.status >= 400;
     const hasTests = testResults.length > 0;
-    const status = postScriptError ? "error" : hasTests ? allPassed ? "passed" : "failed" : httpFailed ? "failed" : "skipped";
+    const status = postScriptError ? "error" : hasTests ? allPassed ? "passed" : "failed" : httpFailed ? "failed" : "passed";
     if (httpFailed && testResults.length === 0) {
       testResults = [
         ...testResults,
@@ -3567,70 +3781,31 @@ function registerWsHandlers(ipc) {
     }
   });
 }
-function fetchUrl(url, headers = {}) {
-  return new Promise((resolve2, reject) => {
-    const lib = url.startsWith("https") ? https : http;
-    const req = lib.get(url, { headers }, (res) => {
-      const chunks = [];
-      res.on("data", (chunk) => chunks.push(chunk));
-      res.on("end", () => resolve2(Buffer.concat(chunks).toString("utf8")));
-      res.on("error", reject);
-    });
-    req.on("error", reject);
-    req.setTimeout(15e3, () => {
-      req.destroy();
-      reject(new Error("WSDL fetch timed out"));
-    });
-  });
+function isJsonContentType(ct) {
+  return !!ct && /\bjson\b/i.test(ct);
 }
-function parseWsdl(wsdlText) {
-  const nsMatch = wsdlText.match(/targetNamespace\s*=\s*["']([^"']+)["']/);
-  const targetNamespace = nsMatch ? nsMatch[1] : "";
-  const operationRegex = /<(?:wsdl:)?operation\s+name\s*=\s*["']([^"']+)["']/g;
-  const operationNames = /* @__PURE__ */ new Set();
-  let m;
-  while ((m = operationRegex.exec(wsdlText)) !== null) {
-    operationNames.add(m[1]);
-  }
-  const soapActionMap = {};
-  const bindingOpRegex = /<(?:wsdl:)?operation\s+name\s*=\s*["']([^"']+)["'][^>]*>([\s\S]*?)<\/(?:wsdl:)?operation>/g;
-  while ((m = bindingOpRegex.exec(wsdlText)) !== null) {
-    const opName = m[1];
-    const block = m[2];
-    const saMatch = block.match(/soapAction\s*=\s*["']([^"']*)["']/);
-    if (saMatch) soapActionMap[opName] = saMatch[1];
-  }
-  const operations = [];
-  for (const name of operationNames) {
-    const soapAction = soapActionMap[name];
-    const inputTemplate = buildEnvelopeTemplate(name, targetNamespace);
-    operations.push({ name, soapAction, inputTemplate });
-  }
-  return { operations, targetNamespace };
-}
-function buildEnvelopeTemplate(operationName, namespace) {
-  return `<?xml version="1.0" encoding="utf-8"?>
-<soap:Envelope
-  xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
-  xmlns:tns="${namespace}">
-  <soap:Header/>
-  <soap:Body>
-    <tns:${operationName}>
-      <!-- Add parameters here -->
-    </tns:${operationName}>
-  </soap:Body>
-</soap:Envelope>`;
-}
-function registerSoapHandlers(ipc) {
-  ipc.handle("wsdl:fetch", async (_event, url, extraHeaders = {}) => {
-    const wsdlText = await fetchUrl(url, extraHeaders);
-    return parseWsdl(wsdlText);
-  });
+function formatBody(body, contentType) {
+  if (!body) return "";
+  const trimmed = body.length > 8e3 ? body.slice(0, 8e3) + "\n… (truncated)" : body;
+  if (isJsonContentType(contentType)) {
+    try {
+      return JSON.stringify(JSON.parse(trimmed), null, 2);
+    } catch {
+    }
+  }
+  return trimmed;
+}
+function langForContentType(ct) {
+  if (!ct) return "";
+  if (/\bjson\b/i.test(ct)) return "json";
+  if (/\bxml\b/i.test(ct)) return "xml";
+  if (/\bhtml\b/i.test(ct)) return "html";
+  return "";
 }
 function escMd(s) {
   return s.replace(/[|\\`*_{}[\]()#+\-.!]/g, (c) => `\\${c}`);
 }
-function requestToMarkdown(req) {
+function requestToMarkdown(req, example) {
   const lines = [];
   const methodLabel = req.protocol === "websocket" ? "WS" : req.method;
   lines.push(`#### ${methodLabel} ${escMd(req.name)}`);
@@ -3697,9 +3872,31 @@ function requestToMarkdown(req) {
     lines.push("```");
     lines.push("");
   }
+  if (example?.sent?.body?.trim()) {
+    const ct = example.sent.headers?.["Content-Type"] ?? example.sent.headers?.["content-type"];
+    const lang = langForContentType(ct);
+    lines.push("**Example Request Body**");
+    lines.push("```" + lang);
+    lines.push(formatBody(example.sent.body, ct));
+    lines.push("```");
+    lines.push("");
+  }
+  if (example?.response) {
+    const ct = example.response.headers["content-type"] ?? example.response.headers["Content-Type"];
+    const lang = langForContentType(ct);
+    lines.push(`**Example Response** (${example.response.status})`);
+    if (example.response.body?.trim()) {
+      lines.push("```" + lang);
+      lines.push(formatBody(example.response.body, ct));
+      lines.push("```");
+    } else {
+      lines.push("_(empty body)_");
+    }
+    lines.push("");
+  }
   return lines.join("\n");
 }
-function folderToMarkdown(folder, requests, depth) {
+function folderToMarkdown(folder, requests, depth, examples) {
   const lines = [];
   const heading = "#".repeat(depth);
   if (folder.name !== "root") {
@@ -3713,11 +3910,11 @@ function folderToMarkdown(folder, requests, depth) {
   for (const reqId of folder.requestIds) {
     const req = requests[reqId];
     if (req) {
-      lines.push(requestToMarkdown(req));
+      lines.push(requestToMarkdown(req, examples[reqId]));
     }
   }
   for (const sub of folder.folders) {
-    lines.push(folderToMarkdown(sub, requests, depth + 1));
+    lines.push(folderToMarkdown(sub, requests, depth + 1, examples));
   }
   return lines.join("\n");
 }
@@ -3725,6 +3922,7 @@ function generateMarkdown(payload) {
   const lines = [];
   lines.push("# API Documentation");
   lines.push("");
+  const examples = payload.examples ?? {};
   for (const { collection, requests } of payload.collections) {
     lines.push(`## ${escMd(collection.name)}`);
     lines.push("");
@@ -3732,7 +3930,7 @@ function generateMarkdown(payload) {
       lines.push(collection.description.trim());
       lines.push("");
     }
-    lines.push(folderToMarkdown(collection.rootFolder, requests, 3));
+    lines.push(folderToMarkdown(collection.rootFolder, requests, 3, examples));
   }
   return lines.join("\n");
 }
@@ -3749,7 +3947,7 @@ const METHOD_COLORS = {
   OPTIONS: "#9ca3af",
   WS: "#22d3ee"
 };
-function requestToHtml(req) {
+function requestToHtml(req, example) {
   const methodLabel = req.protocol === "websocket" ? "WS" : req.method;
   const color = METHOD_COLORS[methodLabel] ?? "#9ca3af";
   let html = `<div class="request">`;
@@ -3787,10 +3985,23 @@ function requestToHtml(req) {
   } else if (mode === "soap" && req.body.soap?.envelope?.trim()) {
     html += `<div class="label">Body (SOAP)</div><pre><code>${escHtml(req.body.soap.envelope.trim())}</code></pre>`;
   }
+  if (example?.sent?.body?.trim()) {
+    const ct = example.sent.headers?.["Content-Type"] ?? example.sent.headers?.["content-type"];
+    html += `<div class="label">Example Request Body</div><pre><code class="lang-${escHtml(langForContentType(ct))}">${escHtml(formatBody(example.sent.body, ct))}</code></pre>`;
+  }
+  if (example?.response) {
+    const ct = example.response.headers["content-type"] ?? example.response.headers["Content-Type"];
+    html += `<div class="label">Example Response (${example.response.status})</div>`;
+    if (example.response.body?.trim()) {
+      html += `<pre><code class="lang-${escHtml(langForContentType(ct))}">${escHtml(formatBody(example.response.body, ct))}</code></pre>`;
+    } else {
+      html += `<p class="desc"><em>(empty body)</em></p>`;
+    }
+  }
   html += `</div>`;
   return html;
 }
-function folderToHtml(folder, requests, depth) {
+function folderToHtml(folder, requests, depth, examples) {
   let html = "";
   const tag = `h${Math.min(depth, 6)}`;
   if (folder.name !== "root") {
@@ -3801,21 +4012,22 @@ function folderToHtml(folder, requests, depth) {
   }
   for (const reqId of folder.requestIds) {
     const req = requests[reqId];
-    if (req) html += requestToHtml(req);
+    if (req) html += requestToHtml(req, examples[reqId]);
   }
   for (const sub of folder.folders) {
-    html += folderToHtml(sub, requests, depth + 1);
+    html += folderToHtml(sub, requests, depth + 1, examples);
   }
   return html;
 }
 function generateHtml(payload) {
   let body = "";
+  const examples = payload.examples ?? {};
   for (const { collection, requests } of payload.collections) {
     body += `<section class="collection"><h2>${escHtml(collection.name)}</h2>`;
     if (collection.description?.trim()) {
       body += `<p class="collection-desc">${escHtml(collection.description.trim())}</p>`;
     }
-    body += folderToHtml(collection.rootFolder, requests, 3);
+    body += folderToHtml(collection.rootFolder, requests, 3, examples);
     body += `</section>`;
   }
   return `<!DOCTYPE html>
@@ -3901,6 +4113,7 @@ async function resolveSnapshotSpec(relPath) {
 }
 function registerContractHandlers(ipc) {
   ipc.handle("contract:run", async (_e, payload) => {
+    ipcValidate.validateContractRunPayload(payload);
     const { mode, requests, envVars, collectionVars = {}, requestBaseUrl } = payload;
     let { specUrl, specPath } = payload;
     if (payload.specSnapshotRelPath) {
@@ -3961,6 +4174,8 @@ function registerGitHandlers(ipc) {
   });
   ipc.handle("git:init", async () => {
     await git().init();
+    const dir = getWorkspaceDir();
+    if (dir) await ensureGitignore(dir);
   });
   ipc.handle("git:status", async () => {
     const result = await git().status();
@@ -4020,16 +4235,58 @@ function registerGitHandlers(ipc) {
     }));
   });
   ipc.handle("git:branches", async () => {
-    const result = await git().branch(["-a", "--format=%(refname:short)|%(objectname:short)|%(upstream:short)|%(upstream:track)"]);
-    return result.all.filter((name) => !name.includes("HEAD")).map((name) => ({
-      name: name.replace(/^remotes\//, ""),
-      current: name === result.current,
-      remote: name.startsWith("remotes/")
-    }));
+    const raw = await git().raw([
+      "for-each-ref",
+      "--format=%(refname:short)|%(HEAD)|%(upstream:short)|%(upstream:track)",
+      "refs/heads",
+      "refs/remotes"
+    ]);
+    const current = (await git().branch()).current;
+    const branches = [];
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      const [shortName, head, upstream, track] = line.split("|");
+      if (!shortName || shortName.endsWith("/HEAD")) continue;
+      const isRemote = shortName.startsWith("origin/") || shortName.includes("/");
+      const looksLocal = !isRemote;
+      let ahead;
+      let behind;
+      const aheadM = track?.match(/ahead (\d+)/);
+      const behindM = track?.match(/behind (\d+)/);
+      if (aheadM) ahead = Number(aheadM[1]);
+      if (behindM) behind = Number(behindM[1]);
+      branches.push({
+        name: shortName,
+        current: looksLocal && (head === "*" || shortName === current),
+        remote: isRemote,
+        upstream: upstream || void 0,
+        ahead,
+        behind
+      });
+    }
+    return branches;
   });
   ipc.handle("git:checkout", async (_e, branch, create) => {
-    if (create) await git().checkoutLocalBranch(branch);
-    else await git().checkout(branch);
+    if (create) {
+      await git().checkoutLocalBranch(branch);
+      return;
+    }
+    const m = /^([^/]+)\/(.+)$/.exec(branch);
+    if (m) {
+      const remote = m[1];
+      const localName = m[2];
+      const localList = await git().branchLocal();
+      if (!localList.all.includes(localName)) {
+        await git().checkoutBranch(localName, `${remote}/${localName}`);
+        return;
+      }
+      await git().checkout(localName);
+      return;
+    }
+    await git().checkout(branch);
+  });
+  ipc.handle("git:deleteBranch", async (_e, name, force = false) => {
+    await git().deleteLocalBranch(name, force);
   });
   ipc.handle("git:pull", async () => {
     await git().pull();
@@ -4189,7 +4446,7 @@ electron.app.whenReady().then(async () => {
   registerMockHandlers(electron.ipcMain);
   registerOAuth2Handlers(electron.ipcMain);
   registerWsHandlers(electron.ipcMain);
-  registerSoapHandlers(electron.ipcMain);
+  soapHandler.registerSoapHandlers(electron.ipcMain);
   registerDocsHandlers(electron.ipcMain);
   registerContractHandlers(electron.ipcMain);
   registerGitHandlers(electron.ipcMain);

package/out/main/mock.js

@@ -2,7 +2,7 @@
 "use strict";
 const promises = require("fs/promises");
 const path = require("path");
-const mockServer = require("./chunks/mock-server-Cx-xG4pJ.js");
+const mockServer = require("./chunks/mock-server-DmdvwCgj.js");
 require("http");
 require("crypto");
 require("vm");