@testsmith/api-spector 0.1.2 → 0.1.4

package/bin/cli.js

@@ -12,12 +12,14 @@ function printHelp() {
   console.log('')
   console.log('  Usage:')
   console.log('    api-spector ui                            Launch the app')
-  console.log('    api-spector run  --workspace <path>       Run tests from CLI')
-  console.log('    api-spector mock --workspace <path>       Start mock servers from CLI')
+  console.log('    api-spector run    --workspace <path>     Run tests from CLI')
+  console.log('    api-spector mock   --workspace <path>     Start mock servers from CLI')
+  console.log('    api-spector record --upstream <url>       Record API traffic as mock stubs')
   console.log('')
   console.log('  Options:')
-  console.log('    api-spector run  --help                   Show run options')
-  console.log('    api-spector mock --help                   Show mock options')
+  console.log('    api-spector run    --help                 Show run options')
+  console.log('    api-spector mock   --help                 Show mock options')
+  console.log('    api-spector record --help                 Show record options')
   console.log('')
   console.log('  Environment:')
   console.log('    ELECTRON_NO_SANDBOX=1                     Disable Chromium sandbox')
@@ -50,6 +52,13 @@ if (cmd === '--help' || cmd === '-h') {
     env: process.env,
   })
   proc.on('close', code => process.exit(code ?? 0))
