mock-mcp 0.3.1 → 0.5.1

package/dist/daemon/index.js

@@ -0,0 +1,678 @@
+import http2 from 'http';
+import fs from 'fs/promises';
+import crypto from 'crypto';
+import { WebSocketServer, WebSocket } from 'ws';
+import fssync from 'fs';
+import os from 'os';
+import path from 'path';
+import 'child_process';
+import { fileURLToPath } from 'url';
+import 'module';
+
+// src/daemon/daemon.ts
+function debugLog(_msg) {
+}
+(() => {
+  try {
+    const metaUrl = import.meta.url;
+    if (metaUrl && typeof metaUrl === "string" && metaUrl.startsWith("file://")) {
+      return path.dirname(fileURLToPath(metaUrl));
+    }
+  } catch {
+  }
+  return process.cwd();
+})();
+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 writeRegistry(registryPath, registry) {
+  await fs.writeFile(registryPath, JSON.stringify(registry, null, 2), {
+    encoding: "utf-8",
+    mode: 384
+    // Read/write for owner only
+  });
+}
+function getGlobalIndexPath(cacheDir) {
+  const base = path.join(getCacheDir(cacheDir), "mock-mcp");
+  return path.join(base, "active-daemons.json");
+}
+async function readGlobalIndex(cacheDir) {
+  const indexPath = getGlobalIndexPath(cacheDir);
+  try {
+    const txt = await fs.readFile(indexPath, "utf-8");
+    return JSON.parse(txt);
+  } catch {
+    return { daemons: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+async function writeGlobalIndex(index, cacheDir) {
+  const indexPath = getGlobalIndexPath(cacheDir);
+  const base = path.dirname(indexPath);
+  await fs.mkdir(base, { recursive: true });
+  await fs.writeFile(indexPath, JSON.stringify(index, null, 2), {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+async function registerDaemonGlobally(entry, cacheDir) {
+  const index = await readGlobalIndex(cacheDir);
+  index.daemons = index.daemons.filter((d) => d.projectId !== entry.projectId);
+  index.daemons.push(entry);
+  index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeGlobalIndex(index, cacheDir);
+  debugLog(`Registered daemon ${entry.projectId} in global index`);
+}
+async function unregisterDaemonGlobally(projectId, cacheDir) {
+  const index = await readGlobalIndex(cacheDir);
+  index.daemons = index.daemons.filter((d) => d.projectId !== projectId);
+  index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeGlobalIndex(index, cacheDir);
+}
+
+// src/shared/protocol.ts
+var HELLO_TEST = "HELLO_TEST";
+var HELLO_ACK = "HELLO_ACK";
+var BATCH_MOCK_REQUEST = "BATCH_MOCK_REQUEST";
+var BATCH_MOCK_RESULT = "BATCH_MOCK_RESULT";
+var HEARTBEAT = "HEARTBEAT";
+var HEARTBEAT_ACK = "HEARTBEAT_ACK";
+var RPC_GET_STATUS = "getStatus";
+var RPC_LIST_RUNS = "listRuns";
+var RPC_CLAIM_NEXT_BATCH = "claimNextBatch";
+var RPC_PROVIDE_BATCH = "provideBatch";
+var RPC_RELEASE_BATCH = "releaseBatch";
+var RPC_GET_BATCH = "getBatch";
+var RPC_ERROR_METHOD_NOT_FOUND = -32601;
+var RPC_ERROR_INTERNAL = -32603;
+var RPC_ERROR_NOT_FOUND = -32e3;
+var RPC_ERROR_UNAUTHORIZED = -32001;
+var RPC_ERROR_CONFLICT = -32002;
+var RPC_ERROR_EXPIRED = -32003;
+function isHelloTestMessage(msg) {
+  if (!msg || typeof msg !== "object") return false;
+  const m = msg;
+  return m.type === HELLO_TEST && typeof m.token === "string" && typeof m.runId === "string" && typeof m.pid === "number" && typeof m.cwd === "string";
+}
+function isBatchMockRequestMessage(msg) {
+  if (!msg || typeof msg !== "object") return false;
+  const m = msg;
+  return m.type === BATCH_MOCK_REQUEST && typeof m.runId === "string" && Array.isArray(m.requests);
+}
+function isHeartbeatMessage(msg) {
+  if (!msg || typeof msg !== "object") return false;
+  const m = msg;
+  return m.type === HEARTBEAT && typeof m.runId === "string";
+}
+function isJsonRpcRequest(msg) {
+  if (!msg || typeof msg !== "object") return false;
+  const m = msg;
+  return m.jsonrpc === "2.0" && (typeof m.id === "string" || typeof m.id === "number") && typeof m.method === "string";
+}
+
+// src/daemon/daemon.ts
+var 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.mkdir(base, { recursive: true });
+    if (process.platform !== "win32") {
+      try {
+        await fs.rm(ipcPath);
+      } catch {
+      }
+    }
+    const server = http2.createServer((req, res) => this.handleHttp(req, res));
+    this.server = server;
+    const wss = new 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);
+    const globalEntry = {
+      projectId,
+      projectRoot: this.opts.projectRoot,
+      ipcPath,
+      registryPath,
+      pid: process.pid,
+      startedAt: registry.startedAt,
+      version: this.opts.version
+    };
+    await registerDaemonGlobally(globalEntry, this.opts.cacheDir);
+    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;
+    const projectId = computeProjectId(this.opts.projectRoot);
+    await unregisterDaemonGlobally(projectId, this.opts.cacheDir);
+    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.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 !== 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?.();
+    }
+  }
+};
+var RpcError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "RpcError";
+  }
+};
+
+export { MockMcpDaemon };