@testsmith/api-spector 0.0.8 → 0.1.0

package/bin/cli.js

@@ -3,7 +3,6 @@
 
 const path = require('path')
 const { spawn } = require('child_process')
-const electron = require('electron')
 
 const [, , cmd = 'ui', ...rest] = process.argv
 
@@ -20,14 +19,19 @@ function printHelp() {
   console.log('    api-spector run  --help                   Show run options')
   console.log('    api-spector mock --help                   Show mock options')
   console.log('')
+  console.log('  Environment:')
+  console.log('    ELECTRON_NO_SANDBOX=1                     Disable Chromium sandbox')
+  console.log('                                              (needed on locked-down Linux)')
+  console.log('')
 }
 
 if (cmd === '--help' || cmd === '-h') {
   printHelp()
   process.exit(0)
 } else if (cmd === 'ui') {
+  const electron = require('electron')
   const appDir = path.join(__dirname, '..')
-  const proc = spawn(String(electron), [appDir], {
+  const proc = spawn(String(electron), [appDir, ...rest], {
     stdio: 'inherit',
     env: process.env,
   })

package/out/main/chunks/mock-server-Cx-xG4pJ.js

@@ -0,0 +1,245 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+const http = require("http");
+const crypto = require("crypto");
+const vm = require("vm");
+const dayjs = require("dayjs");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const vm__namespace = /* @__PURE__ */ _interopNamespaceDefault(vm);
+let _fakerCache = null;
+async function getFaker() {
+  if (!_fakerCache) _fakerCache = await import("@faker-js/faker");
+  return _fakerCache.faker;
+}
+const running = /* @__PURE__ */ new Map();
+const liveRoutes = /* @__PURE__ */ new Map();
+let hitCallback = null;
+function setHitCallback(cb) {
+  hitCallback = cb;
+}
+function updateMockRoutes(id, routes) {
+  liveRoutes.set(id, routes);
+}
+function matchPath(pattern, urlPath) {
+  const regexStr = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/:[^/]+/g, "[^/]+");
+  try {
+    const regex = new RegExp("^" + regexStr + "/?$");
+    return regex.test(urlPath.split("?")[0]);
+  } catch {
+    return false;
+  }
+}
+function findRoute(routes, method, urlPath) {
+  const path = urlPath.split("?")[0];
+  return routes.find((r) => r.method === method && matchPath(r.path, path)) ?? routes.find((r) => r.method === "ANY" && matchPath(r.path, path)) ?? null;
+}
+function extractPathParams(pattern, urlPath) {
+  const params = {};
+  const patParts = pattern.split("/");
+  const urlParts = urlPath.split("?")[0].split("/");
+  patParts.forEach((part, i) => {
+    if (part.startsWith(":")) {
+      params[part.slice(1)] = decodeURIComponent(urlParts[i] ?? "");
+    }
+  });
+  return params;
+}
+function extractQueryParams(url) {
+  const params = {};
+  const qs = url.split("?")[1];
+  if (qs) new URLSearchParams(qs).forEach((v, k) => {
+    params[k] = v;
+  });
+  return params;
+}
+function readBody(req) {
+  return new Promise((resolve) => {
+    let data = "";
+    req.on("data", (chunk) => {
+      data += chunk.toString();
+    });
+    req.on("end", () => resolve(data));
+    req.on("error", () => resolve(""));
+  });
+}
+function interpolateMockBody(body, context) {
+  return body.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
+    const expr = key.trim();
+    if (expr.includes(".") || expr.includes("(")) {
+      try {
+        const result = vm__namespace.runInNewContext(expr, context);
+        if (result !== void 0 && result !== null) return String(result);
+      } catch {
+      }
+    }
+    return match;
+  });
+}
+async function handleRequest(serverId, req, res, reqStart) {
+  const method = (req.method ?? "GET").toUpperCase();
+  const urlPath = req.url ?? "/";
+  if (urlPath === "/favicon.ico") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+  const bodyRaw = await readBody(req);
+  let bodyParsed = {};
+  try {
+    bodyParsed = JSON.parse(bodyRaw);
+  } catch {
+  }
+  const routes = liveRoutes.get(serverId) ?? [];
+  const route = findRoute(routes, method, urlPath);
+  if (!route) {
+    const notFoundBody = JSON.stringify({ error: "No matching mock route", method, path: urlPath });
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(notFoundBody);
+    hitCallback?.({
+      id: crypto.randomUUID(),
+      serverId,
+      timestamp: reqStart,
+      method,
+      path: urlPath,
+      matchedRouteId: null,
+      status: 404,
+      durationMs: Date.now() - reqStart,
+      responseBody: notFoundBody,
+      responseHeaders: { "Content-Type": "application/json" }
+    });
+    return;
+  }
+  const reqHeaders = {};
+  Object.entries(req.headers).forEach(([k, v]) => {
+    if (v !== void 0) reqHeaders[k] = Array.isArray(v) ? v.join(", ") : v;
+  });
+  const requestCtx = {
+    method,
+    path: urlPath.split("?")[0],
+    params: extractPathParams(route.path, urlPath),
+    query: extractQueryParams(urlPath),
+    body: bodyParsed,
+    bodyRaw,
+    headers: reqHeaders
+  };
+  const responseDraft = {
+    statusCode: route.statusCode,
+    body: route.body,
+    headers: { "Content-Type": "application/json", ...route.headers }
+  };
+  if (route.script?.trim()) {
+    try {
+      const faker2 = await getFaker();
+      vm__namespace.runInNewContext(route.script, {
+        request: requestCtx,
+        response: responseDraft,
+        faker: faker2,
+        dayjs,
+        console: { log: (...args) => console.log("[mock-script]", ...args) }
+      });
+    } catch (err) {
+      console.error("[mock-script error]", err);
+    }
+  }
+  const faker = await getFaker();
+  const exprCtx = { request: requestCtx, faker, dayjs };
+  const finalBody = interpolateMockBody(responseDraft.body, exprCtx);
+  const respond = () => {
+    res.writeHead(responseDraft.statusCode, responseDraft.headers);
+    res.end(finalBody);
+    hitCallback?.({
+      id: crypto.randomUUID(),
+      serverId,
+      timestamp: reqStart,
+      method,
+      path: urlPath,
+      matchedRouteId: route.id,
+      status: responseDraft.statusCode,
+      durationMs: Date.now() - reqStart,
+      responseBody: finalBody,
+      responseHeaders: responseDraft.headers
+    });
+  };
+  if (route.delay && route.delay > 0) setTimeout(respond, route.delay);
+  else respond();
+}
+async function startMock(server) {
+  if (running.has(server.id)) await stopMock(server.id);
+  liveRoutes.set(server.id, server.routes ?? []);
+  const httpServer = http.createServer((req, res) => {
+    const reqStart = Date.now();
+    handleRequest(server.id, req, res, reqStart).catch((err) => {
+      console.error("[mock-handler uncaught]", err);
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Mock handler error", message: String(err) }));
+      }
+    });
+  });
+  await new Promise((resolve, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(server.port, "127.0.0.1", resolve);
+  });
+  running.set(server.id, httpServer);
+}
+async function stopMock(id) {
+  const srv = running.get(id);
+  if (!srv) return;
+  await new Promise(
+    (resolve, reject) => srv.close((err) => err ? reject(err) : resolve())
+  );
+  running.delete(id);
+  liveRoutes.delete(id);
+}
+function isRunning(id) {
+  return running.has(id);
+}
+function getRunningIds() {
+  return [...running.keys()];
+}
+async function stopAll() {
+  await Promise.all([...running.keys()].map(stopMock));
+}
+exports.getRunningIds = getRunningIds;
+exports.isRunning = isRunning;
+exports.setHitCallback = setHitCallback;
+exports.startMock = startMock;
+exports.stopAll = stopAll;
+exports.stopMock = stopMock;
+exports.updateMockRoutes = updateMockRoutes;