+} else if (cmd === 'record') {
+  const recordPath = path.join(__dirname, '..', 'out', 'main', 'record.js')
+  const proc = spawn(process.execPath, [recordPath, ...rest], {
+    stdio: 'inherit',
+    env: process.env,
+  })
+  proc.on('close', code => process.exit(code ?? 0))
 } else {
   console.error(`api Spector — unknown command: "${cmd}"`)
   printHelp()

package/out/main/chunks/recorder-DFxJgn9c.js

@@ -0,0 +1,241 @@
+"use strict";
+const http = require("http");
+const crypto = require("crypto");
+const undici = require("undici");
+const DEFAULT_MASK_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-auth-token",
+  "x-access-token",
+  "proxy-authorization"
+]);
+const HOP_BY_HOP = /* @__PURE__ */ new Set([
+  "host",
+  "connection",
+  "keep-alive",
+  "proxy-connection",
+  "transfer-encoding",
+  "te",
+  "trailer",
+  "upgrade"
+]);
+const STRIP_FROM_MOCK_RESPONSE = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "transfer-encoding",
+  "content-encoding",
+  "content-length",
+  "strict-transport-security",
+  "alt-svc",
+  "cf-ray",
+  "cf-cache-status"
+]);
+let activeServer = null;
+let activeConfig = null;
+let activeEntries = [];
+let activeStarted = "";
+let activeMaskSet = /* @__PURE__ */ new Set();
+let hitCallback = null;
+function isRecorderRunning() {
+  return activeServer !== null;
+}
+function getRecorderEntries() {
+  return [...activeEntries];
+}
+function setRecorderHitCallback(cb) {
+  hitCallback = cb;
+}
+async function startRecorder(config) {
+  if (activeServer) throw new Error("Recorder already running");
+  const upstream = config.upstream.replace(/\/$/, "");
+  const maskSet = /* @__PURE__ */ new Set([
+    ...DEFAULT_MASK_HEADERS,
+    ...(config.maskHeaders ?? []).map((h) => h.toLowerCase())
+  ]);
+  const ignoreSet = /* @__PURE__ */ new Set([
+    ...HOP_BY_HOP,
+    ...(config.ignoreHeaders ?? []).map((h) => h.toLowerCase())
+  ]);
+  activeConfig = config;
+  activeEntries = [];
+  activeStarted = (/* @__PURE__ */ new Date()).toISOString();
+  activeMaskSet = maskSet;
+  const server = http.createServer(async (req, res) => {
+    const id = crypto.randomUUID();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const start = Date.now();
+    const rawUrl = req.url ?? "/";
+    const parsed = new URL(rawUrl, "http://localhost");
+    const path = parsed.pathname;
+    const query = parseQuery(parsed.search);
+    const method = (req.method ?? "GET").toUpperCase();
+    if (path === "/favicon.ico") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    let reqBodyBuf;
+    try {
+      reqBodyBuf = await readBody(req);
+    } catch {
+      res.writeHead(400);
+      res.end("Bad request body");
+      return;
+    }
+    const reqBodyStr = reqBodyBuf.length > 0 ? reqBodyBuf.toString("utf8") : null;
+    const forwardHeaders = new undici.Headers();
+    const recordedReqHeaders = {};
+    for (const [k, v] of Object.entries(req.headers)) {
+      if (!v) continue;
+      const val = Array.isArray(v) ? v.join(", ") : v;
+      const lk = k.toLowerCase();
+      if (ignoreSet.has(lk)) continue;
+      forwardHeaders.set(k, val);
+      recordedReqHeaders[k] = maskSet.has(lk) ? "***" : val;
+    }
+    const upstreamUrl = new URL(upstream);
+    forwardHeaders.set("host", upstreamUrl.host);
+    const targetUrl = `${upstream}${rawUrl}`;
+    let upstreamResp;
+    let respBodyBuf;
+    let timedOut = false;
+    const timeoutMs = 3e4;
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => {
+        controller.abort();
+        timedOut = true;
+      }, timeoutMs);
+      upstreamResp = await undici.fetch(targetUrl, {
+        method,
+        headers: forwardHeaders,
+        body: ["GET", "HEAD"].includes(method) ? void 0 : reqBodyBuf,
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      respBodyBuf = Buffer.from(await upstreamResp.arrayBuffer());
+    } catch (err) {
+      const msg = timedOut ? `Upstream timed out after ${timeoutMs}ms` : `Upstream error: ${err instanceof Error ? err.message : String(err)}`;
+      const entry2 = {
+        id,
+        timestamp,
+        durationMs: Date.now() - start,
+        request: { method, path, query, headers: recordedReqHeaders, body: reqBodyStr },
+        response: { status: 0, statusText: msg, headers: {}, body: null, binary: false, bodySize: 0 }
+      };
+      activeEntries.push(entry2);
+      hitCallback?.(entry2);
+      res.writeHead(504, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: msg }));
+      return;
+    }
+    const durationMs = Date.now() - start;
+    const status = upstreamResp.status;
+    const statusText = upstreamResp.statusText;
+    const contentType = upstreamResp.headers.get("content-type") ?? "";
+    const binary = isBinary(contentType);
+    const recordedRespHeaders = {};
+    upstreamResp.headers.forEach((v, k) => {
+      if (!ignoreSet.has(k.toLowerCase())) recordedRespHeaders[k] = v;
+    });
+    const entry = {
+      id,
+      timestamp,
+      durationMs,
+      request: { method, path, query, headers: recordedReqHeaders, body: reqBodyStr },
+      response: {
+        status,
+        statusText,
+        headers: recordedRespHeaders,
+        body: binary ? `base64:${respBodyBuf.toString("base64")}` : respBodyBuf.toString("utf8"),
+        binary,
+        bodySize: respBodyBuf.length
+      }
+    };
+    activeEntries.push(entry);
+    hitCallback?.(entry);
+    const clientHeaders = {};
+    upstreamResp.headers.forEach((v, k) => {
+      const lk = k.toLowerCase();
+      if (!HOP_BY_HOP.has(lk) && lk !== "content-encoding") clientHeaders[k] = v;
+    });
+    clientHeaders["content-length"] = String(respBodyBuf.length);
+    res.writeHead(status, clientHeaders);
+    res.end(respBodyBuf);
+  });
+  await new Promise((ok, fail) => {
+    server.once("error", fail);
+    server.listen(config.port, "0.0.0.0", ok);
+  });
+  activeServer = server;
+}
+function stopRecorder() {
+  if (!activeServer) throw new Error("Recorder is not running");
+  activeServer.close();
+  activeServer = null;
+  const session = {
+    version: "1.0",
+    upstream: activeConfig?.upstream ?? "",
+    port: activeConfig?.port ?? 0,
+    startedAt: activeStarted,
+    maskedHeaders: [...activeMaskSet],
+    entries: activeEntries
+  };
+  activeConfig = null;
+  activeEntries = [];
+  return session;
+}
+function entriesToMockServer(entries, upstream, name, port) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const key = `${e.request.method}:${e.request.path}`;
+    const existing = seen.get(key);
+    const isSuccess = e.response.status >= 200 && e.response.status < 300;
+    const existingIsSuccess = existing && existing.response.status >= 200 && existing.response.status < 300;
+    if (!existing || !existingIsSuccess && isSuccess || !existingIsSuccess && !isSuccess) seen.set(key, e);
+  }
+  const routes = [];
+  for (const e of seen.values()) {
+    const respHeaders = {};
+    for (const [k, v] of Object.entries(e.response.headers)) {
+      if (!STRIP_FROM_MOCK_RESPONSE.has(k.toLowerCase())) respHeaders[k] = v;
+    }
+    routes.push({
+      id: crypto.randomUUID(),
+      method: e.request.method,
+      path: e.request.path,
+      statusCode: e.response.status,
+      headers: respHeaders,
+      body: e.response.binary ? `[binary — recorded from ${upstream}${e.request.path}]` : e.response.body ?? "",
+      description: `Recorded from ${upstream} at ${e.timestamp}`
+    });
+  }
+  return { version: "1.0", id: crypto.randomUUID(), name, port, routes };
+}
+function readBody(req) {
+  return new Promise((ok, fail) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => ok(Buffer.concat(chunks)));
+    req.on("error", fail);
+  });
+}
+function parseQuery(search) {
+  const q = {};
+  new URLSearchParams(search).forEach((v, k) => {
+    q[k] = v;
+  });
+  return q;
+}
+function isBinary(contentType) {
+  const ct = contentType.toLowerCase();
+  return ct.startsWith("image/") || ct.startsWith("audio/") || ct.startsWith("video/") || ct.includes("octet-stream") || ct.includes("application/pdf") || ct.includes("application/zip") || ct.includes("application/gzip") || ct.includes("font/");
+}
+exports.entriesToMockServer = entriesToMockServer;
+exports.getRecorderEntries = getRecorderEntries;
+exports.isRecorderRunning = isRecorderRunning;
+exports.setRecorderHitCallback = setRecorderHitCallback;
+exports.startRecorder = startRecorder;
+exports.stopRecorder = stopRecorder;

