mock-mcp 0.3.0 → 0.5.0

package/dist/shared/index.js

@@ -0,0 +1,310 @@
+import fs from 'fs/promises';
+import fssync from 'fs';
+import os from 'os';
+import path from 'path';
+import crypto from 'crypto';
+import { spawn } from 'child_process';
+import http from 'http';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { createRequire } from 'module';
+
+// src/shared/discovery.ts
+function debugLog(_msg) {
+}
+var __curDirname = (() => {
+  try {
+    const metaUrl = import.meta.url;
+    if (metaUrl && typeof metaUrl === "string" && metaUrl.startsWith("file://")) {
+      return path.dirname(fileURLToPath(metaUrl));
+    }
+  } catch {
+  }
+  return process.cwd();
+})();
+function resolveProjectRoot(startDir = process.cwd()) {
+  let current = path.resolve(startDir);
+  const root = path.parse(current).root;
+  while (current !== root) {
+    const gitPath = path.join(current, ".git");
+    try {
+      const stat = fssync.statSync(gitPath);
+      if (stat.isDirectory() || stat.isFile()) {
+        return current;
+      }
+    } catch {
+    }
+    const pkgPath = path.join(current, "package.json");
+    try {
+      fssync.accessSync(pkgPath, fssync.constants.F_OK);
+      return current;
+    } catch {
+    }
+    current = path.dirname(current);
+  }
+  return path.resolve(startDir);
+}
+function computeProjectId(projectRoot) {
+  const real = fssync.realpathSync(projectRoot);
+  return crypto.createHash("sha256").update(real).digest("hex").slice(0, 16);
+}
+function getCacheDir(override) {
+  if (override) {
+    return override;
+  }
+  const envCacheDir = process.env.MOCK_MCP_CACHE_DIR;
+  if (envCacheDir) {
+    return envCacheDir;
+  }
+  const xdg = process.env.XDG_CACHE_HOME;
+  if (xdg) {
+    return xdg;
+  }
+  if (process.platform === "win32" && process.env.LOCALAPPDATA) {
+    return process.env.LOCALAPPDATA;
+  }
+  const home = os.homedir();
+  if (home) {
+    return path.join(home, ".cache");
+  }
+  return os.tmpdir();
+}
+function getPaths(projectId, cacheDir) {
+  const base = path.join(getCacheDir(cacheDir), "mock-mcp");
+  const registryPath = path.join(base, `${projectId}.json`);
+  const lockPath = path.join(base, `${projectId}.lock`);
+  const ipcPath = process.platform === "win32" ? `\\\\.\\pipe\\mock-mcp-${projectId}` : path.join(base, `${projectId}.sock`);
+  return { base, registryPath, lockPath, ipcPath };
+}
+async function readRegistry(registryPath) {
+  try {
+    const txt = await fs.readFile(registryPath, "utf-8");
+    return JSON.parse(txt);
+  } catch (error) {
+    debugLog(`readRegistry error for ${registryPath}: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
+async function writeRegistry(registryPath, registry) {
+  await fs.writeFile(registryPath, JSON.stringify(registry, null, 2), {
+    encoding: "utf-8",
+    mode: 384
+    // Read/write for owner only
+  });
+}
+async function healthCheck(ipcPath, timeoutMs = 2e3) {
+  return new Promise((resolve) => {
+    const req = http.request(
+      {
+        method: "GET",
+        socketPath: ipcPath,
+        path: "/health",
+        timeout: timeoutMs
+      },
+      (res) => {
+        resolve(res.statusCode === 200);
+      }
+    );
+    req.on("error", () => resolve(false));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(false);
+    });
+    req.end();
+  });
+}
+async function tryAcquireLock(lockPath) {
+  try {
+    const fh = await fs.open(lockPath, "wx");
+    await fh.write(`${process.pid}
+`);
+    return fh;
+  } catch {
+    return null;
+  }
+}
+async function releaseLock(lockPath, fh) {
+  await fh.close();
+  await fs.rm(lockPath).catch(() => {
+  });
+}
+function randomToken() {
+  return crypto.randomBytes(24).toString("base64url");
+}
+function getDaemonEntryPath() {
+  try {
+    const cwdRequire = createRequire(pathToFileURL(path.join(process.cwd(), "index.js")).href);
+    const resolved = cwdRequire.resolve("mock-mcp");
+    const distDir = path.dirname(resolved);
+    const daemonEntry = path.join(distDir, "index.js");
+    if (fssync.existsSync(daemonEntry)) {
+      return daemonEntry;
+    }
+  } catch {
+  }
+  try {
+    const packageRoot = resolveProjectRoot(__curDirname);
+    const distPath = path.join(packageRoot, "dist", "index.js");
+    if (fssync.existsSync(distPath)) {
+      return distPath;
+    }
+  } catch {
+  }
+  if (process.argv[1]) {
+    return process.argv[1];
+  }
+  return path.join(process.cwd(), "dist", "index.js");
+}
+async function ensureDaemonRunning(opts = {}) {
+  const projectRoot = opts.projectRoot ?? resolveProjectRoot();
+  const projectId = computeProjectId(projectRoot);
+  const { base, registryPath, lockPath, ipcPath } = getPaths(
+    projectId,
+    opts.cacheDir
+  );
+  const timeoutMs = opts.timeoutMs ?? 1e4;
+  await fs.mkdir(base, { recursive: true });
+  const existing = await readRegistry(registryPath);
+  debugLog(`Registry read result: ${existing ? "Found (PID " + existing.pid + ")" : "Null"}`);
+  if (existing) {
+    let healthy = false;
+    for (let i = 0; i < 3; i++) {
+      debugLog(`Checking health attempt ${i + 1}/3 on ${existing.ipcPath}`);
+      healthy = await healthCheck(existing.ipcPath);
+      if (healthy) break;
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    if (healthy) {
+      return existing;
+    }
+  }
+  if (process.platform !== "win32") {
+    try {
+      await fs.rm(ipcPath);
+    } catch {
+    }
+  }
+  const lock = await tryAcquireLock(lockPath);
+  if (lock) {
+    try {
+      const recheckReg = await readRegistry(registryPath);
+      if (recheckReg && await healthCheck(recheckReg.ipcPath)) {
+        return recheckReg;
+      }
+      const token = randomToken();
+      const daemonEntry = getDaemonEntryPath();
+      const child = spawn(
+        process.execPath,
+        [daemonEntry, "daemon", "--project-root", projectRoot, "--token", token],
+        {
+          detached: true,
+          stdio: ["ignore", "pipe", "pipe"],
+          env: {
+            ...process.env,
+            MOCK_MCP_CACHE_DIR: opts.cacheDir ?? ""
+          }
+        }
+      );
+      let daemonStderr = "";
+      let daemonStdout = "";
+      child.stdout?.on("data", (data) => {
+        const str = data.toString();
+        debugLog(`Daemon stdout: ${str}`);
+      });
+      child.stderr?.on("data", (data) => {
+        daemonStderr += data.toString();
+        debugLog(`Daemon stderr: ${data.toString()}`);
+      });
+      child.on("error", (err) => {
+        console.error(`[mock-mcp] Daemon spawn error: ${err.message}`);
+      });
+      child.on("exit", (code, signal) => {
+        if (code !== null && code !== 0) {
+          console.error(`[mock-mcp] Daemon exited with code: ${code}`);
+          if (daemonStderr) {
+            console.error(`[mock-mcp] Daemon stderr: ${daemonStderr.slice(0, 500)}`);
+          }
+        } else if (signal) {
+          console.error(`[mock-mcp] Daemon killed by signal: ${signal}`);
+        }
+      });
+      child.unref();
+      const deadline2 = Date.now() + timeoutMs;
+      while (Date.now() < deadline2) {
+        const reg = await readRegistry(registryPath);
+        if (reg && await healthCheck(reg.ipcPath)) {
+          return reg;
+        }
+        await sleep(50);
+      }
+      console.error("[mock-mcp] Daemon failed to start within timeout");
+      if (daemonStderr) {
+        console.error(`[mock-mcp] Daemon stderr:
+${daemonStderr}`);
+      }
+      throw new Error(
+        `Daemon start timeout after ${timeoutMs}ms. Check logs for details.`
+      );
+    } finally {
+      await releaseLock(lockPath, lock);
+    }
+  }
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const reg = await readRegistry(registryPath);
+    if (reg && await healthCheck(reg.ipcPath)) {
+      return reg;
+    }
+    await sleep(50);
+  }
+  throw new Error(
+    `Waiting for daemon timed out after ${timeoutMs}ms. Another process may have failed to start it.`
+  );
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/shared/protocol.ts
+var HELLO_TEST = "HELLO_TEST";
+var HELLO_ACK = "HELLO_ACK";
+var BATCH_MOCK_REQUEST = "BATCH_MOCK_REQUEST";
+var BATCH_MOCK_RESULT = "BATCH_MOCK_RESULT";
+var HEARTBEAT = "HEARTBEAT";
+var HEARTBEAT_ACK = "HEARTBEAT_ACK";
+var RPC_GET_STATUS = "getStatus";
+var RPC_LIST_RUNS = "listRuns";
+var RPC_CLAIM_NEXT_BATCH = "claimNextBatch";
+var RPC_PROVIDE_BATCH = "provideBatch";
+var RPC_RELEASE_BATCH = "releaseBatch";
+var RPC_GET_BATCH = "getBatch";
+var RPC_ERROR_PARSE = -32700;
+var RPC_ERROR_INVALID_REQUEST = -32600;
+var RPC_ERROR_METHOD_NOT_FOUND = -32601;
+var RPC_ERROR_INVALID_PARAMS = -32602;
+var RPC_ERROR_INTERNAL = -32603;
+var RPC_ERROR_NOT_FOUND = -32e3;
+var RPC_ERROR_UNAUTHORIZED = -32001;
+var RPC_ERROR_CONFLICT = -32002;
+var RPC_ERROR_EXPIRED = -32003;
+function isHelloTestMessage(msg) {
+  if (!msg || typeof msg !== "object") return false;
+  const m = msg;
+  return m.type === HELLO_TEST && typeof m.token === "string" && typeof m.runId === "string" && typeof m.pid === "number" && typeof m.cwd === "string";
+}
+function isBatchMockRequestMessage(msg) {
+  if (!msg || typeof msg !== "object") return false;
+  const m = msg;
+  return m.type === BATCH_MOCK_REQUEST && typeof m.runId === "string" && Array.isArray(m.requests);
+}
+function isHeartbeatMessage(msg) {
+  if (!msg || typeof msg !== "object") return false;
+  const m = msg;
+  return m.type === HEARTBEAT && typeof m.runId === "string";
+}
+function isJsonRpcRequest(msg) {
+  if (!msg || typeof msg !== "object") return false;
+  const m = msg;
+  return m.jsonrpc === "2.0" && (typeof m.id === "string" || typeof m.id === "number") && typeof m.method === "string";
+}
+
+export { BATCH_MOCK_REQUEST, BATCH_MOCK_RESULT, HEARTBEAT, HEARTBEAT_ACK, HELLO_ACK, HELLO_TEST, RPC_CLAIM_NEXT_BATCH, RPC_ERROR_CONFLICT, RPC_ERROR_EXPIRED, RPC_ERROR_INTERNAL, RPC_ERROR_INVALID_PARAMS, RPC_ERROR_INVALID_REQUEST, RPC_ERROR_METHOD_NOT_FOUND, RPC_ERROR_NOT_FOUND, RPC_ERROR_PARSE, RPC_ERROR_UNAUTHORIZED, RPC_GET_BATCH, RPC_GET_STATUS, RPC_LIST_RUNS, RPC_PROVIDE_BATCH, RPC_RELEASE_BATCH, computeProjectId, ensureDaemonRunning, getCacheDir, getDaemonEntryPath, getPaths, healthCheck, isBatchMockRequestMessage, isHeartbeatMessage, isHelloTestMessage, isJsonRpcRequest, randomToken, readRegistry, releaseLock, resolveProjectRoot, sleep, tryAcquireLock, writeRegistry };

package/dist/types-BKREdsyr.d.cts

@@ -0,0 +1,32 @@
+/**
+ * Core types for mock-mcp.
+ */
+/**
+ * Shape of a mock request emitted by the test process.
+ */
+interface MockRequestDescriptor {
+    requestId: string;
+    endpoint: string;
+    method: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Shape of the mock data that needs to be returned for a request.
+ */
+interface MockResponseDescriptor {
+    requestId: string;
+    data: unknown;
+    status?: number;
+    headers?: Record<string, string>;
+    delayMs?: number;
+}
+/**
+ * Resolved mock with typed data.
+ */
+interface ResolvedMock<T = unknown> extends Omit<MockResponseDescriptor, "data"> {
+    data: T;
+}
+
+export type { MockRequestDescriptor as M, ResolvedMock as R, MockResponseDescriptor as a };

package/dist/types-BKREdsyr.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Core types for mock-mcp.
+ */
+/**
+ * Shape of a mock request emitted by the test process.
+ */
+interface MockRequestDescriptor {
+    requestId: string;
+    endpoint: string;
+    method: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Shape of the mock data that needs to be returned for a request.
+ */
+interface MockResponseDescriptor {
+    requestId: string;
+    data: unknown;
+    status?: number;
+    headers?: Record<string, string>;
+    delayMs?: number;
+}
+/**
+ * Resolved mock with typed data.
+ */
+interface ResolvedMock<T = unknown> extends Omit<MockResponseDescriptor, "data"> {
+    data: T;
+}
+
+export type { MockRequestDescriptor as M, ResolvedMock as R, MockResponseDescriptor as a };

package/package.json

@@ -1,12 +1,46 @@
 {
   "name": "mock-mcp",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "An MCP server enabling LLMs to write integration tests through live test environment interaction",
-  "main": "./dist/connect.cjs",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "type": "module",
   "bin": {
     "mock-mcp": "./dist/index.js"
   },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./client": {
+      "import": {
+        "types": "./dist/client/index.d.ts",
+        "default": "./dist/client/index.js"
+      },
+      "require": {
+        "types": "./dist/client/index.d.cts",
+        "default": "./dist/client/index.cjs"
+      }
+    },
+    "./connect": {
+      "import": {
+        "types": "./dist/client/connect.d.ts",
+        "default": "./dist/client/connect.js"
+      },
+      "require": {
+        "types": "./dist/client/connect.d.cts",
+        "default": "./dist/client/connect.cjs"
+      }
+    }
+  },
   "files": [
     "dist"
   ],
@@ -17,12 +51,17 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "build": "tsc && tsup src/client/connect.ts --dts",
+    "build": "tsup",
+    "clean": "rimraf dist",
     "start": "node dist/index.js",
+    "start:adapter": "node dist/index.js adapter",
     "dev": "tsx src/index.ts",
+    "dev:adapter": "tsx src/index.ts adapter",
     "lint": "eslint . --ext .ts",
     "test": "vitest run",
     "test:watch": "vitest --watch",
+    "test:concurrency": "vitest run test/concurrency.test.ts",
+    "test:inspector": "vitest run test/inspector-integration.test.ts",
     "prepublishOnly": "npm run build",
     "link": "npm link",
     "unlink": "npm unlink",
@@ -56,6 +95,7 @@
     "commitizen": "^4.3.1",
     "eslint": "^9.31.0",
     "node-fetch": "^3.3.2",
+    "rimraf": "^6.1.2",
     "tsup": "^8.5.0",
     "tsx": "^4.20.3",
     "typescript": "^5.8.3",
@@ -70,4 +110,4 @@
       "path": "cz-conventional-changelog"
     }
   }
-}
+}

package/dist/client/batch-mock-collector.d.ts

@@ -1,87 +0,0 @@
-type Logger = Pick<Console, "log" | "warn" | "error"> & {
-    debug?: (...args: unknown[]) => void;
-};
-export interface BatchMockCollectorOptions {
-    /**
-     * TCP port exposed by {@link TestMockMCPServer}.
-     *
-     * @default 3002
-     */
-    port?: number;
-    /**
-     * Timeout for individual mock requests in milliseconds.
-     *
-     * @default 60000
-     */
-    timeout?: number;
-    /**
-     * Delay (in milliseconds) that determines how long the collector waits before
-     * flushing the current batch. Setting this to 0 mirrors the "flush on the next
-     * macrotask" approach described in the technical design document.
-     *
-     * @default 0
-     */
-    batchDebounceMs?: number;
-    /**
-     * Maximum number of requests that may be included in a single batch payload.
-     * Requests that exceed this limit will be split into multiple batches.
-     *
-     * @default 50
-     */
-    maxBatchSize?: number;
-    /**
-     * Optional custom logger. Defaults to `console`.
-     */
-    logger?: Logger;
-}
-export interface RequestMockOptions {
-    body?: unknown;
-    headers?: Record<string, string>;
-    metadata?: Record<string, unknown>;
-}
-/**
- * Collects HTTP requests issued during a single macrotask and forwards them to
- * the MCP server as a batch for AI-assisted mock generation.
- */
-export declare class BatchMockCollector {
-    private readonly ws;
-    private readonly pendingRequests;
-    private readonly queuedRequestIds;
-    private readonly timeout;
-    private readonly batchDebounceMs;
-    private readonly maxBatchSize;
-    private readonly logger;
-    private batchTimer;
-    private requestIdCounter;
-    private closed;
-    private readyResolve?;
-    private readyReject?;
-    private readonly readyPromise;
-    constructor(options?: BatchMockCollectorOptions);
-    /**
-     * Ensures the underlying WebSocket connection is ready for use.
-     */
-    waitUntilReady(): Promise<void>;
-    /**
-     * Request mock data for a specific endpoint/method pair.
-     */
-    requestMock<T = unknown>(endpoint: string, method: string, options?: RequestMockOptions): Promise<T>;
-    /**
-     * Wait for all requests that are currently pending to settle. Requests
-     * created after this method is called are not included.
-     */
-    waitForPendingRequests(): Promise<void>;
-    /**
-     * Close the underlying connection and fail all pending requests.
-     */
-    close(code?: number): Promise<void>;
-    private setupWebSocket;
-    private handleMessage;
-    private resolveRequest;
-    private enqueueRequest;
-    private flushQueue;
-    private sendBatch;
-    private rejectRequest;
-    private failAllPending;
-}
-export {};