mock-mcp 0.5.0 → 0.5.1

package/dist/adapter/index.js

@@ -1,111 +1,20 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import crypto2 from 'crypto';
 import http from 'http';
+import crypto2 from 'crypto';
 import fs from 'fs/promises';
-import fssync from 'fs';
+import 'fs';
 import os from 'os';
 import path from 'path';
-import { spawn } from 'child_process';
-import { fileURLToPath, pathToFileURL } from 'url';
-import { createRequire } from 'module';
+import 'child_process';
+import { fileURLToPath } from 'url';
+import 'module';
 
 // src/adapter/adapter.ts
-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.randomUUID(),
-      method,
-      params
-    };
-    return new Promise((resolve, reject) => {
-      const req = http.request(
-        {
-          method: "POST",
-          socketPath: this.ipcPath,
-          path: "/control",
-          headers: {
-            "content-type": "application/json",
-            "x-mock-mcp-token": this.token
-          },
-          timeout: 3e4
-        },
-        (res) => {
-          let buf = "";
-          res.on("data", (chunk) => buf += chunk);
-          res.on("end", () => {
-            try {
-              const response = JSON.parse(buf);
-              if (response.error) {
-                reject(new Error(response.error.message));
-              } else {
-                resolve(response.result);
-              }
-            } catch (e) {
-              reject(e);
-            }
-          });
-        }
-      );
-      req.on("error", (err) => {
-        reject(new Error(`Daemon connection failed: ${err.message}`));
-      });
-      req.on("timeout", () => {
-        req.destroy();
-        reject(new Error("Daemon request timeout"));
-      });
-      req.end(JSON.stringify(payload));
-    });
-  }
-};
 function debugLog(_msg) {
 }
-var __curDirname = (() => {
+(() => {
   try {
     const metaUrl = import.meta.url;
     if (metaUrl && typeof metaUrl === "string" && metaUrl.startsWith("file://")) {
@@ -115,32 +24,6 @@ var __curDirname = (() => {
   }
   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 crypto2.createHash("sha256").update(real).digest("hex").slice(0, 16);
-}
 function getCacheDir(override) {
   if (override) {
     return override;
@@ -162,13 +45,6 @@ function getCacheDir(override) {
   }
   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");
@@ -199,157 +75,310 @@ async function healthCheck(ipcPath, timeoutMs = 2e3) {
     req.end();
   });
 }
-async function tryAcquireLock(lockPath) {
+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 fh = await fs.open(lockPath, "wx");
-    await fh.write(`${process.pid}
-`);
-    return fh;
+    const txt = await fs.readFile(indexPath, "utf-8");
+    return JSON.parse(txt);
   } catch {
-    return null;
+    return { daemons: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
   }
 }
-async function releaseLock(lockPath, fh) {
-  await fh.close();
-  await fs.rm(lockPath).catch(() => {
+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
   });
 }
-function randomToken() {
-  return crypto2.randomBytes(24).toString("base64url");
+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);
+  }
 }
-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;
+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 });
     }
-  } catch {
   }
-  try {
-    const packageRoot = resolveProjectRoot(__curDirname);
-    const distPath = path.join(packageRoot, "dist", "index.js");
-    if (fssync.existsSync(distPath)) {
-      return distPath;
+  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.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
+        });
+      }
     }
-  } catch {
+    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;
   }