package/out/main/chunks/{request-handler-C1b53aHR.js → request-handler-9MdHOWVf.js}

@@ -25,8 +25,8 @@ const undici = require("undici");
 const promises = require("fs/promises");
 const crypto = require("crypto");
 const path = require("path");
-const vm = require("vm");
 const dayjs = require("dayjs");
+const vm = require("vm");
 const tv4 = require("tv4");
 const jsonpathPlus = require("jsonpath-plus");
 const xmldom = require("@xmldom/xmldom");
@@ -140,8 +140,49 @@ async function getSecret(ref) {
   }
   return process.env[ref] ?? null;
 }
+let _fakerCache$1 = null;
+async function getFaker$1() {
+  if (!_fakerCache$1) _fakerCache$1 = await import("@faker-js/faker");
+  return _fakerCache$1.faker;
+}
+let _exprContext = null;
+async function buildDynamicVars() {
+  const faker = await getFaker$1();
+  const now = dayjs();
+  _exprContext = { faker, dayjs };
+  return {
+    $uuid: faker.string.uuid(),
+    $timestamp: String(Date.now()),
+    $isoTimestamp: now.toISOString(),
+    $randomInt: String(faker.number.int({ min: 0, max: 1e3 })),
+    $randomFloat: String(faker.number.float({ min: 0, max: 1e3, fractionDigits: 2 })),
+    $randomBoolean: String(faker.datatype.boolean()),
+    $randomEmail: faker.internet.email(),
+    $randomUsername: faker.internet.username(),
+    $randomPassword: faker.internet.password(),
+    $randomFullName: faker.person.fullName(),
+    $randomFirstName: faker.person.firstName(),
+    $randomLastName: faker.person.lastName(),
+    $randomWord: faker.lorem.word(),
+    $randomPhrase: faker.lorem.sentence(),
+    $randomUrl: faker.internet.url(),
+    $randomIp: faker.internet.ip(),
+    $randomHexColor: faker.color.rgb({ format: "hex", casing: "lower" })
+  };
+}
 function interpolate(str, vars) {
-  return str.replace(/\{\{([^}]+)\}\}/g, (_, key) => vars[key.trim()] ?? `{{${key}}}`);
+  return str.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
+    const trimmed = key.trim();
+    if (trimmed in vars) return vars[trimmed];
+    if (_exprContext && (trimmed.includes(".") || trimmed.includes("("))) {
+      try {
+        const result = vm__namespace.runInNewContext(trimmed, _exprContext);
+        if (result !== void 0 && result !== null) return String(result);
+      } catch {
+      }
+    }
+    return match;
+  });
 }
 function buildUrl(baseUrl, params, vars) {
   const url = interpolate(baseUrl, vars);
@@ -173,8 +214,8 @@ async function buildEnvVars(environment) {
   }
   return vars;
 }
