@testsmith/api-spector 0.1.1 → 0.1.3

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/chunks/{request-handler-9MdHOWVf.js → request-handler-CvqESn11.js}

@@ -208,6 +208,13 @@ async function buildEnvVars(environment) {
         } catch {
         }
       }
+      if (vars[v.key] === void 0 && process.env[v.key] !== void 0) {
+        vars[v.key] = process.env[v.key];
+      }
+    } else if (v.secret) {
+      if (process.env[v.key] !== void 0) {
+        vars[v.key] = process.env[v.key];
+      }
     } else {
       vars[v.key] = v.value;
     }

package/out/main/index.js

@@ -25,7 +25,7 @@ const electron = require("electron");
 const path = require("path");
 const fs = require("fs");
 const promises = require("fs/promises");
-const requestHandler = require("./chunks/request-handler-9MdHOWVf.js");
+const requestHandler = require("./chunks/request-handler-CvqESn11.js");
 const uuid = require("uuid");
 const jsYaml = require("js-yaml");
 const undici = require("undici");
@@ -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");
@@ -3460,12 +3461,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 +3566,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 +3685,7 @@ electron.app.whenReady().then(async () => {
   registerDocsHandlers(electron.ipcMain);
   registerContractHandlers(electron.ipcMain);
   registerGitHandlers(electron.ipcMain);
+  registerRecordHandlers(electron.ipcMain, () => electron.BrowserWindow.getAllWindows()[0]?.webContents ?? null);
   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);
+});