mock-mcp 0.3.1 → 0.5.0

package/dist/client/index.js

@@ -1,2 +1,873 @@
-export { BatchMockCollector, } from "./batch-mock-collector.js";
-export { connect } from "./connect.js";
+import http from 'http';
+import path from 'path';
+import crypto from 'crypto';
+import { fileURLToPath, pathToFileURL } from 'url';
+import WebSocket from 'ws';
+import fs from 'fs/promises';
+import fssync from 'fs';
+import os from 'os';
+import { spawn } from 'child_process';
+import { createRequire } from 'module';
+
+// src/client/batch-mock-collector.ts
+function debugLog(_msg) {
+}
+var __curDirname = (() => {
+  try {
+    const metaUrl = import.meta.url;
+    if (metaUrl && typeof metaUrl === "string" && metaUrl.startsWith("file://")) {
+      return path.dirname(fileURLToPath(metaUrl));
+    }
+  } catch {
+  }
+  return process.cwd();
+})();
+function resolveProjectRoot(startDir = process.cwd()) {
+  let current = path.resolve(startDir);
+  const root = path.parse(current).root;
+  while (current !== root) {
+    const gitPath = path.join(current, ".git");
+    try {
+      const stat = fssync.statSync(gitPath);
+      if (stat.isDirectory() || stat.isFile()) {
+        return current;
+      }
+    } catch {
+    }
+    const pkgPath = path.join(current, "package.json");
+    try {
+      fssync.accessSync(pkgPath, fssync.constants.F_OK);
+      return current;
+    } catch {
+    }
+    current = path.dirname(current);
+  }
+  return path.resolve(startDir);
+}
+function computeProjectId(projectRoot) {
+  const real = fssync.realpathSync(projectRoot);
+  return crypto.createHash("sha256").update(real).digest("hex").slice(0, 16);
+}
+function getCacheDir(override) {
+  if (override) {
+    return override;
+  }
+  const envCacheDir = process.env.MOCK_MCP_CACHE_DIR;
+  if (envCacheDir) {
+    return envCacheDir;
+  }
+  const xdg = process.env.XDG_CACHE_HOME;
+  if (xdg) {
+    return xdg;
+  }
+  if (process.platform === "win32" && process.env.LOCALAPPDATA) {
+    return process.env.LOCALAPPDATA;
+  }
+  const home = os.homedir();
+  if (home) {
+    return path.join(home, ".cache");
+  }
+  return os.tmpdir();
+}
+function getPaths(projectId, cacheDir) {
+  const base = path.join(getCacheDir(cacheDir), "mock-mcp");
+  const registryPath = path.join(base, `${projectId}.json`);
+  const lockPath = path.join(base, `${projectId}.lock`);
+  const ipcPath = process.platform === "win32" ? `\\\\.\\pipe\\mock-mcp-${projectId}` : path.join(base, `${projectId}.sock`);
+  return { base, registryPath, lockPath, ipcPath };
+}
+async function readRegistry(registryPath) {
+  try {
+    const txt = await fs.readFile(registryPath, "utf-8");
+    return JSON.parse(txt);
+  } catch (error) {
+    debugLog(`readRegistry error for ${registryPath}: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
+async function healthCheck(ipcPath, timeoutMs = 2e3) {
+  return new Promise((resolve) => {
+    const req = http.request(
+      {
+        method: "GET",
+        socketPath: ipcPath,
+        path: "/health",
+        timeout: timeoutMs
+      },
+      (res) => {
+        resolve(res.statusCode === 200);
+      }
+    );
+    req.on("error", () => resolve(false));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(false);
+    });
+    req.end();
+  });
+}
+async function tryAcquireLock(lockPath) {
+  try {
+    const fh = await fs.open(lockPath, "wx");
+    await fh.write(`${process.pid}
+`);
+    return fh;
+  } catch {
+    return null;
+  }
+}
+async function releaseLock(lockPath, fh) {
+  await fh.close();
+  await fs.rm(lockPath).catch(() => {
+  });
+}
+function randomToken() {
+  return crypto.randomBytes(24).toString("base64url");
+}
+function getDaemonEntryPath() {
+  try {
+    const cwdRequire = createRequire(pathToFileURL(path.join(process.cwd(), "index.js")).href);
+    const resolved = cwdRequire.resolve("mock-mcp");
+    const distDir = path.dirname(resolved);
+    const daemonEntry = path.join(distDir, "index.js");
+    if (fssync.existsSync(daemonEntry)) {
+      return daemonEntry;
+    }
+  } catch {
+  }
+  try {
+    const packageRoot = resolveProjectRoot(__curDirname);
+    const distPath = path.join(packageRoot, "dist", "index.js");
+    if (fssync.existsSync(distPath)) {
+      return distPath;
+    }
+  } catch {
+  }
+  if (process.argv[1]) {
+    return process.argv[1];
+  }
+  return path.join(process.cwd(), "dist", "index.js");
+}
+async function ensureDaemonRunning(opts = {}) {
+  const projectRoot = opts.projectRoot ?? resolveProjectRoot();
+  const projectId = computeProjectId(projectRoot);
+  const { base, registryPath, lockPath, ipcPath } = getPaths(
+    projectId,
+    opts.cacheDir
+  );
+  const timeoutMs = opts.timeoutMs ?? 1e4;
+  await fs.mkdir(base, { recursive: true });
+  const existing = await readRegistry(registryPath);
+  debugLog(`Registry read result: ${existing ? "Found (PID " + existing.pid + ")" : "Null"}`);
+  if (existing) {
+    let healthy = false;
+    for (let i = 0; i < 3; i++) {
+      debugLog(`Checking health attempt ${i + 1}/3 on ${existing.ipcPath}`);
+      healthy = await healthCheck(existing.ipcPath);
+      if (healthy) break;
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    if (healthy) {
+      return existing;
+    }
+  }
+  if (process.platform !== "win32") {
+    try {
+      await fs.rm(ipcPath);
+    } catch {
+    }
+  }
+  const lock = await tryAcquireLock(lockPath);
+  if (lock) {
+    try {
+      const recheckReg = await readRegistry(registryPath);
+      if (recheckReg && await healthCheck(recheckReg.ipcPath)) {
+        return recheckReg;
+      }
+      const token = randomToken();
+      const daemonEntry = getDaemonEntryPath();
+      const child = spawn(
+        process.execPath,
+        [daemonEntry, "daemon", "--project-root", projectRoot, "--token", token],
+        {
+          detached: true,
+          stdio: ["ignore", "pipe", "pipe"],
+          env: {
+            ...process.env,
+            MOCK_MCP_CACHE_DIR: opts.cacheDir ?? ""
+          }
+        }
+      );
+      let daemonStderr = "";
+      let daemonStdout = "";
+      child.stdout?.on("data", (data) => {
+        const str = data.toString();
+        debugLog(`Daemon stdout: ${str}`);
+      });
+      child.stderr?.on("data", (data) => {
+        daemonStderr += data.toString();
+        debugLog(`Daemon stderr: ${data.toString()}`);
+      });
+      child.on("error", (err) => {
+        console.error(`[mock-mcp] Daemon spawn error: ${err.message}`);
+      });
+      child.on("exit", (code, signal) => {
+        if (code !== null && code !== 0) {
+          console.error(`[mock-mcp] Daemon exited with code: ${code}`);
+          if (daemonStderr) {
+            console.error(`[mock-mcp] Daemon stderr: ${daemonStderr.slice(0, 500)}`);
+          }
+        } else if (signal) {
+          console.error(`[mock-mcp] Daemon killed by signal: ${signal}`);
+        }
+      });
+      child.unref();
+      const deadline2 = Date.now() + timeoutMs;
+      while (Date.now() < deadline2) {
+        const reg = await readRegistry(registryPath);
+        if (reg && await healthCheck(reg.ipcPath)) {
+          return reg;
+        }
+        await sleep(50);
+      }
+      console.error("[mock-mcp] Daemon failed to start within timeout");
+      if (daemonStderr) {
+        console.error(`[mock-mcp] Daemon stderr:
+${daemonStderr}`);
+      }
+      throw new Error(
+        `Daemon start timeout after ${timeoutMs}ms. Check logs for details.`
+      );
+    } finally {
+      await releaseLock(lockPath, lock);
+    }
+  }
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const reg = await readRegistry(registryPath);
+    if (reg && await healthCheck(reg.ipcPath)) {
+      return reg;
+    }
+    await sleep(50);
+  }
+  throw new Error(
+    `Waiting for daemon timed out after ${timeoutMs}ms. Another process may have failed to start it.`
+  );
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/shared/protocol.ts
+var HELLO_TEST = "HELLO_TEST";
+var HELLO_ACK = "HELLO_ACK";
+var BATCH_MOCK_REQUEST = "BATCH_MOCK_REQUEST";
+var BATCH_MOCK_RESULT = "BATCH_MOCK_RESULT";
+
+// 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.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 = fileURLToPath(filePath);
+        } catch {
+          filePath = filePath.replace(/^file:\/\//, "");
+        }
+      }
+      const dir = path.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.Agent({
+        // @ts-expect-error: Node.js supports socketPath for Unix sockets
+        socketPath: ipcPath
+      });
+      const ws = new WebSocket("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 === WebSocket.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 !== WebSocket.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 !== WebSocket.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;
+  }
+};
+
+export { BatchMockCollector, connect };