-function mergeVars(envVars, collectionVars, globals2, localVars = {}) {
-  return { ...globals2, ...collectionVars, ...envVars, ...localVars };
+function mergeVars(envVars, collectionVars, globals2, localVars = {}, dynamicVars = {}) {
+  return { ...dynamicVars, ...globals2, ...collectionVars, ...envVars, ...localVars };
 }
 function xmlFindAll(node, tag, nth) {
   const results = [];
@@ -753,7 +794,8 @@ function registerRequestHandler(ipc) {
         }
       }
     }
-    let vars = mergeVars(envVars, collectionVars, mergedGlobals, localVars);
+    const dynamicVars = await buildDynamicVars();
+    let vars = mergeVars(envVars, collectionVars, mergedGlobals, localVars, dynamicVars);
     let preScriptMeta = { consoleOutput: [] };
     let updatedCollectionVars = { ...collectionVars };
     let updatedEnvVars = { ...envVars };
@@ -772,7 +814,7 @@ function registerRequestHandler(ipc) {
       updatedGlobals = result.updatedGlobals;
       patchGlobals(result.updatedGlobals);
       await persistGlobals();
-      vars = mergeVars(updatedEnvVars, updatedCollectionVars, updatedGlobals, localVars);
+      vars = mergeVars(updatedEnvVars, updatedCollectionVars, updatedGlobals, localVars, dynamicVars);
     }
     let response;
     let sentRequest = { method: req.method, url: "", headers: {} };
