@testsmith/api-spector 0.0.9 → 0.1.1

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-C0RlwZf_.js → mock-server-Cx-xG4pJ.js}

@@ -128,8 +128,9 @@ async function handleRequest(serverId, req, res, reqStart) {
   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(JSON.stringify({ error: "No matching mock route", method, path: urlPath }));
+    res.end(notFoundBody);
     hitCallback?.({
       id: crypto.randomUUID(),
       serverId,
@@ -138,7 +139,9 @@ async function handleRequest(serverId, req, res, reqStart) {
       path: urlPath,
       matchedRouteId: null,
       status: 404,
-      durationMs: Date.now() - reqStart
+      durationMs: Date.now() - reqStart,
+      responseBody: notFoundBody,
+      responseHeaders: { "Content-Type": "application/json" }
     });
     return;
   }
@@ -188,7 +191,9 @@ async function handleRequest(serverId, req, res, reqStart) {
       path: urlPath,
       matchedRouteId: route.id,
       status: responseDraft.statusCode,
-      durationMs: Date.now() - reqStart
+      durationMs: Date.now() - reqStart,
+      responseBody: finalBody,
+      responseHeaders: responseDraft.headers
     });
   };
   if (route.delay && route.delay > 0) setTimeout(respond, route.delay);

package/out/main/index.js

@@ -30,11 +30,12 @@ const uuid = require("uuid");
 const jsYaml = require("js-yaml");
 const undici = require("undici");
 const JSZip = require("jszip");
-const mockServer = require("./chunks/mock-server-C0RlwZf_.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");
+const simpleGit = require("simple-git");
 require("crypto");
 require("dayjs");
 require("vm");
@@ -86,7 +87,7 @@ function registerFileHandlers(ipc) {
     await requestHandler.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";
+    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);
     const ws = {
       version: "1.0",
@@ -3436,6 +3437,124 @@ function registerContractHandlers(ipc) {
     return schema ? JSON.stringify(schema, null, 2) : null;
   });
 }
