mock-mcp 0.3.1 → 0.5.0

package/dist/adapter/index.cjs

@@ -0,0 +1,712 @@
+'use strict';
+
+var index_js = require('@modelcontextprotocol/sdk/server/index.js');
+var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
+var types_js = require('@modelcontextprotocol/sdk/types.js');
+var crypto2 = require('crypto');
+var http = require('http');
+var fs = require('fs/promises');
+var fssync = require('fs');
+var os = require('os');
+var path = require('path');
+var child_process = require('child_process');
+var url = require('url');
+var module$1 = require('module');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var crypto2__default = /*#__PURE__*/_interopDefault(crypto2);
+var http__default = /*#__PURE__*/_interopDefault(http);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var fssync__default = /*#__PURE__*/_interopDefault(fssync);
+var os__default = /*#__PURE__*/_interopDefault(os);
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+var __importMetaUrl = (function() {
+  if (typeof document !== 'undefined') {
+    return document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+  }
+  // Node.js CJS context
+  // When this bundle is re-bundled by another tool (e.g., esbuild, webpack),
+  // __filename may not be defined or may not be a valid file path.
+  // We need to handle these cases gracefully.
+  try {
+    if (typeof __filename !== 'undefined' && __filename) {
+      var url = require('url');
+      var path = require('path');
+      // Check if __filename looks like a valid file path
+      if (path.isAbsolute(__filename) || __filename.startsWith('./') || __filename.startsWith('../')) {
+        return url.pathToFileURL(__filename).href;
+      }
+    }
+  } catch (e) {
+    // Fallback if pathToFileURL fails
+  }
+  // Fallback: use process.cwd() as the base URL
+  // This is not perfect but allows the code to continue working
+  try {
+    var url = require('url');
+    return url.pathToFileURL(require('path').join(process.cwd(), 'index.cjs')).href;
+  } catch (e) {
+    return 'file:///unknown';
+  }
+})();
+var DaemonClient = class {
+  constructor(ipcPath, token, adapterId) {
+    this.ipcPath = ipcPath;
+    this.token = token;
+    this.adapterId = adapterId;
+  }
+  // ===========================================================================
+  // RPC Methods
+  // ===========================================================================
+  async getStatus() {
+    return this.rpc("getStatus", {});
+  }
+  async listRuns() {
+    return this.rpc("listRuns", {});
+  }
+  async claimNextBatch(args) {
+    return this.rpc("claimNextBatch", {
+      adapterId: this.adapterId,
+      runId: args.runId,
+      leaseMs: args.leaseMs
+    });
+  }
+  async provideBatch(args) {
+    return this.rpc("provideBatch", {
+      adapterId: this.adapterId,
+      batchId: args.batchId,
+      claimToken: args.claimToken,
+      mocks: args.mocks
+    });
+  }
+  async releaseBatch(args) {
+    return this.rpc("releaseBatch", {
+      adapterId: this.adapterId,
+      batchId: args.batchId,
+      claimToken: args.claimToken,
+      reason: args.reason
+    });
+  }
+  async getBatch(batchId) {
+    return this.rpc("getBatch", { batchId });
+  }
+  // ===========================================================================
+  // Internal
+  // ===========================================================================
+  rpc(method, params) {
+    const payload = {
+      jsonrpc: "2.0",
+      id: crypto2__default.default.randomUUID(),
+      method,
+      params
+    };
+    return new Promise((resolve, reject) => {
+      const req = http__default.default.request(
+        {
+          method: "POST",
+          socketPath: this.ipcPath,
+          path: "/control",
+          headers: {
+            "content-type": "application/json",
+            "x-mock-mcp-token": this.token
+          },
+          timeout: 3e4
+        },
+        (res) => {
+          let buf = "";
+          res.on("data", (chunk) => buf += chunk);
+          res.on("end", () => {
+            try {
+              const response = JSON.parse(buf);
+              if (response.error) {
+                reject(new Error(response.error.message));
+              } else {
+                resolve(response.result);
+              }
+            } catch (e) {
+              reject(e);
+            }
+          });
+        }
+      );
+      req.on("error", (err) => {
+        reject(new Error(`Daemon connection failed: ${err.message}`));
+      });
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("Daemon request timeout"));
+      });
+      req.end(JSON.stringify(payload));
+    });
+  }
+};
+function debugLog(_msg) {
+}
+var __curDirname = (() => {
+  try {
+    const metaUrl = __importMetaUrl;
+    if (metaUrl && typeof metaUrl === "string" && metaUrl.startsWith("file://")) {
+      return path__default.default.dirname(url.fileURLToPath(metaUrl));
+    }
+  } catch {
+  }
+  return process.cwd();
+})();
+function resolveProjectRoot(startDir = process.cwd()) {
+  let current = path__default.default.resolve(startDir);
+  const root = path__default.default.parse(current).root;
+  while (current !== root) {
+    const gitPath = path__default.default.join(current, ".git");
+    try {
+      const stat = fssync__default.default.statSync(gitPath);
+      if (stat.isDirectory() || stat.isFile()) {
+        return current;
+      }
+    } catch {
+    }
+    const pkgPath = path__default.default.join(current, "package.json");
+    try {
+      fssync__default.default.accessSync(pkgPath, fssync__default.default.constants.F_OK);
+      return current;
+    } catch {
+    }
+    current = path__default.default.dirname(current);
+  }
+  return path__default.default.resolve(startDir);
+}
+function computeProjectId(projectRoot) {
+  const real = fssync__default.default.realpathSync(projectRoot);
+  return crypto2__default.default.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__default.default.homedir();
+  if (home) {
+    return path__default.default.join(home, ".cache");
+  }
+  return os__default.default.tmpdir();
+}
+function getPaths(projectId, cacheDir) {
+  const base = path__default.default.join(getCacheDir(cacheDir), "mock-mcp");
+  const registryPath = path__default.default.join(base, `${projectId}.json`);
+  const lockPath = path__default.default.join(base, `${projectId}.lock`);
+  const ipcPath = process.platform === "win32" ? `\\\\.\\pipe\\mock-mcp-${projectId}` : path__default.default.join(base, `${projectId}.sock`);
+  return { base, registryPath, lockPath, ipcPath };
+}
+async function readRegistry(registryPath) {
+  try {
+    const txt = await fs__default.default.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 healthCheck(ipcPath, timeoutMs = 2e3) {
+  return new Promise((resolve) => {
+    const req = http__default.default.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__default.default.open(lockPath, "wx");
+    await fh.write(`${process.pid}
+`);
+    return fh;
+  } catch {
+    return null;
+  }
+}
+async function releaseLock(lockPath, fh) {
+  await fh.close();
+  await fs__default.default.rm(lockPath).catch(() => {
+  });
+}
+function randomToken() {
+  return crypto2__default.default.randomBytes(24).toString("base64url");
+}
+function getDaemonEntryPath() {
+  try {
+    const cwdRequire = module$1.createRequire(url.pathToFileURL(path__default.default.join(process.cwd(), "index.js")).href);
+    const resolved = cwdRequire.resolve("mock-mcp");
+    const distDir = path__default.default.dirname(resolved);
+    const daemonEntry = path__default.default.join(distDir, "index.js");
+    if (fssync__default.default.existsSync(daemonEntry)) {
+      return daemonEntry;
+    }
+  } catch {
+  }
+  try {
+    const packageRoot = resolveProjectRoot(__curDirname);
+    const distPath = path__default.default.join(packageRoot, "dist", "index.js");
+    if (fssync__default.default.existsSync(distPath)) {
+      return distPath;
+    }
+  } catch {
+  }
+  if (process.argv[1]) {
+    return process.argv[1];
+  }
+  return path__default.default.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__default.default.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__default.default.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 = child_process.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/adapter/adapter.ts
+var TOOLS = [
+  {
+    name: "get_status",
+    description: "Get the current status of the mock-mcp daemon, including active test runs and pending batches.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "list_runs",
+    description: "List all active test runs connected to the daemon.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "claim_next_batch",
+    description: `Claim the next pending mock batch for processing. This acquires a lease on the batch.
+    
+You MUST call this before provide_batch_mock_data. The batch will be locked for 30 seconds (configurable via leaseMs).
+If you don't provide mock data within the lease time, the batch will be released for another adapter to claim.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        runId: {
+          type: "string",
+          description: "Optional: Filter to only claim batches from a specific test run."
+        },
+        leaseMs: {
+          type: "number",
+          description: "Optional: Lease duration in milliseconds. Default: 30000 (30 seconds)."
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "get_batch",
+    description: "Get details of a specific batch by ID (read-only, does not claim).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        batchId: {
+          type: "string",
+          description: "The batch ID to retrieve."
+        }
+      },
+      required: ["batchId"]
+    }
+  },
+  {
+    name: "provide_batch_mock_data",
+    description: `Provide mock response data for a claimed batch.
+    
+You MUST first call claim_next_batch to get the batchId and claimToken.
+The mocks array must contain exactly one mock for each request in the batch.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        batchId: {
+          type: "string",
+          description: "The batch ID (from claim_next_batch)."
+        },
+        claimToken: {
+          type: "string",
+          description: "The claim token (from claim_next_batch)."
+        },
+        mocks: {
+          type: "array",
+          description: "Array of mock responses, one for each request in the batch.",
+          items: {
+            type: "object",
+            properties: {
+              requestId: {
+                type: "string",
+                description: "The requestId from the original request."
+              },
+              data: {
+                description: "The mock response data (any JSON value)."
+              },
+              status: {
+                type: "number",
+                description: "Optional HTTP status code. Default: 200."
+              },
+              headers: {
+                type: "object",
+                description: "Optional response headers."
+              },
+              delayMs: {
+                type: "number",
+                description: "Optional delay before returning the mock (ms)."
+              }
+            },
+            required: ["requestId", "data"]
+          }
+        }
+      },
+      required: ["batchId", "claimToken", "mocks"]
+    }
+  },
+  {
+    name: "release_batch",
+    description: "Release a claimed batch without providing mock data. Use this if you cannot generate appropriate mocks.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        batchId: {
+          type: "string",
+          description: "The batch ID to release."
+        },
+        claimToken: {
+          type: "string",
+          description: "The claim token."
+        },
+        reason: {
+          type: "string",
+          description: "Optional reason for releasing."
+        }
+      },
+      required: ["batchId", "claimToken"]
+    }
+  }
+];
+async function runAdapter(opts = {}) {
+  const logger = opts.logger ?? console;
+  const version = opts.version ?? "0.4.0";
+  logger.error("\u{1F50D} Connecting to mock-mcp daemon...");
+  const registry = await ensureDaemonRunning();
+  const adapterId = crypto2__default.default.randomUUID();
+  const daemon = new DaemonClient(registry.ipcPath, registry.token, adapterId);
+  logger.error(`\u2705 Connected to daemon (project: ${registry.projectId})`);
+  const server = new index_js.Server(
+    {
+      name: "mock-mcp-adapter",
+      version
+    },
+    {
+      capabilities: { tools: {} }
+    }
+  );
+  server.setRequestHandler(types_js.ListToolsRequestSchema, async () => ({
+    tools: [...TOOLS]
+  }));
+  server.setRequestHandler(types_js.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      switch (name) {
+        case "get_status": {
+          const result = await daemon.getStatus();
+          return buildToolResponse(formatStatus(result));
+        }
+        case "list_runs": {
+          const result = await daemon.listRuns();
+          return buildToolResponse(formatRuns(result));
+        }
+        case "claim_next_batch": {
+          const result = await daemon.claimNextBatch({
+            runId: args?.runId,
+            leaseMs: args?.leaseMs
+          });
+          return buildToolResponse(formatClaimResult(result));
+        }
+        case "get_batch": {
+          if (!args?.batchId) {
+            throw new Error("batchId is required");
+          }
+          const result = await daemon.getBatch(args.batchId);
+          return buildToolResponse(formatBatch(result));
+        }
+        case "provide_batch_mock_data": {
+          if (!args?.batchId || !args?.claimToken || !args?.mocks) {
+            throw new Error("batchId, claimToken, and mocks are required");
+          }
+          const result = await daemon.provideBatch({
+            batchId: args.batchId,
+            claimToken: args.claimToken,
+            mocks: args.mocks
+          });
+          return buildToolResponse(formatProvideResult(result));
+        }
+        case "release_batch": {
+          if (!args?.batchId || !args?.claimToken) {
+            throw new Error("batchId and claimToken are required");
+          }
+          const result = await daemon.releaseBatch({
+            batchId: args.batchId,
+            claimToken: args.claimToken,
+            reason: args?.reason
+          });
+          return buildToolResponse(JSON.stringify(result, null, 2));
+        }
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.error(`Tool error (${name}):`, message);
+      return buildToolResponse(`Error: ${message}`, true);
+    }
+  });
+  const transport = new stdio_js.StdioServerTransport();
+  await server.connect(transport);
+  logger.error("\u2705 MCP adapter ready (stdio transport)");
+}
+function buildToolResponse(text, isError = false) {
+  return {
+    content: [{ type: "text", text }],
+    isError
+  };
+}
+function formatStatus(status) {
+  return `# Mock MCP Daemon Status
+
+- **Version**: ${status.version}
+- **Project ID**: ${status.projectId}
+- **Project Root**: ${status.projectRoot}
+- **PID**: ${status.pid}
+- **Uptime**: ${Math.round(status.uptime / 1e3)}s
+
+## Batches
+- **Pending**: ${status.pending}
+- **Claimed**: ${status.claimed}
+- **Active Runs**: ${status.runs}
+`;
+}
+function formatRuns(result) {
+  if (result.runs.length === 0) {
+    return "No active test runs.";
+  }
+  const lines = ["# Active Test Runs\n"];
+  for (const run of result.runs) {
+    lines.push(`## Run: ${run.runId}`);
+    lines.push(`- **PID**: ${run.pid}`);
+    lines.push(`- **CWD**: ${run.cwd}`);
+    lines.push(`- **Started**: ${run.startedAt}`);
+    lines.push(`- **Pending Batches**: ${run.pendingBatches}`);
+    if (run.testMeta) {
+      if (run.testMeta.testFile) {
+        lines.push(`- **Test File**: ${run.testMeta.testFile}`);
+      }
+      if (run.testMeta.testName) {
+        lines.push(`- **Test Name**: ${run.testMeta.testName}`);
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatClaimResult(result) {
+  if (!result) {
+    return "No pending batches available to claim.";
+  }
+  const lines = [
+    "# Batch Claimed Successfully\n",
+    `**Batch ID**: \`${result.batchId}\``,
+    `**Claim Token**: \`${result.claimToken}\``,
+    `**Run ID**: ${result.runId}`,
+    `**Lease Until**: ${new Date(result.leaseUntil).toISOString()}`,
+    "",
+    "## Requests\n"
+  ];
+  for (const req of result.requests) {
+    lines.push(`### ${req.method} ${req.endpoint}`);
+    lines.push(`- **Request ID**: \`${req.requestId}\``);
+    if (req.body !== void 0) {
+      lines.push(`- **Body**: \`\`\`json
+${JSON.stringify(req.body, null, 2)}
+\`\`\``);
+    }
+    if (req.headers) {
+      lines.push(`- **Headers**: ${JSON.stringify(req.headers)}`);
+    }
+    if (req.metadata) {
+      lines.push(`- **Metadata**: ${JSON.stringify(req.metadata)}`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("**Next step**: Call `provide_batch_mock_data` with the batch ID, claim token, and mock data for each request.");
+  return lines.join("\n");
+}
+function formatBatch(result) {
+  const lines = [
+    `# Batch: ${result.batchId}
+`,
+    `**Status**: ${result.status}`,
+    `**Run ID**: ${result.runId}`,
+    `**Created**: ${new Date(result.createdAt).toISOString()}`
+  ];
+  if (result.claim) {
+    lines.push(`**Claimed by**: ${result.claim.adapterId}`);
+    lines.push(`**Lease until**: ${new Date(result.claim.leaseUntil).toISOString()}`);
+  }
+  lines.push("", "## Requests\n");
+  for (const req of result.requests) {
+    lines.push(`### ${req.method} ${req.endpoint}`);
+    lines.push(`- **Request ID**: \`${req.requestId}\``);
+    if (req.body !== void 0) {
+      lines.push(`- **Body**: \`\`\`json
+${JSON.stringify(req.body, null, 2)}
+\`\`\``);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatProvideResult(result) {
+  if (result.ok) {
+    return `\u2705 ${result.message ?? "Mock data provided successfully."}`;
+  }
+  return `\u274C Failed to provide mock data: ${result.message}`;
+}
+
+exports.DaemonClient = DaemonClient;
+exports.runAdapter = runAdapter;