@@ -961,9 +1003,23 @@ function registerRequestHandler(ipc) {
     };
     return { response, scriptResult, sentRequest: redactSentRequest(sentRequest) };
   });
+  ipc.handle("script:run-hook", async (_e, payload) => {
+    const { script, envVars, collectionVars, globals: globals2 } = payload;
+    const result = await runScript(script, { envVars, collectionVars, globals: globals2, localVars: {} });
+    patchGlobals(result.updatedGlobals);
+    await persistGlobals();
+    return {
+      updatedEnvVars: result.updatedEnvVars,
+      updatedCollectionVars: result.updatedCollectionVars,
+      updatedGlobals: result.updatedGlobals,
+      consoleOutput: result.consoleOutput,
+      error: result.error
+    };
+  });
 }
 exports.buildAuthHeaders = buildAuthHeaders;
 exports.buildDispatcher = buildDispatcher;
+exports.buildDynamicVars = buildDynamicVars;
 exports.buildEnvVars = buildEnvVars;
 exports.buildUrl = buildUrl;
 exports.fetchOAuth2Token = fetchOAuth2Token;

package/out/main/index.js

@@ -25,19 +25,19 @@ const electron = require("electron");
 const path = require("path");
 const fs = require("fs");
 const promises = require("fs/promises");
-const requestHandler = require("./chunks/request-handler-C1b53aHR.js");
+const requestHandler = require("./chunks/request-handler-9MdHOWVf.js");
 const uuid = require("uuid");
 const jsYaml = require("js-yaml");
 const undici = require("undici");
 const JSZip = require("jszip");
-const mockServer = require("./chunks/mock-server-ZB7zpXh9.js");
+const mockServer = require("./chunks/mock-server-Cx-xG4pJ.js");
 const http = require("http");
 const WebSocket = require("ws");
 const https = require("https");
 const Ajv = require("ajv");
 require("crypto");
-require("vm");
 require("dayjs");
+require("vm");
 require("tv4");
 require("jsonpath-plus");
 require("@xmldom/xmldom");
@@ -3436,6 +3436,10 @@ function registerContractHandlers(ipc) {
     return schema ? JSON.stringify(schema, null, 2) : null;
   });
 }
