mock-mcp 0.3.1 → 0.5.1

package/dist/shared/index.js

@@ -0,0 +1,423 @@
+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 hasValidProjectMarker(dir) {
+  try {
+    const gitPath = path.join(dir, ".git");
+    try {
+      const stat = fssync.statSync(gitPath);
+      if (stat.isDirectory() || stat.isFile()) {
+        return true;
+      }
+    } catch {
+    }
+    const pkgPath = path.join(dir, "package.json");
+    try {
+      fssync.accessSync(pkgPath, fssync.constants.F_OK);
+      return true;
+    } catch {
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+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 = {}) {
+  let projectRoot = opts.projectRoot ?? resolveProjectRoot();
+  if (!hasValidProjectMarker(projectRoot)) {
+    const resolved = resolveProjectRoot(projectRoot);
+    if (resolved !== projectRoot && hasValidProjectMarker(resolved)) {
+      console.error(`[mock-mcp] Warning: projectRoot "${projectRoot}" doesn't look like a project root`);
+      console.error(`[mock-mcp]   Found .git/package.json at: "${resolved}"`);
+      projectRoot = resolved;
+    } else {
+      console.error(`[mock-mcp] \u26A0\uFE0F  WARNING: Could not find a valid project root!`);
+      console.error(`[mock-mcp]   Current path: "${projectRoot}"`);
+      console.error(`[mock-mcp]   This path doesn't contain .git or package.json.`);
+      console.error(`[mock-mcp]   This may cause project mismatch issues.`);
+      console.error(`[mock-mcp]   `);
+      console.error(`[mock-mcp]   For MCP adapters, please specify --project-root explicitly:`);
+      console.error(`[mock-mcp]     mock-mcp adapter --project-root /path/to/your/project`);
+      console.error(`[mock-mcp]   `);
+      console.error(`[mock-mcp]   In your MCP client config (Cursor, Claude Desktop, etc.):`);
+      console.error(`[mock-mcp]   {`);
+      console.error(`[mock-mcp]     "args": ["-y", "mock-mcp", "adapter", "--project-root", "/path/to/your/project"]`);
+      console.error(`[mock-mcp]   }`);
+    }
+  }
+  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));
+}
+function getGlobalIndexPath(cacheDir) {
+  const base = path.join(getCacheDir(cacheDir), "mock-mcp");
+  return path.join(base, "active-daemons.json");
+}
+async function readGlobalIndex(cacheDir) {
+  const indexPath = getGlobalIndexPath(cacheDir);
+  try {
+    const txt = await fs.readFile(indexPath, "utf-8");
+    return JSON.parse(txt);
+  } catch {
+    return { daemons: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+async function writeGlobalIndex(index, cacheDir) {
+  const indexPath = getGlobalIndexPath(cacheDir);
+  const base = path.dirname(indexPath);
+  await fs.mkdir(base, { recursive: true });
+  await fs.writeFile(indexPath, JSON.stringify(index, null, 2), {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+async function registerDaemonGlobally(entry, cacheDir) {
+  const index = await readGlobalIndex(cacheDir);
+  index.daemons = index.daemons.filter((d) => d.projectId !== entry.projectId);
+  index.daemons.push(entry);
+  index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeGlobalIndex(index, cacheDir);
+  debugLog(`Registered daemon ${entry.projectId} in global index`);
+}
+async function unregisterDaemonGlobally(projectId, cacheDir) {
+  const index = await readGlobalIndex(cacheDir);
+  index.daemons = index.daemons.filter((d) => d.projectId !== projectId);
+  index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeGlobalIndex(index, cacheDir);
+}
+async function cleanupGlobalIndex(cacheDir) {
+  const index = await readGlobalIndex(cacheDir);
+  const validDaemons = [];
+  for (const entry of index.daemons) {
+    try {
+      process.kill(entry.pid, 0);
+      const healthy = await healthCheck(entry.ipcPath, 1e3);
+      if (healthy) {
+        validDaemons.push(entry);
+      } else {
+        debugLog(`Removing unhealthy daemon ${entry.projectId} (pid ${entry.pid})`);
+      }
+    } catch {
+      debugLog(`Removing dead daemon ${entry.projectId} (pid ${entry.pid})`);
+    }
+  }
+  if (validDaemons.length !== index.daemons.length) {
+    index.daemons = validDaemons;
+    index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await writeGlobalIndex(index, cacheDir);
+  }
+}
+async function discoverAllDaemons(cacheDir) {
+  await cleanupGlobalIndex(cacheDir);
+  const index = await readGlobalIndex(cacheDir);
+  const results = [];
+  for (const entry of index.daemons) {
+    const registry = await readRegistry(entry.registryPath);
+    if (registry) {
+      const healthy = await healthCheck(entry.ipcPath, 2e3);
+      results.push({ registry, healthy });
+    }
+  }
+  return results;
+}
+
+// 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, cleanupGlobalIndex, computeProjectId, discoverAllDaemons, ensureDaemonRunning, getCacheDir, getDaemonEntryPath, getGlobalIndexPath, getPaths, healthCheck, isBatchMockRequestMessage, isHeartbeatMessage, isHelloTestMessage, isJsonRpcRequest, randomToken, readGlobalIndex, readRegistry, registerDaemonGlobally, releaseLock, resolveProjectRoot, sleep, tryAcquireLock, unregisterDaemonGlobally, writeGlobalIndex, writeRegistry };

package/dist/types-bEGXLBF0.d.cts

@@ -0,0 +1,190 @@
+import fssync from 'node:fs';
+
+/**
+ * Discovery module for mock-mcp Daemon + Adapter architecture.
+ *
+ * Provides:
+ * - Project root resolution (up-search for .git / package.json)
+ * - Project ID computation (sha256 of realpath)
+ * - Registry/lock file path management
+ * - IPC path (Unix Domain Socket / Windows Named Pipe)
+ * - ensureDaemonRunning() - atomic daemon startup with lock
+ */
+
+interface DaemonRegistry {
+    projectId: string;
+    projectRoot: string;
+    ipcPath: string;
+    token: string;
+    pid: number;
+    startedAt: string;
+    version: string;
+}
+interface EnsureDaemonOptions {
+    projectRoot?: string;
+    timeoutMs?: number;
+    /** For testing: override cache directory */
+    cacheDir?: string;
+}
+/**
+ * Resolve the project root by searching upward for .git or package.json.
+ * Falls back to the starting directory if nothing is found.
+ */
+declare function resolveProjectRoot(startDir?: string): string;
+/**
+ * Compute a stable project ID from the project root path.
+ * Uses sha256 of the realpath, truncated to 16 characters.
+ */
+declare function computeProjectId(projectRoot: string): string;
+/**
+ * Get the cache directory for mock-mcp files.
+ * Priority: override > MOCK_MCP_CACHE_DIR env > XDG_CACHE_HOME > LOCALAPPDATA (Windows) > ~/.cache
+ */
+declare function getCacheDir(override?: string): string;
+interface DaemonPaths {
+    base: string;
+    registryPath: string;
+    lockPath: string;
+    ipcPath: string;
+}
+/**
+ * Get all relevant paths for a given project ID.
+ */
+declare function getPaths(projectId: string, cacheDir?: string): DaemonPaths;
+/**
+ * Read the daemon registry file.
+ */
+declare function readRegistry(registryPath: string): Promise<DaemonRegistry | null>;
+/**
+ * Write the daemon registry file with restricted permissions.
+ */
+declare function writeRegistry(registryPath: string, registry: DaemonRegistry): Promise<void>;
+/**
+ * Check if the daemon is healthy by making an HTTP request to /health.
+ */
+declare function healthCheck(ipcPath: string, timeoutMs?: number): Promise<boolean>;
+/**
+ * Try to acquire an exclusive lock file.
+ * Returns the file handle if successful, null otherwise.
+ */
+declare function tryAcquireLock(lockPath: string): Promise<fssync.promises.FileHandle | null>;
+/**
+ * Release the lock file.
+ */
+declare function releaseLock(lockPath: string, fh: fssync.promises.FileHandle): Promise<void>;
+/**
+ * Generate a random token for daemon authentication.
+ */
+declare function randomToken(): string;
+/**
+ * Get the path to the daemon entry point.
+ *
+ * This function handles multiple scenarios:
+ * 1. Direct execution from source (development)
+ * 2. Execution from dist (production)
+ * 3. When re-bundled by another tool (Vitest, esbuild, webpack)
+ *
+ * We use require.resolve to reliably find the mock-mcp package location,
+ * which works even when the code is re-bundled by another tool.
+ */
+declare function getDaemonEntryPath(): string;
+/**
+ * Ensure the daemon is running for the given project.
+ *
+ * This function:
+ * 1. Checks if a daemon is already running (via registry + health check)
+ * 2. If not, acquires a lock and spawns a new daemon
+ * 3. Waits for the daemon to become healthy
+ * 4. Returns the registry information
+ *
+ * Thread-safe: multiple processes calling this concurrently will only start one daemon.
+ */
+declare function ensureDaemonRunning(opts?: EnsureDaemonOptions): Promise<DaemonRegistry>;
+declare function sleep(ms: number): Promise<void>;
+/**
+ * Entry in the global active daemons index.
+ */
+interface ActiveDaemonEntry {
+    projectId: string;
+    projectRoot: string;
+    ipcPath: string;
+    registryPath: string;
+    pid: number;
+    startedAt: string;
+    version: string;
+}
+/**
+ * Global index of all active daemons.
+ */
+interface ActiveDaemonsIndex {
+    daemons: ActiveDaemonEntry[];
+    updatedAt: string;
+}
+/**
+ * Get the path to the global active daemons index file.
+ */
+declare function getGlobalIndexPath(cacheDir?: string): string;
+/**
+ * Read the global active daemons index.
+ */
+declare function readGlobalIndex(cacheDir?: string): Promise<ActiveDaemonsIndex>;
+/**
+ * Write the global active daemons index.
+ */
+declare function writeGlobalIndex(index: ActiveDaemonsIndex, cacheDir?: string): Promise<void>;
+/**
+ * Register a daemon in the global index.
+ * Called when a daemon starts.
+ */
+declare function registerDaemonGlobally(entry: ActiveDaemonEntry, cacheDir?: string): Promise<void>;
+/**
+ * Unregister a daemon from the global index.
+ * Called when a daemon stops.
+ */
+declare function unregisterDaemonGlobally(projectId: string, cacheDir?: string): Promise<void>;
+/**
+ * Clean up stale entries from the global index.
+ * Removes entries where the daemon is no longer running.
+ */
+declare function cleanupGlobalIndex(cacheDir?: string): Promise<void>;
+/**
+ * Discover all active daemons.
+ * Returns list of daemons with their connection info.
+ */
+declare function discoverAllDaemons(cacheDir?: string): Promise<{
+    registry: DaemonRegistry;
+    healthy: boolean;
+}[]>;
+
+/**
+ * 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 ActiveDaemonEntry as A, type DaemonRegistry as D, type EnsureDaemonOptions as E, type MockResponseDescriptor as M, type ResolvedMock as R, type MockRequestDescriptor as a, getPaths as b, computeProjectId as c, readRegistry as d, releaseLock as e, randomToken as f, getCacheDir as g, healthCheck as h, getDaemonEntryPath as i, ensureDaemonRunning as j, getGlobalIndexPath as k, readGlobalIndex as l, writeGlobalIndex as m, registerDaemonGlobally as n, cleanupGlobalIndex as o, discoverAllDaemons as p, type DaemonPaths as q, resolveProjectRoot as r, sleep as s, tryAcquireLock as t, unregisterDaemonGlobally as u, type ActiveDaemonsIndex as v, writeRegistry as w };