+function git() {
+  const dir = getWorkspaceDir();
+  if (!dir) throw new Error("No workspace open");
+  return simpleGit.simpleGit(dir);
+}
+function registerGitHandlers(ipc) {
+  ipc.handle("git:isRepo", async () => {
+    try {
+      await git().revparse(["--git-dir"]);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  ipc.handle("git:init", async () => {
+    await git().init();
+  });
+  ipc.handle("git:status", async () => {
+    const result = await git().status();
+    return {
+      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" })),
+      branch: result.current ?? "",
+      ahead: result.ahead,
+      behind: result.behind,
+      remote: result.tracking ?? null
+    };
+  });
+  ipc.handle("git:diff", async (_e, filePath) => {
+    if (filePath) return git().diff(["--", filePath]);
+    return git().diff();
+  });
+  ipc.handle("git:diffStaged", async (_e, filePath) => {
+    if (filePath) return git().diff(["--cached", "--", filePath]);
+    return git().diff(["--cached"]);
+  });
+  ipc.handle("git:stage", async (_e, paths) => {
+    await git().add(paths);
+  });
+  ipc.handle("git:unstage", async (_e, paths) => {
+    await git().reset(["HEAD", "--", ...paths]);
+  });
+  ipc.handle("git:stageAll", async () => {
+    await git().add(["."]);
+  });
+  ipc.handle("git:commit", async (_e, message) => {
+    await git().commit(message);
+  });
+  ipc.handle("git:log", async (_e, limit = 50) => {
+    const result = await git().log({ maxCount: limit });
+    return result.all.map((c) => ({
+      hash: c.hash,
+      short: c.hash.slice(0, 7),
+      message: c.message,
+      author: c.author_name,
+      email: c.author_email,
+      date: c.date
+    }));
+  });
+  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/")
+    }));
+  });
+  ipc.handle("git:checkout", async (_e, branch, create) => {
+    if (create) await git().checkoutLocalBranch(branch);
+    else await git().checkout(branch);
+  });
+  ipc.handle("git:pull", async () => {
+    await git().pull();
+  });
+  ipc.handle("git:push", async (_e, setUpstream) => {
+    if (setUpstream) {
+      const status = await git().status();
+      await git().push(["--set-upstream", "origin", status.current ?? "main"]);
+    } else {
+      await git().push();
+    }
+  });
+  ipc.handle("git:remotes", async () => {
+    const result = await git().getRemotes(true);
+    return result.map((r) => ({ name: r.name, url: r.refs.fetch || r.refs.push || "" }));
+  });
+  ipc.handle("git:addRemote", async (_e, name, url) => {
+    await git().addRemote(name, url);
+  });
+  ipc.handle("git:setRemoteUrl", async (_e, name, url) => {
+    await git().remote(["set-url", name, url]);
+  });
+  ipc.handle("git:removeRemote", async (_e, name) => {
+    await git().removeRemote(name);
+  });
+  ipc.handle("git:writeCiFile", async (_e, relPath, content) => {
+    const wsDir = getWorkspaceDir();
+    if (!wsDir) throw new Error("No workspace open");
+    const fullPath = path.join(wsDir, relPath);
+    await promises.mkdir(path.dirname(fullPath), { recursive: true });
+    await promises.writeFile(fullPath, content, "utf8");
+  });
+}
+function resolveStatus(result, filePath, staged) {
+  if (staged) {
+    if (result.created.includes(filePath)) return "added";
+    if (result.deleted.includes(filePath)) return "deleted";
+    if (result.renamed.find((r) => r.to === filePath || r.from === filePath)) return "renamed";
+    return "modified";
+  }
+  if (result.deleted.includes(filePath)) return "deleted";
+  return "modified";
+}
+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,
@@ -3532,6 +3651,7 @@ electron.app.whenReady().then(async () => {
   registerSoapHandlers(electron.ipcMain);
   registerDocsHandlers(electron.ipcMain);
   registerContractHandlers(electron.ipcMain);
+  registerGitHandlers(electron.ipcMain);
   createWindow();
   electron.app.on("activate", () => {
     if (electron.BrowserWindow.getAllWindows().length === 0) createWindow();

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-C0RlwZf_.js");
+const mockServer = require("./chunks/mock-server-Cx-xG4pJ.js");
 require("http");
 require("crypto");
 require("vm");
@@ -41,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 = [];
@@ -61,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);
   }
@@ -117,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

@@ -123,9 +123,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 loadCollections(workspace, dir) {
   const cols = [];

package/out/preload/index.js

@@ -81,6 +81,26 @@ const api = {
   inferContractSchema: (jsonBody) => electron.ipcRenderer.invoke("contract:inferSchema", jsonBody),
   // ─── Script hooks ─────────────────────────────────────────────────────────
   runScriptHook: (payload) => electron.ipcRenderer.invoke("script:run-hook", payload),
+  // ─── Git ──────────────────────────────────────────────────────────────────
+  gitIsRepo: () => electron.ipcRenderer.invoke("git:isRepo"),
+  gitInit: () => electron.ipcRenderer.invoke("git:init"),
+  gitStatus: () => electron.ipcRenderer.invoke("git:status"),
+  gitDiff: (filePath) => electron.ipcRenderer.invoke("git:diff", filePath),
+  gitDiffStaged: (filePath) => electron.ipcRenderer.invoke("git:diffStaged", filePath),
+  gitStage: (paths) => electron.ipcRenderer.invoke("git:stage", paths),
+  gitUnstage: (paths) => electron.ipcRenderer.invoke("git:unstage", paths),
+  gitStageAll: () => electron.ipcRenderer.invoke("git:stageAll"),
+  gitCommit: (message) => electron.ipcRenderer.invoke("git:commit", message),
+  gitLog: (limit) => electron.ipcRenderer.invoke("git:log", limit),
+  gitBranches: () => electron.ipcRenderer.invoke("git:branches"),
+  gitCheckout: (branch, create) => electron.ipcRenderer.invoke("git:checkout", branch, create),
+  gitPull: () => electron.ipcRenderer.invoke("git:pull"),
+  gitPush: (setUpstream) => electron.ipcRenderer.invoke("git:push", setUpstream),
+  gitRemotes: () => electron.ipcRenderer.invoke("git:remotes"),
+  gitAddRemote: (name, url) => electron.ipcRenderer.invoke("git:addRemote", name, url),
+  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),
   // ─── Zoom ─────────────────────────────────────────────────────────────────
   setZoomFactor: (factor) => electron.webFrame.setZoomFactor(factor),
   // ─── Platform ─────────────────────────────────────────────────────────────