-  if (process.argv[1]) {
-    return process.argv[1];
+  /**
+   * 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;
   }
-  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));
+  /**
+   * 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}` };
     }
-    if (healthy) {
-      return existing;
+    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}` };
   }
-  if (process.platform !== "win32") {
-    try {
-      await fs.rm(ipcPath);
-    } catch {
+  /**
+   * 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}` };
   }
-  const lock = await tryAcquireLock(lockPath);
-  if (lock) {
-    try {
-      const recheckReg = await readRegistry(registryPath);
-      if (recheckReg && await healthCheck(recheckReg.ipcPath)) {
-        return recheckReg;
+  /**
+   * 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;
       }
-      const token = randomToken();
-      const daemonEntry = getDaemonEntryPath();
-      const child = spawn(
-        process.execPath,
-        [daemonEntry, "daemon", "--project-root", projectRoot, "--token", token],
+    }
+    return null;
+  }
+  // ===========================================================================
+  // Internal RPC
+  // ===========================================================================
+  rpc(registry, method, params) {
+    const payload = {
+      jsonrpc: "2.0",
+      id: crypto2.randomUUID(),
+      method,
+      params
+    };
+    return new Promise((resolve, reject) => {
+      const req = http.request(
         {
-          detached: true,
-          stdio: ["ignore", "pipe", "pipe"],
-          env: {
-            ...process.env,
-            MOCK_MCP_CACHE_DIR: opts.cacheDir ?? ""
-          }
+          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);
+            }
+          });
         }
       );
-      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}`);
+      req.on("error", (err) => {
+        reject(new Error(`Daemon connection failed: ${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}`);
-        }
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("Daemon request timeout"));
       });
-      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);
+      req.end(JSON.stringify(payload));
+    });
   }
-  throw new Error(
-    `Waiting for daemon timed out after ${timeoutMs}ms. Another process may have failed to start it.`
-  );
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
+};
 
 // src/adapter/adapter.ts
 var TOOLS = [
@@ -481,12 +510,19 @@ The mocks array must contain exactly one mock for each request in the batch.`,
 ];
 async function runAdapter(opts = {}) {
   const logger = opts.logger ?? console;
-  const version = opts.version ?? "0.4.0";
-  logger.error("\u{1F50D} Connecting to mock-mcp daemon...");
-  const registry = await ensureDaemonRunning();
-  const adapterId = crypto2.randomUUID();
-  const daemon = new DaemonClient(registry.ipcPath, registry.token, adapterId);
-  logger.error(`\u2705 Connected to daemon (project: ${registry.projectId})`);
+  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 Server(
     {
       name: "mock-mcp-adapter",
@@ -504,15 +540,15 @@ async function runAdapter(opts = {}) {
     try {
       switch (name) {
         case "get_status": {
-          const result = await daemon.getStatus();
-          return buildToolResponse(formatStatus(result));
+          const result = await multiDaemon.getAggregatedStatus();
+          return buildToolResponse(formatAggregatedStatus(result));
         }
         case "list_runs": {
-          const result = await daemon.listRuns();
-          return buildToolResponse(formatRuns(result));
+          const result = await multiDaemon.listAllRuns();
+          return buildToolResponse(formatExtendedRuns(result));
         }
         case "claim_next_batch": {
-          const result = await daemon.claimNextBatch({
+          const result = await multiDaemon.claimNextBatch({
             runId: args?.runId,
             leaseMs: args?.leaseMs
           });
@@ -522,14 +558,17 @@ async function runAdapter(opts = {}) {
           if (!args?.batchId) {
             throw new Error("batchId is required");
           }
-          const result = await daemon.getBatch(args.batchId);
+          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 daemon.provideBatch({
+          const result = await multiDaemon.provideBatch({
             batchId: args.batchId,
             claimToken: args.claimToken,
             mocks: args.mocks
@@ -540,7 +579,7 @@ async function runAdapter(opts = {}) {
           if (!args?.batchId || !args?.claimToken) {
             throw new Error("batchId and claimToken are required");
           }
-          const result = await daemon.releaseBatch({
+          const result = await multiDaemon.releaseBatch({
             batchId: args.batchId,
             claimToken: args.claimToken,
             reason: args?.reason
@@ -552,7 +591,7 @@ async function runAdapter(opts = {}) {
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      logger.error(`Tool error (${name}):`, message);
+      logger.error(`Tool error (${name}): ${message}`);
       return buildToolResponse(`Error: ${message}`, true);
     }
   });
@@ -566,53 +605,86 @@ function buildToolResponse(text, isError = false) {
     isError
   };
 }
-function formatStatus(status) {
-  return `# Mock MCP Daemon Status
+function formatAggregatedStatus(status) {
+  if (status.daemons.length === 0) {
+    return `# Mock MCP 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}
+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 formatRuns(result) {
-  if (result.runs.length === 0) {
-    return "No active test runs.";
+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"];
-  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}`);
+  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("");
     }
-    lines.push("");
   }
   return lines.join("\n");
 }
 function formatClaimResult(result) {
   if (!result) {
-    return "No pending batches available to claim.";
+    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"
@@ -668,5 +740,96 @@ function formatProvideResult(result) {
   }
   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.randomUUID(),
+      method,
+      params
+    };
+    return new Promise((resolve, reject) => {
+      const req = http.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));
+    });
+  }
+};
 
-export { DaemonClient, runAdapter };
+export { DaemonClient, MultiDaemonClient, runAdapter };