mock-mcp 0.3.0 → 0.5.0

package/dist/index.cjs

@@ -0,0 +1,2238 @@
+#!/usr/bin/env node
+'use strict';
+
+var fs = require('fs/promises');
+var fssync = require('fs');
+var os = require('os');
+var path = require('path');
+var crypto = require('crypto');
+var child_process = require('child_process');
+var http = require('http');
+var url = require('url');
+var module$1 = require('module');
+var WebSocket2 = require('ws');
+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 process2 = require('process');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+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 crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var http__default = /*#__PURE__*/_interopDefault(http);
+var WebSocket2__default = /*#__PURE__*/_interopDefault(WebSocket2);
+var process2__default = /*#__PURE__*/_interopDefault(process2);
+
+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 __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/shared/discovery.ts
+var discovery_exports = {};
+__export(discovery_exports, {
+  computeProjectId: () => computeProjectId,
+  ensureDaemonRunning: () => ensureDaemonRunning,
+  getCacheDir: () => getCacheDir,
+  getDaemonEntryPath: () => getDaemonEntryPath,
+  getPaths: () => getPaths,
+  healthCheck: () => healthCheck,
+  randomToken: () => randomToken,
+  readRegistry: () => readRegistry,
+  releaseLock: () => releaseLock,
+  resolveProjectRoot: () => resolveProjectRoot,
+  sleep: () => sleep,
+  tryAcquireLock: () => tryAcquireLock,
+  writeRegistry: () => writeRegistry
+});
+function debugLog(_msg) {
+}
+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 crypto__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 writeRegistry(registryPath, registry) {
+  await fs__default.default.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__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 crypto__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));
+}
+var __curDirname;
+var init_discovery = __esm({
+  "src/shared/discovery.ts"() {
+    __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();
+    })();
+  }
+});
+
+// src/shared/protocol.ts
+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";
+}
+var HELLO_TEST, HELLO_ACK, BATCH_MOCK_REQUEST, BATCH_MOCK_RESULT, HEARTBEAT, HEARTBEAT_ACK, RPC_GET_STATUS, RPC_LIST_RUNS, RPC_CLAIM_NEXT_BATCH, RPC_PROVIDE_BATCH, RPC_RELEASE_BATCH, RPC_GET_BATCH, RPC_ERROR_METHOD_NOT_FOUND, RPC_ERROR_INTERNAL, RPC_ERROR_NOT_FOUND, RPC_ERROR_UNAUTHORIZED, RPC_ERROR_CONFLICT, RPC_ERROR_EXPIRED;
+var init_protocol = __esm({
+  "src/shared/protocol.ts"() {
+    HELLO_TEST = "HELLO_TEST";
+    HELLO_ACK = "HELLO_ACK";
+    BATCH_MOCK_REQUEST = "BATCH_MOCK_REQUEST";
+    BATCH_MOCK_RESULT = "BATCH_MOCK_RESULT";
+    HEARTBEAT = "HEARTBEAT";
+    HEARTBEAT_ACK = "HEARTBEAT_ACK";
+    RPC_GET_STATUS = "getStatus";
+    RPC_LIST_RUNS = "listRuns";
+    RPC_CLAIM_NEXT_BATCH = "claimNextBatch";
+    RPC_PROVIDE_BATCH = "provideBatch";
+    RPC_RELEASE_BATCH = "releaseBatch";
+    RPC_GET_BATCH = "getBatch";
+    RPC_ERROR_METHOD_NOT_FOUND = -32601;
+    RPC_ERROR_INTERNAL = -32603;
+    RPC_ERROR_NOT_FOUND = -32e3;
+    RPC_ERROR_UNAUTHORIZED = -32001;
+    RPC_ERROR_CONFLICT = -32002;
+    RPC_ERROR_EXPIRED = -32003;
+  }
+});
+
+// src/daemon/daemon.ts
+var daemon_exports = {};
+__export(daemon_exports, {
+  MockMcpDaemon: () => exports.MockMcpDaemon
+});
+exports.MockMcpDaemon = void 0; var RpcError;
+var init_daemon = __esm({
+  "src/daemon/daemon.ts"() {
+    init_discovery();
+    init_protocol();
+    exports.MockMcpDaemon = class {
+      logger;
+      opts;
+      server;
+      wss;
+      sweepTimer;
+      idleTimer;
+      startedAt;
+      // State management
+      runs = /* @__PURE__ */ new Map();
+      batches = /* @__PURE__ */ new Map();
+      pendingQueue = [];
+      // batchIds in order
+      batchSeq = 0;
+      constructor(options) {
+        this.logger = options.logger ?? console;
+        this.opts = {
+          projectRoot: options.projectRoot,
+          token: options.token,
+          version: options.version,
+          cacheDir: options.cacheDir,
+          logger: this.logger,
+          defaultLeaseMs: options.defaultLeaseMs ?? 3e4,
+          sweepIntervalMs: options.sweepIntervalMs ?? 5e3,
+          idleShutdownMs: options.idleShutdownMs ?? 6e5
+        };
+      }
+      // ===========================================================================
+      // Lifecycle
+      // ===========================================================================
+      async start() {
+        const projectId = computeProjectId(this.opts.projectRoot);
+        const { base, registryPath, ipcPath } = getPaths(projectId, this.opts.cacheDir);
+        await fs__default.default.mkdir(base, { recursive: true });
+        if (process.platform !== "win32") {
+          try {
+            await fs__default.default.rm(ipcPath);
+          } catch {
+          }
+        }
+        const server = http__default.default.createServer((req, res) => this.handleHttp(req, res));
+        this.server = server;
+        const wss = new WebSocket2.WebSocketServer({ noServer: true });
+        this.wss = wss;
+        server.on("upgrade", (req, socket, head) => {
+          if (!req.url?.startsWith("/test")) {
+            socket.destroy();
+            return;
+          }
+          wss.handleUpgrade(req, socket, head, (ws) => {
+            wss.emit("connection", ws, req);
+          });
+        });
+        wss.on("connection", (ws, req) => this.handleWsConnection(ws, req));
+        await new Promise((resolve, reject) => {
+          server.once("error", reject);
+          server.listen(ipcPath, () => {
+            this.logger.error(`\u{1F680} Daemon listening on ${ipcPath}`);
+            resolve();
+          });
+        });
+        this.startedAt = Date.now();
+        const registry = {
+          projectId,
+          projectRoot: this.opts.projectRoot,
+          ipcPath,
+          token: this.opts.token,
+          pid: process.pid,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          version: this.opts.version
+        };
+        await writeRegistry(registryPath, registry);
+        this.sweepTimer = setInterval(() => this.sweepExpiredClaims(), this.opts.sweepIntervalMs);
+        this.sweepTimer.unref?.();
+        this.resetIdleTimer();
+        this.logger.error(`\u2705 Daemon ready (project: ${projectId}, pid: ${process.pid})`);
+      }
+      async stop() {
+        if (this.sweepTimer) {
+          clearInterval(this.sweepTimer);
+          this.sweepTimer = void 0;
+        }
+        if (this.idleTimer) {
+          clearTimeout(this.idleTimer);
+          this.idleTimer = void 0;
+        }
+        for (const run of this.runs.values()) {
+          run.ws.close(1001, "Daemon shutting down");
+        }
+        this.runs.clear();
+        this.wss?.close();
+        await new Promise((resolve) => {
+          if (!this.server) {
+            resolve();
+            return;
+          }
+          this.server.close(() => resolve());
+        });
+        this.batches.clear();
+        this.pendingQueue.length = 0;
+        this.logger.error("\u{1F44B} Daemon stopped");
+      }
+      // ===========================================================================
+      // HTTP Handler (/health, /control)
+      // ===========================================================================
+      async handleHttp(req, res) {
+        try {
+          if (req.method === "GET" && req.url === "/health") {
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(
+              JSON.stringify({
+                ok: true,
+                pid: process.pid,
+                version: this.opts.version,
+                projectId: computeProjectId(this.opts.projectRoot)
+              })
+            );
+            return;
+          }
+          if (req.method === "POST" && req.url === "/control") {
+            const token = req.headers["x-mock-mcp-token"];
+            if (token !== this.opts.token) {
+              res.writeHead(401, { "content-type": "application/json" });
+              res.end(JSON.stringify({ error: "Unauthorized" }));
+              return;
+            }
+            const body = await this.readBody(req);
+            let rpcReq;
+            try {
+              rpcReq = JSON.parse(body);
+            } catch {
+              res.writeHead(400, { "content-type": "application/json" });
+              res.end(JSON.stringify({ error: "Invalid JSON" }));
+              return;
+            }
+            if (!isJsonRpcRequest(rpcReq)) {
+              res.writeHead(400, { "content-type": "application/json" });
+              res.end(JSON.stringify({ error: "Invalid JSON-RPC request" }));
+              return;
+            }
+            const rpcRes = await this.handleRpc(rpcReq);
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify(rpcRes));
+            return;
+          }
+          res.writeHead(404, { "content-type": "text/plain" });
+          res.end("Not Found");
+        } catch (e) {
+          this.logger.error("HTTP handler error:", e);
+          res.writeHead(500, { "content-type": "text/plain" });
+          res.end(e instanceof Error ? e.message : String(e));
+        }
+      }
+      readBody(req) {
+        return new Promise((resolve, reject) => {
+          let buf = "";
+          req.on("data", (chunk) => buf += chunk);
+          req.on("end", () => resolve(buf));
+          req.on("error", reject);
+        });
+      }
+      // ===========================================================================
+      // WebSocket Handler (/test)
+      // ===========================================================================
+      handleWsConnection(ws, _req) {
+        let authed = false;
+        let runId = null;
+        const helloTimeout = setTimeout(() => {
+          if (!authed) {
+            ws.close(1008, "HELLO timeout");
+          }
+        }, 5e3);
+        ws.on("message", (data) => {
+          let msg;
+          try {
+            msg = JSON.parse(data.toString());
+          } catch {
+            this.logger.warn("Invalid JSON from test process");
+            return;
+          }
+          if (!authed) {
+            if (!isHelloTestMessage(msg)) {
+              ws.close(1008, "Expected HELLO_TEST");
+              return;
+            }
+            if (msg.token !== this.opts.token) {
+              ws.close(1008, "Invalid token");
+              return;
+            }
+            authed = true;
+            clearTimeout(helloTimeout);
+            runId = msg.runId;
+            const runState = {
+              runId,
+              pid: msg.pid,
+              cwd: msg.cwd,
+              startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              lastSeen: Date.now(),
+              testMeta: msg.testMeta,
+              ws
+            };
+            this.runs.set(runId, runState);
+            const ack = { type: HELLO_ACK, runId };
+            ws.send(JSON.stringify(ack));
+            this.logger.error(`\u{1F50C} Test run connected: ${runId} (pid: ${msg.pid})`);
+            this.resetIdleTimer();
+            return;
+          }
+          if (isBatchMockRequestMessage(msg)) {
+            this.handleBatchRequest(runId, msg.requests, ws);
+            return;
+          }
+          if (isHeartbeatMessage(msg)) {
+            const run = this.runs.get(msg.runId);
+            if (run) {
+              run.lastSeen = Date.now();
+            }
+            const ack = { type: HEARTBEAT_ACK, runId: msg.runId };
+            ws.send(JSON.stringify(ack));
+            return;
+          }
+        });
+        ws.on("close", () => {
+          clearTimeout(helloTimeout);
+          if (runId) {
+            this.cleanupRun(runId);
+          }
+        });
+        ws.on("error", (err) => {
+          this.logger.error("WebSocket error:", err);
+          if (runId) {
+            this.cleanupRun(runId);
+          }
+        });
+      }
+      handleBatchRequest(runId, requests, ws) {
+        const batchId = `batch:${runId}:${++this.batchSeq}`;
+        const batch = {
+          batchId,
+          runId,
+          requests,
+          createdAt: Date.now(),
+          status: "pending"
+        };
+        this.batches.set(batchId, batch);
+        this.pendingQueue.push(batchId);
+        this.logger.error(
+          [
+            `\u{1F4E5} Received ${requests.length} request(s) (${batchId})`,
+            ...requests.map(
+              (req, i) => `   ${i + 1}. ${req.method} ${req.endpoint} (${req.requestId})`
+            )
+          ].join("\n")
+        );
+        this.logger.error("\u23F3 Awaiting mock data from MCP adapter...");
+      }
+      cleanupRun(runId) {
+        const run = this.runs.get(runId);
+        if (!run) return;
+        this.runs.delete(runId);
+        for (const [batchId, batch] of this.batches) {
+          if (batch.runId === runId) {
+            this.batches.delete(batchId);
+          }
+        }
+        for (let i = this.pendingQueue.length - 1; i >= 0; i--) {
+          const bid = this.pendingQueue[i];
+          if (!this.batches.has(bid)) {
+            this.pendingQueue.splice(i, 1);
+          }
+        }
+        this.logger.error(`\u{1F50C} Test run disconnected: ${runId}`);
+        this.resetIdleTimer();
+      }
+      // ===========================================================================
+      // JSON-RPC Handler
+      // ===========================================================================
+      async handleRpc(req) {
+        try {
+          this.sweepExpiredClaims();
+          const params = req.params ?? {};
+          switch (req.method) {
+            case RPC_GET_STATUS:
+              return this.rpcSuccess(req.id, this.getStatus());
+            case RPC_LIST_RUNS:
+              return this.rpcSuccess(req.id, this.listRuns());
+            case RPC_CLAIM_NEXT_BATCH:
+              return this.rpcSuccess(req.id, this.claimNextBatch(params));
+            case RPC_PROVIDE_BATCH:
+              return this.rpcSuccess(req.id, await this.provideBatch(params));
+            case RPC_RELEASE_BATCH:
+              return this.rpcSuccess(req.id, this.releaseBatch(params));
+            case RPC_GET_BATCH:
+              return this.rpcSuccess(req.id, this.getBatch(params));
+            default:
+              return this.rpcError(req.id, RPC_ERROR_METHOD_NOT_FOUND, `Unknown method: ${req.method}`);
+          }
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          const code = this.getErrorCode(e);
+          return this.rpcError(req.id, code, msg);
+        }
+      }
+      getErrorCode(e) {
+        if (e instanceof RpcError) {
+          return e.code;
+        }
+        return RPC_ERROR_INTERNAL;
+      }
+      rpcSuccess(id, result) {
+        return { jsonrpc: "2.0", id, result };
+      }
+      rpcError(id, code, message) {
+        return { jsonrpc: "2.0", id, error: { code, message } };
+      }
+      // ===========================================================================
+      // RPC Methods
+      // ===========================================================================
+      getStatus() {
+        const pending = this.pendingQueue.filter((bid) => {
+          const b = this.batches.get(bid);
+          return b && b.status === "pending";
+        }).length;
+        const claimed = Array.from(this.batches.values()).filter(
+          (b) => b.status === "claimed"
+        ).length;
+        return {
+          version: this.opts.version,
+          projectId: computeProjectId(this.opts.projectRoot),
+          projectRoot: this.opts.projectRoot,
+          pid: process.pid,
+          uptime: this.startedAt ? Date.now() - this.startedAt : 0,
+          runs: this.runs.size,
+          pending,
+          claimed,
+          totalBatches: this.batches.size
+        };
+      }
+      listRuns() {
+        const runs = Array.from(this.runs.values()).map((r) => {
+          const pendingBatches = Array.from(this.batches.values()).filter(
+            (b) => b.runId === r.runId && b.status === "pending"
+          ).length;
+          return {
+            runId: r.runId,
+            pid: r.pid,
+            cwd: r.cwd,
+            startedAt: r.startedAt,
+            lastSeen: r.lastSeen,
+            pendingBatches,
+            testMeta: r.testMeta
+          };
+        });
+        return { runs };
+      }
+      claimNextBatch(params) {
+        const { adapterId, runId, leaseMs = this.opts.defaultLeaseMs } = params;
+        if (!adapterId) {
+          throw new RpcError(RPC_ERROR_UNAUTHORIZED, "adapterId required");
+        }
+        for (let i = 0; i < this.pendingQueue.length; i++) {
+          const batchId = this.pendingQueue[i];
+          const batch = this.batches.get(batchId);
+          if (!batch || batch.status !== "pending") {
+            continue;
+          }
+          if (runId && batch.runId !== runId) {
+            continue;
+          }
+          this.pendingQueue.splice(i, 1);
+          batch.status = "claimed";
+          batch.claim = {
+            adapterId,
+            claimToken: crypto__default.default.randomUUID(),
+            leaseUntil: Date.now() + leaseMs
+          };
+          this.logger.error(`\u{1F512} Batch ${batchId} claimed by adapter ${adapterId.slice(0, 8)}...`);
+          return {
+            batchId: batch.batchId,
+            runId: batch.runId,
+            requests: batch.requests,
+            claimToken: batch.claim.claimToken,
+            leaseUntil: batch.claim.leaseUntil
+          };
+        }
+        return null;
+      }
+      async provideBatch(params) {
+        const { adapterId, batchId, claimToken, mocks } = params;
+        const batch = this.batches.get(batchId);
+        if (!batch) {
+          throw new RpcError(RPC_ERROR_NOT_FOUND, `Batch not found: ${batchId}`);
+        }
+        if (batch.status !== "claimed" || !batch.claim) {
+          throw new RpcError(RPC_ERROR_CONFLICT, `Batch not in claimed state: ${batchId}`);
+        }
+        if (batch.claim.adapterId !== adapterId) {
+          throw new RpcError(RPC_ERROR_UNAUTHORIZED, "Not the owner of this batch");
+        }
+        if (batch.claim.claimToken !== claimToken) {
+          throw new RpcError(RPC_ERROR_UNAUTHORIZED, "Invalid claim token");
+        }
+        if (batch.claim.leaseUntil <= Date.now()) {
+          batch.status = "pending";
+          batch.claim = void 0;
+          this.pendingQueue.push(batchId);
+          throw new RpcError(RPC_ERROR_EXPIRED, "Claim lease expired");
+        }
+        this.validateMocks(batch, mocks);
+        const run = this.runs.get(batch.runId);
+        if (!run) {
+          this.batches.delete(batchId);
+          throw new RpcError(RPC_ERROR_NOT_FOUND, "Run is gone");
+        }
+        if (run.ws.readyState !== WebSocket2.WebSocket.OPEN) {
+          this.batches.delete(batchId);
+          throw new RpcError(RPC_ERROR_NOT_FOUND, "Test process disconnected");
+        }
+        const result = {
+          type: BATCH_MOCK_RESULT,
+          batchId,
+          mocks
+        };
+        run.ws.send(JSON.stringify(result));
+        batch.status = "fulfilled";
+        this.batches.delete(batchId);
+        this.logger.error(`\u2705 Delivered ${mocks.length} mock(s) for ${batchId}`);
+        return { ok: true, message: `Provided ${mocks.length} mock(s) for ${batchId}` };
+      }
+      validateMocks(batch, mocks) {
+        const expectedIds = new Set(batch.requests.map((r) => r.requestId));
+        const providedIds = /* @__PURE__ */ new Set();
+        for (const mock of mocks) {
+          if (!expectedIds.has(mock.requestId)) {
+            throw new RpcError(
+              RPC_ERROR_CONFLICT,
+              `Mock references unknown requestId: ${mock.requestId}`
+            );
+          }
+          if (providedIds.has(mock.requestId)) {
+            throw new RpcError(
+              RPC_ERROR_CONFLICT,
+              `Duplicate mock for requestId: ${mock.requestId}`
+            );
+          }
+          providedIds.add(mock.requestId);
+        }
+        const missing = Array.from(expectedIds).filter((id) => !providedIds.has(id));
+        if (missing.length > 0) {
+          throw new RpcError(
+            RPC_ERROR_CONFLICT,
+            `Missing mocks for requestId(s): ${missing.join(", ")}`
+          );
+        }
+      }
+      releaseBatch(params) {
+        const { adapterId, batchId, claimToken } = params;
+        const batch = this.batches.get(batchId);
+        if (!batch) {
+          throw new RpcError(RPC_ERROR_NOT_FOUND, `Batch not found: ${batchId}`);
+        }
+        if (batch.status !== "claimed" || !batch.claim) {
+          throw new RpcError(RPC_ERROR_CONFLICT, `Batch not in claimed state: ${batchId}`);
+        }
+        if (batch.claim.adapterId !== adapterId || batch.claim.claimToken !== claimToken) {
+          throw new RpcError(RPC_ERROR_UNAUTHORIZED, "Not the owner of this batch");
+        }
+        batch.status = "pending";
+        batch.claim = void 0;
+        this.pendingQueue.push(batchId);
+        this.logger.error(`\u{1F513} Batch ${batchId} released by adapter`);
+        return { ok: true };
+      }
+      getBatch(params) {
+        const batch = this.batches.get(params.batchId);
+        if (!batch) {
+          throw new RpcError(RPC_ERROR_NOT_FOUND, `Batch not found: ${params.batchId}`);
+        }
+        return {
+          batchId: batch.batchId,
+          runId: batch.runId,
+          requests: batch.requests,
+          status: batch.status,
+          createdAt: batch.createdAt,
+          claim: batch.claim ? { adapterId: batch.claim.adapterId, leaseUntil: batch.claim.leaseUntil } : void 0
+        };
+      }
+      // ===========================================================================
+      // Maintenance
+      // ===========================================================================
+      sweepExpiredClaims() {
+        const now = Date.now();
+        for (const batch of this.batches.values()) {
+          if (batch.status === "claimed" && batch.claim && batch.claim.leaseUntil <= now) {
+            this.logger.warn(`\u23F0 Claim expired for ${batch.batchId}, returning to pending`);
+            batch.status = "pending";
+            batch.claim = void 0;
+            this.pendingQueue.push(batch.batchId);
+          }
+        }
+      }
+      resetIdleTimer() {
+        if (this.idleTimer) {
+          clearTimeout(this.idleTimer);
+        }
+        if (this.runs.size === 0) {
+          this.idleTimer = setTimeout(() => {
+            if (this.runs.size === 0) {
+              this.logger.error("\u{1F4A4} No activity, shutting down daemon...");
+              this.stop().then(() => process.exit(0));
+            }
+          }, this.opts.idleShutdownMs);
+          this.idleTimer.unref?.();
+        }
+      }
+    };
+    RpcError = class extends Error {
+      constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "RpcError";
+      }
+    };
+  }
+});
+exports.DaemonClient = void 0;
+var init_daemon_client = __esm({
+  "src/adapter/daemon-client.ts"() {
+    exports.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: crypto__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));
+        });
+      }
+    };
+  }
+});
+
+// src/adapter/adapter.ts
+var adapter_exports = {};
+__export(adapter_exports, {
+  runAdapter: () => runAdapter
+});
+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 = crypto__default.default.randomUUID();
+  const daemon = new exports.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}`;
+}
+var TOOLS;
+var init_adapter = __esm({
+  "src/adapter/adapter.ts"() {
+    init_daemon_client();
+    init_discovery();
+    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"]
+        }
+      }
+    ];
+  }
+});
+
+// src/index.ts
+init_daemon();
+
+// src/adapter/index.ts
+init_adapter();
+init_daemon_client();
+
+// src/client/batch-mock-collector.ts
+init_discovery();
+init_protocol();
+
+// src/client/util.ts
+var isEnabled = () => {
+  return process.env.MOCK_MCP !== void 0 && process.env.MOCK_MCP !== "0";
+};
+
+// src/client/batch-mock-collector.ts
+var DEFAULT_TIMEOUT = 6e4;
+var DEFAULT_BATCH_DEBOUNCE_MS = 0;
+var DEFAULT_MAX_BATCH_SIZE = 50;
+var DEFAULT_HEARTBEAT_INTERVAL_MS = 15e3;
+var BatchMockCollector = class {
+  ws;
+  registry;
+  runId = crypto__default.default.randomUUID();
+  pendingRequests = /* @__PURE__ */ new Map();
+  queuedRequestIds = /* @__PURE__ */ new Set();
+  timeout;
+  batchDebounceMs;
+  maxBatchSize;
+  logger;
+  heartbeatIntervalMs;
+  enableReconnect;
+  projectRoot;
+  testMeta;
+  batchTimer = null;
+  heartbeatTimer = null;
+  reconnectTimer = null;
+  requestIdCounter = 0;
+  closed = false;
+  authed = false;
+  readyResolve;
+  readyReject;
+  readyPromise = Promise.resolve();
+  constructor(options = {}) {
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    this.batchDebounceMs = options.batchDebounceMs ?? DEFAULT_BATCH_DEBOUNCE_MS;
+    this.maxBatchSize = options.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE;
+    this.logger = options.logger ?? console;
+    this.heartbeatIntervalMs = options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
+    this.enableReconnect = options.enableReconnect ?? true;
+    this.testMeta = options.testMeta;
+    this.projectRoot = this.resolveProjectRootFromOptions(options);
+    this.logger.log(`[mock-mcp] BatchMockCollector created`);
+    this.logger.log(`[mock-mcp]   runId: ${this.runId}`);
+    this.logger.log(`[mock-mcp]   timeout: ${this.timeout}ms`);
+    this.logger.log(`[mock-mcp]   batchDebounceMs: ${this.batchDebounceMs}ms`);
+    this.logger.log(`[mock-mcp]   maxBatchSize: ${this.maxBatchSize}`);
+    this.logger.log(`[mock-mcp]   heartbeatIntervalMs: ${this.heartbeatIntervalMs}ms`);
+    this.logger.log(`[mock-mcp]   enableReconnect: ${this.enableReconnect}`);
+    this.logger.log(`[mock-mcp]   projectRoot: ${this.projectRoot ?? "(auto-detect)"}`);
+    if (options.filePath) {
+      this.logger.log(`[mock-mcp]   filePath: ${options.filePath}`);
+    }
+    this.resetReadyPromise();
+    this.initConnection({
+      timeout: this.timeout
+    });
+  }
+  /**
+   * Resolve projectRoot from options.
+   * Priority: projectRoot > filePath > undefined (auto-detect)
+   */
+  resolveProjectRootFromOptions(options) {
+    if (options.projectRoot) {
+      return options.projectRoot;
+    }
+    if (options.filePath) {
+      let filePath = options.filePath;
+      if (filePath.startsWith("file://")) {
+        try {
+          filePath = url.fileURLToPath(filePath);
+        } catch {
+          filePath = filePath.replace(/^file:\/\//, "");
+        }
+      }
+      const dir = path__default.default.dirname(filePath);
+      const resolved = resolveProjectRoot(dir);
+      this.logger.log(`[mock-mcp]   Resolved projectRoot from filePath:`);
+      this.logger.log(`[mock-mcp]     filePath: ${options.filePath}`);
+      this.logger.log(`[mock-mcp]     dir: ${dir}`);
+      this.logger.log(`[mock-mcp]     projectRoot: ${resolved}`);
+      return resolved;
+    }
+    return void 0;
+  }
+  /**
+   * Ensures the underlying connection is ready for use.
+   */
+  async waitUntilReady() {
+    return this.readyPromise;
+  }
+  /**
+   * Request mock data for a specific endpoint/method pair.
+   */
+  async requestMock(endpoint, method, options = {}) {
+    if (this.closed) {
+      throw new Error("BatchMockCollector has been closed");
+    }
+    await this.waitUntilReady();
+    const requestId = `req-${++this.requestIdCounter}`;
+    const request = {
+      requestId,
+      endpoint,
+      method,
+      body: options.body,
+      headers: options.headers,
+      metadata: options.metadata
+    };
+    let settleCompletion;
+    const completion = new Promise((resolve) => {
+      settleCompletion = resolve;
+    });
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        this.rejectRequest(
+          requestId,
+          new Error(`Mock request timed out after ${this.timeout}ms: ${method} ${endpoint}`)
+        );
+      }, this.timeout);
+      this.pendingRequests.set(requestId, {
+        request,
+        resolve: (mock) => {
+          settleCompletion({ status: "fulfilled", value: void 0 });
+          resolve(this.buildResolvedMock(mock));
+        },
+        reject: (error) => {
+          settleCompletion({ status: "rejected", reason: error });
+          reject(error);
+        },
+        timeoutId,
+        completion
+      });
+      this.enqueueRequest(requestId);
+    });
+  }
+  /**
+   * Wait for all currently pending requests to settle.
+   */
+  async waitForPendingRequests() {
+    if (!isEnabled()) {
+      return;
+    }
+    const pendingCompletions = Array.from(this.pendingRequests.values()).map(
+      (p) => p.completion
+    );
+    const results = await Promise.all(pendingCompletions);
+    const rejected = results.find(
+      (r) => r.status === "rejected"
+    );
+    if (rejected) {
+      throw rejected.reason;
+    }
+  }
+  /**
+   * Close the connection and fail all pending requests.
+   */
+  async close(code) {
+    this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] close() called with code: ${code ?? "(default)"}`);
+    if (this.closed) {
+      this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Already closed, returning`);
+      return;
+    }
+    this.closed = true;
+    this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Cleaning up timers...`);
+    if (this.batchTimer) {
+      clearTimeout(this.batchTimer);
+      this.batchTimer = null;
+    }
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    const pendingCount = this.pendingRequests.size;
+    const queuedCount = this.queuedRequestIds.size;
+    this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Pending requests: ${pendingCount}, Queued: ${queuedCount}`);
+    this.queuedRequestIds.clear();
+    const closePromise = new Promise((resolve) => {
+      if (!this.ws) {
+        resolve();
+        return;
+      }
+      this.ws.once("close", () => resolve());
+    });
+    this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Closing WebSocket...`);
+    this.ws?.close(code);
+    this.failAllPending(new Error("BatchMockCollector has been closed"));
+    await closePromise;
+    this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] \u2705 Connection closed`);
+  }
+  // ===========================================================================
+  // Connection Management
+  // ===========================================================================
+  async initConnection({
+    timeout = 1e4
+  }) {
+    const initStartTime = Date.now();
+    this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Initializing connection...`);
+    try {
+      this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Ensuring daemon is running...`);
+      const daemonStartTime = Date.now();
+      this.registry = await ensureDaemonRunning({
+        projectRoot: this.projectRoot,
+        timeoutMs: timeout
+      });
+      const daemonElapsed = Date.now() - daemonStartTime;
+      this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Daemon ready (${daemonElapsed}ms)`);
+      this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}]   Project ID: ${this.registry.projectId}`);
+      this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}]   Daemon PID: ${this.registry.pid}`);
+      this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}]   IPC Path: ${this.registry.ipcPath}`);
+      this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Creating WebSocket connection...`);
+      const wsStartTime = Date.now();
+      this.ws = await this.createWebSocket(this.registry.ipcPath);
+      const wsElapsed = Date.now() - wsStartTime;
+      this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] WebSocket created (${wsElapsed}ms)`);
+      this.setupWebSocket();
+      const totalElapsed = Date.now() - initStartTime;
+      this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Connection initialized (total: ${totalElapsed}ms)`);
+    } catch (error) {
+      const elapsed = Date.now() - initStartTime;
+      this.logger.error(`[mock-mcp] [${this.runId.slice(0, 8)}] Connection init failed after ${elapsed}ms:`, error);
+      this.readyReject?.(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  createWebSocket(ipcPath) {
+    return new Promise((resolve, reject) => {
+      this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Creating WebSocket to IPC: ${ipcPath}`);
+      const agent = new http__default.default.Agent({
+        // @ts-expect-error: Node.js supports socketPath for Unix sockets
+        socketPath: ipcPath
+      });
+      const ws = new WebSocket2__default.default("ws://localhost/test", {
+        agent
+      });
+      ws.once("open", () => {
+        this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] WebSocket opened`);
+        resolve(ws);
+      });
+      ws.once("error", (err) => {
+        this.logger.error(`[mock-mcp] [${this.runId.slice(0, 8)}] WebSocket connection error:`, err);
+        reject(err);
+      });
+    });
+  }
+  setupWebSocket() {
+    if (!this.ws || !this.registry) {
+      this.logger.warn(`[mock-mcp] [${this.runId.slice(0, 8)}] setupWebSocket called but ws or registry is missing`);
+      return;
+    }
+    this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Setting up WebSocket event handlers...`);
+    this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}]   Current readyState: ${this.ws.readyState}`);
+    this.ws.on("message", (data) => this.handleMessage(data));
+    this.ws.on("error", (error) => {
+      this.logger.error(`[mock-mcp] [${this.runId.slice(0, 8)}] \u274C WebSocket ERROR:`, error);
+      this.logger.error(`[mock-mcp] [${this.runId.slice(0, 8)}]   authed: ${this.authed}`);
+      this.logger.error(`[mock-mcp] [${this.runId.slice(0, 8)}]   readyState: ${this.ws?.readyState}`);
+      if (!this.authed) {
+        this.readyReject?.(error instanceof Error ? error : new Error(String(error)));
+      }
+      this.failAllPending(error instanceof Error ? error : new Error(String(error)));
+    });
+    this.ws.on("close", (code, reason) => {
+      this.logger.warn(`[mock-mcp] [${this.runId.slice(0, 8)}] \u{1F50C} WebSocket CLOSE`);
+      this.logger.warn(`[mock-mcp] [${this.runId.slice(0, 8)}]   code: ${code}`);
+      this.logger.warn(`[mock-mcp] [${this.runId.slice(0, 8)}]   reason: ${reason?.toString() || "(none)"}`);
+      this.logger.warn(`[mock-mcp] [${this.runId.slice(0, 8)}]   authed: ${this.authed}`);
+      this.logger.warn(`[mock-mcp] [${this.runId.slice(0, 8)}]   closed: ${this.closed}`);
+      this.logger.warn(`[mock-mcp] [${this.runId.slice(0, 8)}]   enableReconnect: ${this.enableReconnect}`);
+      this.authed = false;
+      this.stopHeartbeat();
+      this.failAllPending(new Error(`Daemon connection closed (code: ${code})`));
+      if (!this.closed && this.enableReconnect) {
+        this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Will attempt reconnect...`);
+        this.scheduleReconnect();
+      }
+    });
+    this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] WebSocket event handlers configured`);
+    if (this.ws.readyState === WebSocket2__default.default.OPEN) {
+      this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] \u{1F50C} WebSocket already OPEN - sending HELLO`);
+      this.sendHello();
+    }
+  }
+  sendHello() {
+    if (!this.ws || !this.registry) {
+      this.logger.warn(`[mock-mcp] [${this.runId.slice(0, 8)}] sendHello called but ws or registry is missing`);
+      return;
+    }
+    this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Sending HELLO handshake...`);
+    this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}]   runId: ${this.runId}`);
+    this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}]   pid: ${process.pid}`);
+    this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}]   cwd: ${process.cwd()}`);
+    if (this.testMeta) {
+      this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}]   testFile: ${this.testMeta.testFile ?? "(none)"}`);
+      this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}]   testName: ${this.testMeta.testName ?? "(none)"}`);
+    }
+    const hello = {
+      type: HELLO_TEST,
+      token: this.registry.token,
+      runId: this.runId,
+      pid: process.pid,
+      cwd: process.cwd(),
+      testMeta: this.testMeta
+    };
+    this.ws.send(JSON.stringify(hello));
+    this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] HELLO sent, waiting for HELLO_ACK...`);
+  }
+  handleMessage(data) {
+    let msg;
+    try {
+      msg = JSON.parse(data.toString());
+    } catch {
+      this.logger.error(`[mock-mcp] [${this.runId.slice(0, 8)}] Failed to parse server message`);
+      return;
+    }
+    const msgType = msg?.type;
+    if (this.isHelloAck(msg)) {
+      this.authed = true;
+      this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] \u2705 Received HELLO_ACK - Authenticated!`);
+      this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}]   Connection is now READY`);
+      this.readyResolve?.();
+      this.startHeartbeat();
+      return;
+    }
+    if (this.isBatchMockResult(msg)) {
+      this.logger.log(
+        `[mock-mcp] [${this.runId.slice(0, 8)}] \u{1F4E6} Received BATCH_MOCK_RESULT`
+      );
+      this.logger.log(
+        `[mock-mcp] [${this.runId.slice(0, 8)}]   batchId: ${msg.batchId}`
+      );
+      this.logger.log(
+        `[mock-mcp] [${this.runId.slice(0, 8)}]   mocks count: ${msg.mocks.length}`
+      );
+      for (const mock of msg.mocks) {
+        this.logger.log(
+          `[mock-mcp] [${this.runId.slice(0, 8)}]   - ${mock.requestId}: status=${mock.status ?? 200}`
+        );
+        this.resolveRequest(mock);
+      }
+      return;
+    }
+    if (msgType === "HEARTBEAT_ACK") {
+      return;
+    }
+    this.logger.warn(`[mock-mcp] [${this.runId.slice(0, 8)}] Received unknown message type: ${msgType}`);
+  }
+  isHelloAck(msg) {
+    return msg !== null && typeof msg === "object" && msg.type === HELLO_ACK;
+  }
+  isBatchMockResult(msg) {
+    return msg !== null && typeof msg === "object" && msg.type === BATCH_MOCK_RESULT && Array.isArray(msg.mocks);
+  }
+  // ===========================================================================
+  // Request Management
+  // ===========================================================================
+  resolveRequest(mock) {
+    const pending = this.pendingRequests.get(mock.requestId);
+    if (!pending) {
+      this.logger.warn(`Received mock for unknown request: ${mock.requestId}`);
+      return;
+    }
+    clearTimeout(pending.timeoutId);
+    this.pendingRequests.delete(mock.requestId);
+    const resolve = () => pending.resolve(mock);
+    if (mock.delayMs && mock.delayMs > 0) {
+      setTimeout(resolve, mock.delayMs);
+    } else {
+      resolve();
+    }
+  }
+  rejectRequest(requestId, error) {
+    const pending = this.pendingRequests.get(requestId);
+    if (!pending) return;
+    clearTimeout(pending.timeoutId);
+    this.pendingRequests.delete(requestId);
+    pending.reject(error);
+  }
+  failAllPending(error) {
+    for (const requestId of Array.from(this.pendingRequests.keys())) {
+      this.rejectRequest(requestId, error);
+    }
+  }
+  // ===========================================================================
+  // Batching
+  // ===========================================================================
+  enqueueRequest(requestId) {
+    this.queuedRequestIds.add(requestId);
+    if (this.batchTimer) {
+      return;
+    }
+    this.batchTimer = setTimeout(() => {
+      this.batchTimer = null;
+      this.flushQueue();
+    }, this.batchDebounceMs);
+  }
+  flushQueue() {
+    const queuedIds = Array.from(this.queuedRequestIds);
+    this.queuedRequestIds.clear();
+    if (queuedIds.length === 0) {
+      return;
+    }
+    for (let i = 0; i < queuedIds.length; i += this.maxBatchSize) {
+      const chunkIds = queuedIds.slice(i, i + this.maxBatchSize);
+      const requests = [];
+      for (const id of chunkIds) {
+        const pending = this.pendingRequests.get(id);
+        if (pending) {
+          requests.push(pending.request);
+        }
+      }
+      if (requests.length > 0) {
+        this.sendBatch(requests);
+      }
+    }
+  }
+  sendBatch(requests) {
+    if (!this.ws || this.ws.readyState !== WebSocket2__default.default.OPEN) {
+      this.logger.error(`[mock-mcp] [${this.runId.slice(0, 8)}] Cannot send batch - WebSocket not open`);
+      this.logger.error(`[mock-mcp] [${this.runId.slice(0, 8)}]   ws exists: ${!!this.ws}`);
+      this.logger.error(`[mock-mcp] [${this.runId.slice(0, 8)}]   readyState: ${this.ws?.readyState}`);
+      const error = new Error("WebSocket is not open");
+      for (const req of requests) {
+        this.rejectRequest(req.requestId, error);
+      }
+      return;
+    }
+    const payload = {
+      type: BATCH_MOCK_REQUEST,
+      runId: this.runId,
+      requests
+    };
+    this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] \u{1F4E4} Sending BATCH_MOCK_REQUEST`);
+    this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}]   requests: ${requests.length}`);
+    for (const req of requests) {
+      this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}]   - ${req.requestId}: ${req.method} ${req.endpoint}`);
+    }
+    this.ws.send(JSON.stringify(payload));
+  }
+  // ===========================================================================
+  // Heartbeat
+  // ===========================================================================
+  startHeartbeat() {
+    if (this.heartbeatIntervalMs <= 0 || this.heartbeatTimer) {
+      return;
+    }
+    let lastPong = Date.now();
+    this.ws?.on("pong", () => {
+      lastPong = Date.now();
+    });
+    this.heartbeatTimer = setInterval(() => {
+      if (!this.ws || this.ws.readyState !== WebSocket2__default.default.OPEN) {
+        return;
+      }
+      const now = Date.now();
+      if (now - lastPong > this.heartbeatIntervalMs * 2) {
+        this.logger.warn("Heartbeat missed; closing socket to trigger reconnect...");
+        this.ws.close();
+        return;
+      }
+      this.ws.ping();
+    }, this.heartbeatIntervalMs);
+    this.heartbeatTimer.unref?.();
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  // ===========================================================================
+  // Reconnection
+  // ===========================================================================
+  scheduleReconnect() {
+    if (this.reconnectTimer) {
+      this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Reconnect already scheduled, skipping`);
+      return;
+    }
+    if (this.closed) {
+      this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Client is closed, not reconnecting`);
+      return;
+    }
+    this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Scheduling reconnect in 1000ms...`);
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      this.logger.warn(`[mock-mcp] [${this.runId.slice(0, 8)}] \u{1F504} Attempting reconnect to daemon...`);
+      this.stopHeartbeat();
+      this.resetReadyPromise();
+      this.authed = false;
+      const reconnectStartTime = Date.now();
+      try {
+        this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Re-discovering daemon...`);
+        this.registry = await ensureDaemonRunning({
+          projectRoot: this.projectRoot
+        });
+        this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Daemon found, creating new WebSocket...`);
+        this.ws = await this.createWebSocket(this.registry.ipcPath);
+        this.setupWebSocket();
+        const elapsed = Date.now() - reconnectStartTime;
+        this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] \u2705 Reconnect successful (${elapsed}ms)`);
+      } catch (error) {
+        const elapsed = Date.now() - reconnectStartTime;
+        this.logger.error(`[mock-mcp] [${this.runId.slice(0, 8)}] \u274C Reconnection failed after ${elapsed}ms:`, error);
+        this.logger.log(`[mock-mcp] [${this.runId.slice(0, 8)}] Will retry reconnect...`);
+        this.scheduleReconnect();
+      }
+    }, 1e3);
+    this.reconnectTimer.unref?.();
+  }
+  // ===========================================================================
+  // Utilities
+  // ===========================================================================
+  resetReadyPromise() {
+    this.readyPromise = new Promise((resolve, reject) => {
+      this.readyResolve = resolve;
+      this.readyReject = reject;
+    });
+  }
+  buildResolvedMock(mock) {
+    return {
+      requestId: mock.requestId,
+      data: mock.data,
+      status: mock.status,
+      headers: mock.headers,
+      delayMs: mock.delayMs
+    };
+  }
+  // ===========================================================================
+  // Public Getters
+  // ===========================================================================
+  /**
+   * Get the run ID for this collector instance.
+   */
+  getRunId() {
+    return this.runId;
+  }
+  /**
+   * Get the daemon registry information (after connection).
+   */
+  getRegistry() {
+    return this.registry;
+  }
+};
+
+// src/client/connect.ts
+var DisabledMockClient = class {
+  runId = "disabled";
+  async waitUntilReady() {
+    return;
+  }
+  async requestMock() {
+    throw new Error(
+      "[mock-mcp] MOCK_MCP is not enabled. Set MOCK_MCP=1 to enable mock generation."
+    );
+  }
+  async waitForPendingRequests() {
+    return;
+  }
+  async close() {
+    return;
+  }
+  getRunId() {
+    return this.runId;
+  }
+};
+var connect = async (options) => {
+  const logger = options?.logger ?? console;
+  const startTime = Date.now();
+  logger.log("[mock-mcp] connect() called");
+  logger.log(`[mock-mcp]   PID: ${process.pid}`);
+  logger.log(`[mock-mcp]   CWD: ${process.cwd()}`);
+  logger.log(`[mock-mcp]   MOCK_MCP env: ${process.env.MOCK_MCP ?? "(not set)"}`);
+  if (!isEnabled()) {
+    logger.log("[mock-mcp] Skipping (set MOCK_MCP=1 to enable)");
+    return new DisabledMockClient();
+  }
+  logger.log("[mock-mcp] Creating BatchMockCollector...");
+  const collector = new BatchMockCollector(options ?? {});
+  const runId = collector.getRunId();
+  logger.log(`[mock-mcp] Run ID: ${runId}`);
+  logger.log("[mock-mcp] Waiting for connection to be ready...");
+  try {
+    await collector.waitUntilReady();
+    const elapsed = Date.now() - startTime;
+    const registry = collector.getRegistry();
+    logger.log("[mock-mcp] ========== Connection Established ==========");
+    logger.log(`[mock-mcp]   Run ID: ${runId}`);
+    logger.log(`[mock-mcp]   Daemon PID: ${registry?.pid ?? "unknown"}`);
+    logger.log(`[mock-mcp]   Project ID: ${registry?.projectId ?? "unknown"}`);
+    logger.log(`[mock-mcp]   IPC Path: ${registry?.ipcPath ?? "unknown"}`);
+    logger.log(`[mock-mcp]   Connection time: ${elapsed}ms`);
+    logger.log("[mock-mcp] ==============================================");
+    return collector;
+  } catch (error) {
+    const elapsed = Date.now() - startTime;
+    logger.error("[mock-mcp] ========== Connection Failed ==========");
+    logger.error(`[mock-mcp]   Run ID: ${runId}`);
+    logger.error(`[mock-mcp]   Error: ${error instanceof Error ? error.message : String(error)}`);
+    logger.error(`[mock-mcp]   Elapsed time: ${elapsed}ms`);
+    logger.error("[mock-mcp] =========================================");
+    throw error;
+  }
+};
+
+// src/index.ts
+init_discovery();
+async function runCli() {
+  const args = process2__default.default.argv.slice(2);
+  const command = args[0] ?? "adapter";
+  switch (command) {
+    case "adapter":
+      await runAdapterCommand(args.slice(1));
+      break;
+    case "daemon":
+      await runDaemonCommand(args.slice(1));
+      break;
+    case "status":
+      await runStatusCommand(args.slice(1));
+      break;
+    case "stop":
+      await runStopCommand(args.slice(1));
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+      printHelp();
+      break;
+    case "version":
+    case "--version":
+    case "-v":
+      await printVersion();
+      break;
+    default:
+      await runAdapterCommand();
+  }
+}
+async function runAdapterCommand(_args) {
+  const { runAdapter: runAdapter2 } = await Promise.resolve().then(() => (init_adapter(), adapter_exports));
+  await runAdapter2();
+}
+async function runDaemonCommand(args) {
+  const { MockMcpDaemon: MockMcpDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+  const { resolveProjectRoot: resolveProjectRoot2 } = await Promise.resolve().then(() => (init_discovery(), discovery_exports));
+  let projectRoot;
+  let token;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--project-root" && args[i + 1]) {
+      projectRoot = args[i + 1];
+      i++;
+    } else if (arg === "--token" && args[i + 1]) {
+      token = args[i + 1];
+      i++;
+    }
+  }
+  projectRoot = projectRoot ?? resolveProjectRoot2();
+  const cacheDir = process2__default.default.env.MOCK_MCP_CACHE_DIR || void 0;
+  if (!token) {
+    console.error("Error: --token is required for daemon mode");
+    process2__default.default.exitCode = 1;
+    return;
+  }
+  const version = await getVersion();
+  const daemon = new MockMcpDaemon2({
+    projectRoot,
+    token,
+    version,
+    cacheDir
+  });
+  await daemon.start();
+  const shutdown = async (signal) => {
+    console.error(`
+${signal} received, shutting down...`);
+    await daemon.stop();
+    process2__default.default.exit(0);
+  };
+  process2__default.default.on("SIGINT", () => shutdown("SIGINT"));
+  process2__default.default.on("SIGTERM", () => shutdown("SIGTERM"));
+}
+async function runStatusCommand(_args) {
+  const {
+    resolveProjectRoot: resolveProjectRoot2,
+    computeProjectId: computeProjectId2,
+    getPaths: getPaths2,
+    readRegistry: readRegistry2
+  } = await Promise.resolve().then(() => (init_discovery(), discovery_exports));
+  const projectRoot = resolveProjectRoot2();
+  const projectId = computeProjectId2(projectRoot);
+  const { registryPath, ipcPath } = getPaths2(projectId);
+  console.log(`Project Root: ${projectRoot}`);
+  console.log(`Project ID: ${projectId}`);
+  console.log(`IPC Path: ${ipcPath}`);
+  console.log("");
+  const registry = await readRegistry2(registryPath);
+  if (!registry) {
+    console.log("\u274C Daemon is not running (no registry found)");
+    return;
+  }
+  console.log(`Registry PID: ${registry.pid}`);
+  console.log(`Started At: ${registry.startedAt}`);
+  console.log("");
+  try {
+    const status = await getDaemonStatus(ipcPath, registry.token);
+    console.log("\u2705 Daemon is running\n");
+    console.log(`Version: ${status.version}`);
+    console.log(`Uptime: ${Math.round(status.uptime / 1e3)}s`);
+    console.log(`Active Runs: ${status.runs}`);
+    console.log(`Pending Batches: ${status.pending}`);
+    console.log(`Claimed Batches: ${status.claimed}`);
+  } catch (error) {
+    console.log("\u274C Daemon is not responding");
+    console.log(`   ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function getDaemonStatus(ipcPath, token) {
+  return new Promise((resolve, reject) => {
+    const payload = JSON.stringify({
+      jsonrpc: "2.0",
+      id: "status",
+      method: "getStatus",
+      params: {}
+    });
+    const req = http__default.default.request(
+      {
+        method: "POST",
+        socketPath: ipcPath,
+        path: "/control",
+        headers: {
+          "content-type": "application/json",
+          "x-mock-mcp-token": token
+        },
+        timeout: 5e3
+      },
+      (res) => {
+        let buf = "";
+        res.on("data", (c) => buf += c);
+        res.on("end", () => {
+          try {
+            const result = JSON.parse(buf);
+            if (result.error) {
+              reject(new Error(result.error.message));
+            } else {
+              resolve(result.result);
+            }
+          } catch (e) {
+            reject(e);
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timeout"));
+    });
+    req.end(payload);
+  });
+}
+async function runStopCommand(_args) {
+  const {
+    resolveProjectRoot: resolveProjectRoot2,
+    computeProjectId: computeProjectId2,
+    getPaths: getPaths2,
+    readRegistry: readRegistry2
+  } = await Promise.resolve().then(() => (init_discovery(), discovery_exports));
+  const projectRoot = resolveProjectRoot2();
+  const projectId = computeProjectId2(projectRoot);
+  const { registryPath, ipcPath } = getPaths2(projectId);
+  const registry = await readRegistry2(registryPath);
+  if (!registry) {
+    console.log("Daemon is not running.");
+    return;
+  }
+  try {
+    process2__default.default.kill(registry.pid, "SIGTERM");
+    console.log(`Sent SIGTERM to daemon (PID: ${registry.pid})`);
+    await new Promise((r) => setTimeout(r, 1e3));
+    try {
+      process2__default.default.kill(registry.pid, 0);
+      console.log("Daemon is still running, sending SIGKILL...");
+      process2__default.default.kill(registry.pid, "SIGKILL");
+    } catch {
+    }
+  } catch (error) {
+    console.log(`Daemon process (PID: ${registry.pid}) is not running.`);
+  }
+  try {
+    await fs__default.default.rm(registryPath);
+    console.log("Registry cleaned up.");
+  } catch {
+  }
+  if (process2__default.default.platform !== "win32") {
+    try {
+      await fs__default.default.rm(ipcPath);
+      console.log("Socket cleaned up.");
+    } catch {
+    }
+  }
+  console.log("Done.");
+}
+function printHelp() {
+  console.log(`
+mock-mcp - AI-assisted mock generation for integration tests
+
+USAGE:
+  mock-mcp [command] [options]
+
+COMMANDS:
+  adapter     Start the MCP adapter (default)
+              This is what you configure in your MCP client.
+
+  daemon      Start the daemon process
+              Usually auto-started by adapter/test code.
+
+  status      Show daemon status for current project
+
+  stop        Stop the daemon for current project
+
+  help        Show this help message
+
+  version     Show version
+
+EXAMPLES:
+  # In your MCP client configuration (Cursor, Claude Desktop, etc.):
+  {
+    "mcpServers": {
+      "mock-mcp": {
+        "command": "npx",
+        "args": ["-y", "mock-mcp", "adapter"]
+      }
+    }
+  }
+
+  # Check daemon status:
+  mock-mcp status
+
+  # Stop daemon:
+  mock-mcp stop
+
+ENVIRONMENT:
+  MOCK_MCP=1              Enable mock generation in test code
+  MOCK_MCP_CACHE_DIR      Override cache directory for daemon files
+
+For more information, visit: https://github.com/mcpland/mock-mcp
+`);
+}
+async function printVersion() {
+  const version = await getVersion();
+  console.log(`mock-mcp v${version}`);
+}
+async function getVersion() {
+  return "0.5.0";
+}
+var isCliExecution = (() => {
+  if (typeof process2__default.default === "undefined" || !process2__default.default.argv?.[1]) {
+    return false;
+  }
+  const scriptPath = fssync.realpathSync(process2__default.default.argv[1]);
+  return __importMetaUrl === url.pathToFileURL(scriptPath).href;
+})();
+if (isCliExecution) {
+  runCli().catch((error) => {
+    console.error("Error:", error instanceof Error ? error.message : error);
+    process2__default.default.exitCode = 1;
+  });
+}
+
+exports.BatchMockCollector = BatchMockCollector;
+exports.computeProjectId = computeProjectId;
+exports.connect = connect;
+exports.ensureDaemonRunning = ensureDaemonRunning;
+exports.resolveProjectRoot = resolveProjectRoot;
+exports.runAdapter = runAdapter;