+if (process.env.ELECTRON_NO_SANDBOX === "1") {
+  electron.app.commandLine.appendSwitch("no-sandbox");
+  electron.app.commandLine.appendSwitch("disable-features", "RendererCodeIntegrity");
+}
 function createSplashWindow() {
   const splash = new electron.BrowserWindow({
     width: 420,

package/out/main/mock.js

@@ -2,9 +2,11 @@
 "use strict";
 const promises = require("fs/promises");
 const path = require("path");
-const mockServer = require("./chunks/mock-server-ZB7zpXh9.js");
+const mockServer = require("./chunks/mock-server-Cx-xG4pJ.js");
 require("http");
 require("crypto");
+require("vm");
+require("dayjs");
 const C = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -39,9 +41,18 @@ function parseArgs(argv) {
   }
   return args;
 }
+async function resolveWorkspacePath(wsPath) {
+  const s = await promises.stat(wsPath);
+  if (!s.isDirectory()) return wsPath;
+  const entries = await promises.readdir(wsPath);
+  const spector = entries.find((e) => e.endsWith(".spector"));
+  if (!spector) throw new Error(`No .spector workspace file found in directory: ${wsPath}`);
+  return path.join(wsPath, spector);
+}
 async function loadWorkspace(wsPath) {
-  const raw = await promises.readFile(wsPath, "utf8");
-  return { workspace: JSON.parse(raw), dir: path.dirname(path.resolve(wsPath)) };
+  const resolved = await resolveWorkspacePath(wsPath);
+  const raw = await promises.readFile(resolved, "utf8");
+  return { workspace: JSON.parse(raw), dir: path.dirname(path.resolve(resolved)) };
 }
 async function loadMocks(workspace, dir) {
   const mocks = [];
@@ -59,7 +70,7 @@ 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"
+      "\nUsage:\n  api-spector mock --workspace <path> [--name <server-name>] [--log]\n\nOptions:\n  --workspace <path>   Path to workspace.json (required)\n  --name <name>        Start only the named server (repeat for multiple)\n  --log                Print each incoming request (matched and unmatched)\n  --help               Show this message\n"
     );
     process.exit(0);
   }
@@ -115,6 +126,34 @@ async function main() {
   if (started === 0) {
     process.exit(1);
   }
+  if (args.log) {
+    const serverNames = {};
+    const routePaths = {};
+    for (const mock of toStart) {
+      serverNames[mock.id] = mock.name;
+      for (const route of mock.routes) {
+        routePaths[route.id] = `${route.method} ${route.path}`;
+      }
+    }
+    mockServer.setHitCallback((hit) => {
+      const ts = new Date(hit.timestamp).toISOString().slice(11, 23);
+      const server = color(serverNames[hit.serverId] ?? hit.serverId, C.white);
+      const method = hit.method.padEnd(7);
+      const matched = hit.matchedRouteId !== null;
+      const status = color(String(hit.status), hit.status < 400 ? C.green : C.red);
+      const dur = color(`${hit.durationMs}ms`, C.gray);
+      if (matched) {
+        const route = color(routePaths[hit.matchedRouteId] ?? hit.matchedRouteId, C.gray);
+        console.log(
+          color(`  ${ts}`, C.gray) + `  ${server}  ` + color(method, C.cyan) + color(hit.path, C.white) + `  ${status}  ${dur}` + color(`  → ${route}`, C.gray)
+        );
+      } else {
+        console.log(
+          color(`  ${ts}`, C.gray) + `  ${server}  ` + color(method, C.yellow) + color(hit.path, C.yellow) + `  ${status}  ${dur}` + color("  (no match)", C.yellow)
+        );
+      }
+    });
+  }
   console.log("");
   console.log(color("  Press Ctrl+C to stop all servers.\n", C.gray));
   async function shutdown() {

package/out/main/runner.js

@@ -3,10 +3,10 @@
 const promises = require("fs/promises");
 const path = require("path");
 const undici = require("undici");
-const requestHandler = require("./chunks/request-handler-C1b53aHR.js");
+const requestHandler = require("./chunks/request-handler-9MdHOWVf.js");
 require("crypto");
-require("vm");
 require("dayjs");
+require("vm");
 require("tv4");
 require("jsonpath-plus");
 require("@xmldom/xmldom");
@@ -180,7 +180,8 @@ async function executeRequest(req, collectionVars, envVars, globals, verbose, tl
     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 = requestHandler.mergeVars(updatedEnvVars, updatedCollectionVars, updatedGlobals, localVars);
+  const dynamicVars = await requestHandler.buildDynamicVars();
+  const vars = requestHandler.mergeVars(updatedEnvVars, updatedCollectionVars, updatedGlobals, localVars, dynamicVars);
   const resolvedUrl = requestHandler.buildUrl(req.url, req.params, vars);
   base.resolvedUrl = resolvedUrl;
   const start = Date.now();

package/out/preload/index.js

@@ -79,6 +79,10 @@ const api = {
   // ─── Contract testing ─────────────────────────────────────────────────────
   runContracts: (payload) => electron.ipcRenderer.invoke("contract:run", payload),
   inferContractSchema: (jsonBody) => electron.ipcRenderer.invoke("contract:inferSchema", jsonBody),
+  // ─── Script hooks ─────────────────────────────────────────────────────────
+  runScriptHook: (payload) => electron.ipcRenderer.invoke("script:run-hook", payload),
+  // ─── Zoom ─────────────────────────────────────────────────────────────────
+  setZoomFactor: (factor) => electron.webFrame.setZoomFactor(factor),
   // ─── Platform ─────────────────────────────────────────────────────────────
   platform: process.platform
 };