mock-mcp 0.3.1 → 0.5.1

package/dist/adapter/index.cjs

@@ -0,0 +1,875 @@
+'use strict';
+
+var index_js = require('@modelcontextprotocol/sdk/server/index.js');
+var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
+var types_js = require('@modelcontextprotocol/sdk/types.js');
+var http = require('http');
+var crypto2 = require('crypto');
+var fs = require('fs/promises');
+require('fs');
+var os = require('os');
+var path = require('path');
+require('child_process');
+var url = require('url');
+require('module');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var http__default = /*#__PURE__*/_interopDefault(http);
+var crypto2__default = /*#__PURE__*/_interopDefault(crypto2);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var os__default = /*#__PURE__*/_interopDefault(os);
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+var __importMetaUrl = (function() {
+  if (typeof document !== 'undefined') {
+    return document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+  }
+  // Node.js CJS context
+  // When this bundle is re-bundled by another tool (e.g., esbuild, webpack),
+  // __filename may not be defined or may not be a valid file path.
+  // We need to handle these cases gracefully.
+  try {
+    if (typeof __filename !== 'undefined' && __filename) {
+      var url = require('url');
+      var path = require('path');
+      // Check if __filename looks like a valid file path
+      if (path.isAbsolute(__filename) || __filename.startsWith('./') || __filename.startsWith('../')) {
+        return url.pathToFileURL(__filename).href;
+      }
+    }
+  } catch (e) {
+    // Fallback if pathToFileURL fails
+  }
+  // Fallback: use process.cwd() as the base URL
+  // This is not perfect but allows the code to continue working
+  try {
+    var url = require('url');
+    return url.pathToFileURL(require('path').join(process.cwd(), 'index.cjs')).href;
+  } catch (e) {
+    return 'file:///unknown';
+  }
+})();
+function debugLog(_msg) {
+}
+(() => {
+  try {
+    const metaUrl = __importMetaUrl;
+    if (metaUrl && typeof metaUrl === "string" && metaUrl.startsWith("file://")) {
+      return path__default.default.dirname(url.fileURLToPath(metaUrl));
+    }
+  } catch {
+  }
+  return process.cwd();
+})();
+function 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();
+}
+async function readRegistry(registryPath) {
+  try {
+    const txt = await fs__default.default.readFile(registryPath, "utf-8");
+    return JSON.parse(txt);
+  } catch (error) {
+    debugLog(`readRegistry error for ${registryPath}: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
+async function healthCheck(ipcPath, timeoutMs = 2e3) {
+  return new Promise((resolve) => {
+    const req = http__default.default.request(
+      {
+        method: "GET",
+        socketPath: ipcPath,
+        path: "/health",
+        timeout: timeoutMs
+      },
+      (res) => {
+        resolve(res.statusCode === 200);
+      }
+    );
+    req.on("error", () => resolve(false));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(false);
+    });
+    req.end();
+  });
+}
+function getGlobalIndexPath(cacheDir) {
+  const base = path__default.default.join(getCacheDir(cacheDir), "mock-mcp");
+  return path__default.default.join(base, "active-daemons.json");
+}
+async function readGlobalIndex(cacheDir) {
+  const indexPath = getGlobalIndexPath(cacheDir);
+  try {
+    const txt = await fs__default.default.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__default.default.dirname(indexPath);
+  await fs__default.default.mkdir(base, { recursive: true });
+  await fs__default.default.writeFile(indexPath, JSON.stringify(index, null, 2), {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+async function cleanupGlobalIndex(cacheDir) {
+  const index = await readGlobalIndex(cacheDir);
+  const validDaemons = [];
+  for (const entry of index.daemons) {
+    try {
+      process.kill(entry.pid, 0);
+      const healthy = await healthCheck(entry.ipcPath, 1e3);
+      if (healthy) {
+        validDaemons.push(entry);
+      } else {
+        debugLog(`Removing unhealthy daemon ${entry.projectId} (pid ${entry.pid})`);
+      }
+    } catch {
+      debugLog(`Removing dead daemon ${entry.projectId} (pid ${entry.pid})`);
+    }
+  }
+  if (validDaemons.length !== index.daemons.length) {
+    index.daemons = validDaemons;
+    index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await writeGlobalIndex(index, cacheDir);
+  }
+}
+async function discoverAllDaemons(cacheDir) {
+  await cleanupGlobalIndex(cacheDir);
+  const index = await readGlobalIndex(cacheDir);
+  const results = [];
+  for (const entry of index.daemons) {
+    const registry = await readRegistry(entry.registryPath);
+    if (registry) {
+      const healthy = await healthCheck(entry.ipcPath, 2e3);
+      results.push({ registry, healthy });
+    }
+  }
+  return results;
+}
+
+// src/adapter/multi-daemon-client.ts
+var MultiDaemonClient = class {
+  logger;
+  cacheDir;
+  adapterId;
+  constructor(opts = {}) {
+    this.logger = opts.logger ?? console;
+    this.cacheDir = opts.cacheDir;
+    this.adapterId = crypto2__default.default.randomUUID();
+  }
+  // ===========================================================================
+  // Discovery
+  // ===========================================================================
+  /**
+   * Discover all active and healthy daemons.
+   */
+  async discoverDaemons() {
+    return discoverAllDaemons(this.cacheDir);
+  }
+  // ===========================================================================
+  // Aggregated RPC Methods
+  // ===========================================================================
+  /**
+   * Get aggregated status from all daemons.
+   */
+  async getAggregatedStatus() {
+    const daemons = await this.discoverDaemons();
+    const statuses = [];
+    let totalRuns = 0;
+    let totalPending = 0;
+    let totalClaimed = 0;
+    for (const { registry, healthy } of daemons) {
+      if (!healthy) {
+        statuses.push({
+          version: registry.version,
+          projectId: registry.projectId,
+          projectRoot: registry.projectRoot,
+          pid: registry.pid,
+          uptime: 0,
+          runs: 0,
+          pending: 0,
+          claimed: 0,
+          totalBatches: 0,
+          healthy: false
+        });
+        continue;
+      }
+      try {
+        const status = await this.rpc(registry, "getStatus", {});
+        statuses.push({ ...status, healthy: true });
+        totalRuns += status.runs;
+        totalPending += status.pending;
+        totalClaimed += status.claimed;
+      } catch (error) {
+        this.logger.warn(`Failed to get status from daemon ${registry.projectId}: ${error}`);
+        statuses.push({
+          version: registry.version,
+          projectId: registry.projectId,
+          projectRoot: registry.projectRoot,
+          pid: registry.pid,
+          uptime: 0,
+          runs: 0,
+          pending: 0,
+          claimed: 0,
+          totalBatches: 0,
+          healthy: false
+        });
+      }
+    }
+    return { daemons: statuses, totalRuns, totalPending, totalClaimed };
+  }
+  /**
+   * List all runs across all daemons.
+   */
+  async listAllRuns() {
+    const daemons = await this.discoverDaemons();
+    const allRuns = [];
+    for (const { registry, healthy } of daemons) {
+      if (!healthy) continue;
+      try {
+        const result = await this.rpc(registry, "listRuns", {});
+        for (const run of result.runs) {
+          allRuns.push({
+            ...run,
+            projectId: registry.projectId,
+            projectRoot: registry.projectRoot
+          });
+        }
+      } catch (error) {
+        this.logger.warn(`Failed to list runs from daemon ${registry.projectId}: ${error}`);
+      }
+    }
+    return allRuns;
+  }
+  /**
+   * Claim the next available batch from any daemon.
+   * Searches through all daemons in order until finding one with a pending batch.
+   */
+  async claimNextBatch(args) {
+    const daemons = await this.discoverDaemons();
+    for (const { registry, healthy } of daemons) {
+      if (!healthy) continue;
+      try {
+        const result = await this.rpc(registry, "claimNextBatch", {
+          adapterId: this.adapterId,
+          runId: args.runId,
+          leaseMs: args.leaseMs
+        });
+        if (result) {
+          return {
+            ...result,
+            projectId: registry.projectId,
+            projectRoot: registry.projectRoot
+          };
+        }
+      } catch (error) {
+        this.logger.warn(`Failed to claim batch from daemon ${registry.projectId}: ${error}`);
+      }
+    }
+    return null;
+  }
+  /**
+   * Provide mock data for a batch.
+   * Automatically routes to the correct daemon based on batchId.
+   */
+  async provideBatch(args) {
+    const parts = args.batchId.split(":");
+    if (parts.length < 2) {
+      return { ok: false, message: `Invalid batchId format: ${args.batchId}` };
+    }
+    const daemons = await this.discoverDaemons();
+    for (const { registry, healthy } of daemons) {
+      if (!healthy) continue;
+      try {
+        const result = await this.rpc(registry, "provideBatch", {
+          adapterId: this.adapterId,
+          batchId: args.batchId,
+          claimToken: args.claimToken,
+          mocks: args.mocks
+        });
+        return result;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes("not found") || msg.includes("Not found")) {
+          continue;
+        }
+        return { ok: false, message: msg };
+      }
+    }
+    return { ok: false, message: `Batch not found: ${args.batchId}` };
+  }
+  /**
+   * Release a batch.
+   */
+  async releaseBatch(args) {
+    const daemons = await this.discoverDaemons();
+    for (const { registry, healthy } of daemons) {
+      if (!healthy) continue;
+      try {
+        const result = await this.rpc(registry, "releaseBatch", {
+          adapterId: this.adapterId,
+          batchId: args.batchId,
+          claimToken: args.claimToken,
+          reason: args.reason
+        });
+        return result;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes("not found") || msg.includes("Not found")) {
+          continue;
+        }
+        return { ok: false, message: msg };
+      }
+    }
+    return { ok: false, message: `Batch not found: ${args.batchId}` };
+  }
+  /**
+   * Get a specific batch by ID.
+   */
+  async getBatch(batchId) {
+    const daemons = await this.discoverDaemons();
+    for (const { registry, healthy } of daemons) {
+      if (!healthy) continue;
+      try {
+        const result = await this.rpc(registry, "getBatch", { batchId });
+        return result;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes("not found") || msg.includes("Not found")) {
+          continue;
+        }
+        throw error;
+      }
+    }
+    return null;
+  }
+  // ===========================================================================
+  // Internal RPC
+  // ===========================================================================
+  rpc(registry, method, params) {
+    const payload = {
+      jsonrpc: "2.0",
+      id: crypto2__default.default.randomUUID(),
+      method,
+      params
+    };
+    return new Promise((resolve, reject) => {
+      const req = http__default.default.request(
+        {
+          method: "POST",
+          socketPath: registry.ipcPath,
+          path: "/control",
+          headers: {
+            "content-type": "application/json",
+            "x-mock-mcp-token": registry.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 TOOLS = [
+  {
+    name: "get_status",
+    description: "Get the current status of the mock-mcp daemon, including active test runs and pending batches.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "list_runs",
+    description: "List all active test runs connected to the daemon.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "claim_next_batch",
+    description: `Claim the next pending mock batch for processing. This acquires a lease on the batch.
+    
+You MUST call this before provide_batch_mock_data. The batch will be locked for 30 seconds (configurable via leaseMs).
+If you don't provide mock data within the lease time, the batch will be released for another adapter to claim.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        runId: {
+          type: "string",
+          description: "Optional: Filter to only claim batches from a specific test run."
+        },
+        leaseMs: {
+          type: "number",
+          description: "Optional: Lease duration in milliseconds. Default: 30000 (30 seconds)."
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "get_batch",
+    description: "Get details of a specific batch by ID (read-only, does not claim).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        batchId: {
+          type: "string",
+          description: "The batch ID to retrieve."
+        }
+      },
+      required: ["batchId"]
+    }
+  },
+  {
+    name: "provide_batch_mock_data",
+    description: `Provide mock response data for a claimed batch.
+    
+You MUST first call claim_next_batch to get the batchId and claimToken.
+The mocks array must contain exactly one mock for each request in the batch.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        batchId: {
+          type: "string",
+          description: "The batch ID (from claim_next_batch)."
+        },
+        claimToken: {
+          type: "string",
+          description: "The claim token (from claim_next_batch)."
+        },
+        mocks: {
+          type: "array",
+          description: "Array of mock responses, one for each request in the batch.",
+          items: {
+            type: "object",
+            properties: {
+              requestId: {
+                type: "string",
+                description: "The requestId from the original request."
+              },
+              data: {
+                description: "The mock response data (any JSON value)."
+              },
+              status: {
+                type: "number",
+                description: "Optional HTTP status code. Default: 200."
+              },
+              headers: {
+                type: "object",
+                description: "Optional response headers."
+              },
+              delayMs: {
+                type: "number",
+                description: "Optional delay before returning the mock (ms)."
+              }
+            },
+            required: ["requestId", "data"]
+          }
+        }
+      },
+      required: ["batchId", "claimToken", "mocks"]
+    }
+  },
+  {
+    name: "release_batch",
+    description: "Release a claimed batch without providing mock data. Use this if you cannot generate appropriate mocks.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        batchId: {
+          type: "string",
+          description: "The batch ID to release."
+        },
+        claimToken: {
+          type: "string",
+          description: "The claim token."
+        },
+        reason: {
+          type: "string",
+          description: "Optional reason for releasing."
+        }
+      },
+      required: ["batchId", "claimToken"]
+    }
+  }
+];
+async function runAdapter(opts = {}) {
+  const logger = opts.logger ?? console;
+  const version = opts.version ?? "0.5.0";
+  logger.error("\u{1F50D} Initializing mock-mcp adapter (multi-daemon mode)...");
+  const multiDaemon = new MultiDaemonClient({ logger });
+  const daemons = await multiDaemon.discoverDaemons();
+  if (daemons.length > 0) {
+    logger.error(`\u2705 Found ${daemons.length} active daemon(s):`);
+    for (const d of daemons) {
+      const status = d.healthy ? "healthy" : "unhealthy";
+      logger.error(`   - ${d.registry.projectId}: ${d.registry.projectRoot} (${status})`);
+    }
+  } else {
+    logger.error("\u2139\uFE0F  No active daemons found. Waiting for test processes to start...");
+  }
+  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 multiDaemon.getAggregatedStatus();
+          return buildToolResponse(formatAggregatedStatus(result));
+        }
+        case "list_runs": {
+          const result = await multiDaemon.listAllRuns();
+          return buildToolResponse(formatExtendedRuns(result));
+        }
+        case "claim_next_batch": {
+          const result = await multiDaemon.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 multiDaemon.getBatch(args.batchId);
+          if (!result) {
+            throw new Error(`Batch not found: ${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 multiDaemon.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 multiDaemon.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 formatAggregatedStatus(status) {
+  if (status.daemons.length === 0) {
+    return `# Mock MCP Status
+
+No active daemons found. Start a test with \`MOCK_MCP=1\` to begin.
+`;
+  }
+  const lines = [
+    "# Mock MCP Status\n",
+    "## Summary",
+    `- **Active Daemons**: ${status.daemons.filter((d) => d.healthy).length}`,
+    `- **Total Active Runs**: ${status.totalRuns}`,
+    `- **Total Pending Batches**: ${status.totalPending}`,
+    `- **Total Claimed Batches**: ${status.totalClaimed}`,
+    "",
+    "## Daemons\n"
+  ];
+  for (const daemon of status.daemons) {
+    const healthIcon = daemon.healthy ? "\u2705" : "\u274C";
+    lines.push(`### ${healthIcon} ${daemon.projectRoot}`);
+    lines.push(`- **Project ID**: ${daemon.projectId}`);
+    lines.push(`- **Version**: ${daemon.version}`);
+    lines.push(`- **PID**: ${daemon.pid}`);
+    if (daemon.healthy) {
+      lines.push(`- **Uptime**: ${Math.round(daemon.uptime / 1e3)}s`);
+      lines.push(`- **Runs**: ${daemon.runs}`);
+      lines.push(`- **Pending**: ${daemon.pending}`);
+      lines.push(`- **Claimed**: ${daemon.claimed}`);
+    } else {
+      lines.push(`- **Status**: Not responding`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatExtendedRuns(runs) {
+  if (runs.length === 0) {
+    return "No active test runs.\n\nStart a test with `MOCK_MCP=1` to begin.";
+  }
+  const lines = ["# Active Test Runs\n"];
+  const byProject = /* @__PURE__ */ new Map();
+  for (const run of runs) {
+    const key = run.projectRoot;
+    if (!byProject.has(key)) {
+      byProject.set(key, []);
+    }
+    byProject.get(key).push(run);
+  }
+  for (const [projectRoot, projectRuns] of byProject) {
+    lines.push(`## Project: ${projectRoot}
+`);
+    for (const run of projectRuns) {
+      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.\n\nMake sure a test is running with `MOCK_MCP=1` and has pending mock requests.";
+  }
+  const lines = [
+    "# Batch Claimed Successfully\n",
+    `**Batch ID**: \`${result.batchId}\``,
+    `**Claim Token**: \`${result.claimToken}\``,
+    `**Run ID**: ${result.runId}`,
+    `**Project**: ${result.projectRoot}`,
+    `**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 DaemonClient = class {
+  constructor(ipcPath, token, adapterId) {
+    this.ipcPath = ipcPath;
+    this.token = token;
+    this.adapterId = adapterId;
+  }
+  // ===========================================================================
+  // RPC Methods
+  // ===========================================================================
+  async getStatus() {
+    return this.rpc("getStatus", {});
+  }
+  async listRuns() {
+    return this.rpc("listRuns", {});
+  }
+  async claimNextBatch(args) {
+    return this.rpc("claimNextBatch", {
+      adapterId: this.adapterId,
+      runId: args.runId,
+      leaseMs: args.leaseMs
+    });
+  }
+  async provideBatch(args) {
+    return this.rpc("provideBatch", {
+      adapterId: this.adapterId,
+      batchId: args.batchId,
+      claimToken: args.claimToken,
+      mocks: args.mocks
+    });
+  }
+  async releaseBatch(args) {
+    return this.rpc("releaseBatch", {
+      adapterId: this.adapterId,
+      batchId: args.batchId,
+      claimToken: args.claimToken,
+      reason: args.reason
+    });
+  }
+  async getBatch(batchId) {
+    return this.rpc("getBatch", { batchId });
+  }
+  // ===========================================================================
+  // Internal
+  // ===========================================================================
+  rpc(method, params) {
+    const payload = {
+      jsonrpc: "2.0",
+      id: crypto2__default.default.randomUUID(),
+      method,
+      params
+    };
+    return new Promise((resolve, reject) => {
+      const req = http__default.default.request(
+        {
+          method: "POST",
+          socketPath: this.ipcPath,
+          path: "/control",
+          headers: {
+            "content-type": "application/json",
+            "x-mock-mcp-token": this.token
+          },
+          timeout: 3e4
+        },
+        (res) => {
+          let buf = "";
+          res.on("data", (chunk) => buf += chunk);
+          res.on("end", () => {
+            try {
+              const response = JSON.parse(buf);
+              if (response.error) {
+                reject(new Error(response.error.message));
+              } else {
+                resolve(response.result);
+              }
+            } catch (e) {
+              reject(e);
+            }
+          });
+        }
+      );
+      req.on("error", (err) => {
+        reject(new Error(`Daemon connection failed: ${err.message}`));
+      });
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("Daemon request timeout"));
+      });
+      req.end(JSON.stringify(payload));
+    });
+  }
+};
+
+exports.DaemonClient = DaemonClient;
+exports.MultiDaemonClient = MultiDaemonClient;
+exports.runAdapter = runAdapter;