package/out/main/index.js

@@ -36,6 +36,7 @@ const WebSocket = require("ws");
 const https = require("https");
 const Ajv = require("ajv");
 const simpleGit = require("simple-git");
+const recorder = require("./chunks/recorder-DFxJgn9c.js");
 require("crypto");
 require("dayjs");
 require("vm");
@@ -2398,8 +2399,56 @@ function registerRunnerHandler(ipc) {
     let runEnvVars = { ...envVars };
     let runCollectionVars = {};
     let runGlobals = { ...globals };
+    const failedScopes = /* @__PURE__ */ new Set();
+    const skipRequests = /* @__PURE__ */ new Set();
     for (const item of items) {
-      const runningUpdate = { status: "running", iterationLabel: item.iterationLabel };
+      const { isHook, hookType, scopeId, scopeAncestors, mainRequestId } = item;
+      let skipReason;
+      if (isHook) {
+        if (hookType === "beforeAll") {
+          if ((scopeAncestors ?? []).some((id) => failedScopes.has(id))) {
+            skipReason = "Skipped — outer scope hook failed";
+          }
+        } else if (hookType === "before") {
+          const allScopes = [...scopeAncestors ?? [], scopeId].filter(Boolean);
+          if (allScopes.some((id) => failedScopes.has(id))) {
+            skipReason = "Skipped — scope hook failed";
+          } else if (mainRequestId && skipRequests.has(mainRequestId)) {
+            skipReason = "Skipped — before hook failed";
+          }
+        }
+      } else {
+        const allScopes = [...item.scopeAncestors ?? [], item.scopeId].filter(Boolean);
+        if (allScopes.some((id) => failedScopes.has(id))) {
+          skipReason = "Skipped — beforeAll hook failed";
+        } else if (skipRequests.has(item.request.id)) {
+          skipReason = "Skipped — before hook failed";
+        }
+      }
+      if (skipReason) {
+        const skipped = {
+          requestId: item.request.id,
+          name: item.request.name,
+          method: item.request.method,
+          resolvedUrl: item.request.url,
+          status: "failed",
+          error: skipReason,
+          isHook: item.isHook,
+          hookType: item.hookType,
+          scopeId: item.scopeId,
+          iterationLabel: item.iterationLabel
+        };
+        summary.failed++;
+        event.sender.send("runner:progress", skipped);
+        continue;
+      }
+      const runningUpdate = {
+        status: "running",
+        iterationLabel: item.iterationLabel,
+        isHook: item.isHook,
+        hookType: item.hookType,
+        scopeId: item.scopeId
+      };
       event.sender.send("runner:progress", { requestId: item.request.id, ...runningUpdate });
       const { result, updatedEnvVars, updatedCollectionVars, updatedGlobals } = await executeOne(
         item.request,
@@ -2413,10 +2462,23 @@ function registerRunnerHandler(ipc) {
       runEnvVars = updatedEnvVars;
       runCollectionVars = updatedCollectionVars;
       runGlobals = updatedGlobals;
+      if (isHook && result.status !== "passed") {
+        if (hookType === "beforeAll" && scopeId) {
+          failedScopes.add(scopeId);
+        } else if (hookType === "before" && mainRequestId) {
+          skipRequests.add(mainRequestId);
+        }
+      }
       if (result.status === "passed") summary.passed++;
       else if (result.status === "failed") summary.failed++;
       else summary.errors++;
-      event.sender.send("runner:progress", { ...result, iterationLabel: item.iterationLabel });
+      event.sender.send("runner:progress", {
+        ...result,
+        iterationLabel: item.iterationLabel,
+        isHook: item.isHook,
+        hookType: item.hookType,
+        scopeId: item.scopeId
+      });
       if (requestDelay > 0 && item !== items[items.length - 1]) {
         await sleep(requestDelay);
       }
@@ -3460,12 +3522,26 @@ function registerGitHandlers(ipc) {
       staged: result.staged.map((f) => ({ path: f, status: resolveStatus(result, f, true) })),
       unstaged: result.modified.filter((f) => !result.staged.includes(f)).concat(result.deleted.filter((f) => !result.staged.includes(f))).map((f) => ({ path: f, status: resolveStatus(result, f, false) })),
       untracked: result.not_added.map((f) => ({ path: f, status: "untracked" })),
+      conflicted: result.conflicted,
       branch: result.current ?? "",
       ahead: result.ahead,
       behind: result.behind,
       remote: result.tracking ?? null
     };
   });
+  ipc.handle("git:resolveOurs", async (_e, filePath) => {
+    const g = git();
+    await g.checkout(["--ours", "--", filePath]);
+    await g.add([filePath]);
+  });
+  ipc.handle("git:resolveTheirs", async (_e, filePath) => {
+    const g = git();
+    await g.checkout(["--theirs", "--", filePath]);
+    await g.add([filePath]);
+  });
+  ipc.handle("git:markResolved", async (_e, filePath) => {
+    await git().add([filePath]);
+  });
   ipc.handle("git:diff", async (_e, filePath) => {
     if (filePath) return git().diff(["--", filePath]);
     return git().diff();
@@ -3551,6 +3627,24 @@ function resolveStatus(result, filePath, staged) {
   if (result.deleted.includes(filePath)) return "deleted";
   return "modified";
 }
+function registerRecordHandlers(ipc, getWebContents) {
+  ipc.handle("record:start", async (_e, config) => {
+    await recorder.startRecorder(config);
+    recorder.setRecorderHitCallback((entry) => {
+      getWebContents()?.send("record:hit", entry);
+    });
+  });
+  ipc.handle("record:stop", async () => {
+    const session = recorder.stopRecorder();
+    recorder.setRecorderHitCallback(null);
+    return session;
+  });
+  ipc.handle("record:isRunning", () => recorder.isRecorderRunning());
+  ipc.handle("record:entries", () => recorder.getRecorderEntries());
+  ipc.handle("record:toMock", (_e, entries, upstream, name, port) => {
+    return recorder.entriesToMockServer(entries, upstream, name, port);
+  });
+}
 if (process.env.ELECTRON_NO_SANDBOX === "1") {
   electron.app.commandLine.appendSwitch("no-sandbox");
   electron.app.commandLine.appendSwitch("disable-features", "RendererCodeIntegrity");
@@ -3652,6 +3746,8 @@ electron.app.whenReady().then(async () => {
   registerDocsHandlers(electron.ipcMain);
   registerContractHandlers(electron.ipcMain);
   registerGitHandlers(electron.ipcMain);
+  registerRecordHandlers(electron.ipcMain, () => electron.BrowserWindow.getAllWindows()[0]?.webContents ?? null);
+  electron.ipcMain.handle("shell:openExternal", (_e, url) => electron.shell.openExternal(url));
   createWindow();
   electron.app.on("activate", () => {
     if (electron.BrowserWindow.getAllWindows().length === 0) createWindow();

package/out/main/record.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+"use strict";
+const promises = require("fs/promises");
+const path = require("path");
+const recorder = require("./chunks/recorder-DFxJgn9c.js");
+require("http");
+require("crypto");
+require("undici");
+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 methodBadge(method) {
+  const m = method.toUpperCase();
+  const c = m === "GET" ? C.green : m === "POST" ? C.cyan : m === "PUT" || m === "PATCH" ? C.yellow : m === "DELETE" ? C.red : C.white;
+  return color(m.padEnd(7), c, C.bold);
+}
+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 === "mask" || key === "ignore") {
+        const existing = args[key];
+        args[key] = Array.isArray(existing) ? [...existing, next] : [next];
+      } else {
+        args[key] = next;
+      }
+      i++;
+    }
+  }
+  return args;
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    console.log(
+      "\nUsage:\n  api-spector record --upstream <url> [options]\n\nOptions:\n  --upstream <url>    Real API base URL (required)\n  --port <n>          Local port (default: 4001)\n  --output <path>     Output directory (default: ./recordings)\n  --mask <header>     Mask header value with *** (repeatable)\n  --ignore <header>   Omit header from recordings (repeatable)\n"
+    );
+    process.exit(0);
+  }
+  const upstream = args.upstream?.replace(/\/$/, "");
+  if (!upstream) {
+    console.error(color("Error: --upstream <url> is required", C.red));
+    process.exit(1);
+  }
+  const port = parseInt(args.port ?? "4001", 10);
+  const outputDir = path.resolve(args.output ?? "./recordings");
+  const extraMask = Array.isArray(args.mask) ? args.mask : args.mask ? [args.mask] : [];
+  const extraIgnore = Array.isArray(args.ignore) ? args.ignore : args.ignore ? [args.ignore] : [];
+  recorder.setRecorderHitCallback((entry) => {
+    const { method, path: path2 } = entry.request;
+    const { status, binary } = entry.response;
+    const sc = status < 300 ? C.green : status < 400 ? C.cyan : C.red;
+    const st = status > 0 ? color(String(status), sc, C.bold) : color("ERR", C.red, C.bold);
+    const bin = binary ? color(" [binary]", C.yellow) : "";
+    console.log(`  ${methodBadge(method)} ${color(path2, C.white)}  ${st}  ${color(`${entry.durationMs}ms`, C.gray)}${bin}`);
+  });
+  await recorder.startRecorder({ upstream, port, maskHeaders: extraMask, ignoreHeaders: extraIgnore });
+  console.log("");
+  console.log(color("  API Spector — Record Proxy", C.bold, C.white));
+  console.log(color(`  Upstream:  ${upstream}`, C.gray));
+  console.log(color(`  Listening: http://localhost:${port}`, C.cyan));
+  console.log(color(`  Output:    ${outputDir}`, C.gray));
+  console.log(color("  Press Ctrl+C to stop and save recordings.\n", C.dim));
+  async function shutdown() {
+    console.log("");
+    const session = recorder.stopRecorder();
+    recorder.setRecorderHitCallback(null);
+    if (session.entries.length === 0) {
+      console.log(color("  No requests recorded.", C.yellow));
+      process.exit(0);
+    }
+    await promises.mkdir(outputDir, { recursive: true });
+    const slug = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const sessionPath = path.join(outputDir, `session-${slug}.recording.json`);
+    await promises.writeFile(sessionPath, JSON.stringify(session, null, 2), "utf8");
+    const mockName = `Recorded — ${new URL(upstream).hostname} ${slug}`;
+    const mockServer = recorder.entriesToMockServer(session.entries, upstream, mockName, port);
+    const mockPath = path.join(outputDir, `session-${slug}.mock.json`);
+    await promises.writeFile(mockPath, JSON.stringify(mockServer, null, 2), "utf8");
+    console.log(color(`  Recorded ${session.entries.length} request${session.entries.length !== 1 ? "s" : ""}.`, C.green, C.bold));
+    console.log(color(`  Session:    ${sessionPath}`, C.gray));
+    console.log(color(`  Mock stubs: ${mockPath}`, C.gray));
+    console.log("");
+    process.exit(0);
+  }
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((err) => {
+  console.error(color(`Fatal: ${err instanceof Error ? err.message : String(err)}`, "\x1B[31m"));
+  process.exit(2);
+});

package/out/main/runner.js

@@ -22,6 +22,8 @@ function buildJsonReport(results, summary, meta = {}) {
       method: r.method,
       url: r.resolvedUrl,
       status: r.status,
+      isHook: r.isHook ?? false,
+      hookType: r.hookType ?? null,
       httpStatus: r.httpStatus ?? null,
       durationMs: r.durationMs ?? null,
       iterationLabel: r.iterationLabel ?? null,
@@ -54,11 +56,18 @@ function buildHtmlReport(results, summary, meta = {}) {
   const collection = meta.collection ?? "API Tests";
   const env = meta.environment ?? "—";
   const passRate = summary.total > 0 ? Math.round(summary.passed / summary.total * 100) : 0;
+  const HOOK_LABELS = {
+    beforeAll: "BEFORE ALL",
+    before: "BEFORE",
+    after: "AFTER",
+    afterAll: "AFTER ALL"
+  };
   const cards = results.map((r, idx) => {
     const statusCls = r.status === "passed" ? "badge-pass" : r.status === "failed" ? "badge-fail" : "badge-err";
     const httpCls = r.httpStatus && r.httpStatus < 300 ? "http-ok" : r.httpStatus && r.httpStatus < 400 ? "http-redir" : "http-err";
     const dur = r.durationMs != null ? `${r.durationMs} ms` : "—";
     const label = r.iterationLabel ? ` <span class="muted">#${esc(r.iterationLabel)}</span>` : "";
+    const hookLabel = r.isHook && r.hookType ? HOOK_LABELS[r.hookType] ?? r.hookType.toUpperCase() : null;
     const testRows = (r.testResults ?? []).map(
       (t) => `<div class="test-row ${t.passed ? "test-pass" : "test-fail"}">
         <span class="dot">${t.passed ? "✓" : "✗"}</span> ${esc(t.name)}
@@ -91,12 +100,13 @@ function buildHtmlReport(results, summary, meta = {}) {
         ${headersTable(resp.headers)}
         ${resp.body ? `<div class="section-label">Body</div><pre class="code-block">${prettyJson(resp.body)}</pre>` : ""}
       </div>` : "";
+    const hookCls = hookLabel ? r.hookType?.startsWith("before") ? "card-hook-before" : "card-hook-after" : "";
     return `
-    <div class="card" id="r${idx}">
+    <div class="card ${hookCls}" id="r${idx}">
       <div class="card-header" onclick="toggle(${idx})">
         <span class="chevron" id="ch${idx}">▶</span>
         <span class="badge ${statusCls}">${r.status}</span>
-        <span class="method mono">${esc(r.method)}</span>
+        ${hookLabel ? `<span class="hook-badge ${r.hookType?.startsWith("before") ? "hook-before" : "hook-after"}">${hookLabel}</span>` : `<span class="method mono">${esc(r.method)}</span>`}
         <span class="card-name">${esc(r.name)}${label}</span>
         <span class="card-url muted">${esc(r.resolvedUrl ?? "")}</span>
         <span class="dur muted">${dur}</span>
@@ -177,6 +187,16 @@ function buildHtmlReport(results, summary, meta = {}) {
   .dot { font-weight: 700; }
   /* Console */
   .err-row { color: #f85149; font-size: 12px; }
+  /* Footer */
+  .report-footer { margin-top: 32px; text-align: center; font-size: 11px; color: #484f58; }
+  .footer-link { color: #3d7fb2; text-decoration: none; }
+  .footer-link:hover { text-decoration: underline; }
+  /* Hook cards */
+  .card-hook-before { border-left: 3px solid #7c3aed; }
+  .card-hook-after  { border-left: 3px solid #0e7490; }
+  .hook-badge { display: inline-block; padding: 1px 7px; border-radius: 10px; font-size: 10px; font-weight: 700; white-space: nowrap; letter-spacing: .04em; }
+  .hook-before { background: #4c1d95; color: #c4b5fd; }
+  .hook-after  { background: #164e63; color: #67e8f9; }
 </style>
 </head>
 <body>
@@ -192,6 +212,7 @@ function buildHtmlReport(results, summary, meta = {}) {
     <div class="stat"><div class="stat-val">${summary.durationMs} ms</div><div class="stat-lbl">Duration</div></div>
   </div>
   <div class="cards">${cards}</div>
+  <div class="report-footer">Generated by <a href="https://testsmith.io" target="_blank" rel="noopener" class="footer-link">Testsmith</a> · api Spector</div>
 </div>
 <script>
   function toggle(i) {
@@ -211,9 +232,16 @@ function buildJUnitReport(results, summary, meta = {}) {
   const suiteName = esc(meta.collection ?? "API Tests");
   const totalSec = (summary.durationMs / 1e3).toFixed(3);
   const ts = meta.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  const HOOK_JUNIT_LABELS = {
+    beforeAll: "Hook: Before All",
+    before: "Hook: Before",
+    after: "Hook: After",
+    afterAll: "Hook: After All"
+  };
   const cases = results.map((r) => {
     const label = r.iterationLabel ? ` #${r.iterationLabel}` : "";
-    const name = esc(r.name + label);
+    const hookPrefix = r.isHook && r.hookType ? `[${HOOK_JUNIT_LABELS[r.hookType] ?? "Hook"}] ` : "";
+    const name = esc(hookPrefix + r.name + label);
     const classname = esc(`${r.method} ${r.resolvedUrl}`);
     const timeSec = ((r.durationMs ?? 0) / 1e3).toFixed(3);
     const failures = [];
@@ -251,7 +279,7 @@ function collectTagged(folder, requests, collectionVars, filterTags) {
   const results = [];
   for (const reqId of folder.requestIds) {
     const req = requests[reqId];
-    if (!req) continue;
+    if (!req || req.hookType) continue;
     const tags = req.meta?.tags ?? [];
     if (filterTags.length > 0 && !filterTags.some((t) => tags.includes(t))) continue;
     results.push({ request: req, collectionVars });

package/out/preload/index.js

@@ -101,6 +101,23 @@ const api = {
   gitSetRemoteUrl: (name, url) => electron.ipcRenderer.invoke("git:setRemoteUrl", name, url),
   gitRemoveRemote: (name) => electron.ipcRenderer.invoke("git:removeRemote", name),
   gitWriteCiFile: (relPath, content) => electron.ipcRenderer.invoke("git:writeCiFile", relPath, content),
+  gitResolveOurs: (filePath) => electron.ipcRenderer.invoke("git:resolveOurs", filePath),
+  gitResolveTheirs: (filePath) => electron.ipcRenderer.invoke("git:resolveTheirs", filePath),
+  gitMarkResolved: (filePath) => electron.ipcRenderer.invoke("git:markResolved", filePath),
+  // ─── Recorder ─────────────────────────────────────────────────────────────
+  recordStart: (config) => electron.ipcRenderer.invoke("record:start", config),
+  recordStop: () => electron.ipcRenderer.invoke("record:stop"),
+  recordIsRunning: () => electron.ipcRenderer.invoke("record:isRunning"),
+  recordEntries: () => electron.ipcRenderer.invoke("record:entries"),
+  recordToMock: (entries, upstream, name, port) => electron.ipcRenderer.invoke("record:toMock", entries, upstream, name, port),
+  onRecordHit: (cb) => {
+    electron.ipcRenderer.on("record:hit", (_e, entry) => cb(entry));
+  },
+  offRecordHit: () => {
+    electron.ipcRenderer.removeAllListeners("record:hit");
+  },
+  // ─── Shell ────────────────────────────────────────────────────────────────
+  openExternal: (url) => electron.ipcRenderer.invoke("shell:openExternal", url),
   // ─── Zoom ─────────────────────────────────────────────────────────────────
   setZoomFactor: (factor) => electron.webFrame.setZoomFactor(factor),
   // ─── Platform ─────────────────────────────────────────────────────────────