mock-mcp 0.5.0 → 0.5.1

package/dist/index.cjs

@@ -70,22 +70,50 @@ var __export = (target, all) => {
 // src/shared/discovery.ts
 var discovery_exports = {};
 __export(discovery_exports, {
+  cleanupGlobalIndex: () => cleanupGlobalIndex,
   computeProjectId: () => computeProjectId,
+  discoverAllDaemons: () => discoverAllDaemons,
   ensureDaemonRunning: () => ensureDaemonRunning,
   getCacheDir: () => getCacheDir,
   getDaemonEntryPath: () => getDaemonEntryPath,
+  getGlobalIndexPath: () => getGlobalIndexPath,
   getPaths: () => getPaths,
   healthCheck: () => healthCheck,
   randomToken: () => randomToken,
+  readGlobalIndex: () => readGlobalIndex,
   readRegistry: () => readRegistry,
+  registerDaemonGlobally: () => registerDaemonGlobally,
   releaseLock: () => releaseLock,
   resolveProjectRoot: () => resolveProjectRoot,
   sleep: () => sleep,
   tryAcquireLock: () => tryAcquireLock,
+  unregisterDaemonGlobally: () => unregisterDaemonGlobally,
+  writeGlobalIndex: () => writeGlobalIndex,
   writeRegistry: () => writeRegistry
 });
 function debugLog(_msg) {
 }
+function hasValidProjectMarker(dir) {
+  try {
+    const gitPath = path__default.default.join(dir, ".git");
+    try {
+      const stat = fssync__default.default.statSync(gitPath);
+      if (stat.isDirectory() || stat.isFile()) {
+        return true;
+      }
+    } catch {
+    }
+    const pkgPath = path__default.default.join(dir, "package.json");
+    try {
+      fssync__default.default.accessSync(pkgPath, fssync__default.default.constants.F_OK);
+      return true;
+    } catch {
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
 function resolveProjectRoot(startDir = process.cwd()) {
   let current = path__default.default.resolve(startDir);
   const root = path__default.default.parse(current).root;
@@ -220,7 +248,28 @@ function getDaemonEntryPath() {
   return path__default.default.join(process.cwd(), "dist", "index.js");
 }
 async function ensureDaemonRunning(opts = {}) {
-  const projectRoot = opts.projectRoot ?? resolveProjectRoot();
+  let projectRoot = opts.projectRoot ?? resolveProjectRoot();
+  if (!hasValidProjectMarker(projectRoot)) {
+    const resolved = resolveProjectRoot(projectRoot);
+    if (resolved !== projectRoot && hasValidProjectMarker(resolved)) {
+      console.error(`[mock-mcp] Warning: projectRoot "${projectRoot}" doesn't look like a project root`);
+      console.error(`[mock-mcp]   Found .git/package.json at: "${resolved}"`);
+      projectRoot = resolved;
+    } else {
+      console.error(`[mock-mcp] \u26A0\uFE0F  WARNING: Could not find a valid project root!`);
+      console.error(`[mock-mcp]   Current path: "${projectRoot}"`);
+      console.error(`[mock-mcp]   This path doesn't contain .git or package.json.`);
+      console.error(`[mock-mcp]   This may cause project mismatch issues.`);
+      console.error(`[mock-mcp]   `);
+      console.error(`[mock-mcp]   For MCP adapters, please specify --project-root explicitly:`);
+      console.error(`[mock-mcp]     mock-mcp adapter --project-root /path/to/your/project`);
+      console.error(`[mock-mcp]   `);
+      console.error(`[mock-mcp]   In your MCP client config (Cursor, Claude Desktop, etc.):`);
+      console.error(`[mock-mcp]   {`);
+      console.error(`[mock-mcp]     "args": ["-y", "mock-mcp", "adapter", "--project-root", "/path/to/your/project"]`);
+      console.error(`[mock-mcp]   }`);
+    }
+  }
   const projectId = computeProjectId(projectRoot);
   const { base, registryPath, lockPath, ipcPath } = getPaths(
     projectId,
@@ -328,6 +377,77 @@ ${daemonStderr}`);
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+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 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);
+}
+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;
+}
 var __curDirname;
 var init_discovery = __esm({
   "src/shared/discovery.ts"() {
@@ -471,6 +591,16 @@ var init_daemon = __esm({
           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();
@@ -499,6 +629,8 @@ var init_daemon = __esm({
         });
         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");
       }
       // ===========================================================================
@@ -924,54 +1056,209 @@ var init_daemon = __esm({
     };
   }
 });
-exports.DaemonClient = void 0;
-var init_daemon_client = __esm({
-  "src/adapter/daemon-client.ts"() {
-    exports.DaemonClient = class {
-      constructor(ipcPath, token, adapterId) {
-        this.ipcPath = ipcPath;
-        this.token = token;
-        this.adapterId = adapterId;
+exports.MultiDaemonClient = void 0;
+var init_multi_daemon_client = __esm({
+  "src/adapter/multi-daemon-client.ts"() {
+    init_discovery();
+    exports.MultiDaemonClient = class {
+      logger;
+      cacheDir;
+      adapterId;
+      constructor(opts = {}) {
+        this.logger = opts.logger ?? console;
+        this.cacheDir = opts.cacheDir;
+        this.adapterId = crypto__default.default.randomUUID();
       }
       // ===========================================================================
-      // RPC Methods
+      // Discovery
       // ===========================================================================
-      async getStatus() {
-        return this.rpc("getStatus", {});
+      /**
+       * Discover all active and healthy daemons.
+       */
+      async discoverDaemons() {
+        return discoverAllDaemons(this.cacheDir);
       }
-      async listRuns() {
-        return this.rpc("listRuns", {});
+      // ===========================================================================
+      // 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) {
-        return this.rpc("claimNextBatch", {
-          adapterId: this.adapterId,
-          runId: args.runId,
-          leaseMs: args.leaseMs
-        });
+        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) {
-        return this.rpc("provideBatch", {
-          adapterId: this.adapterId,
-          batchId: args.batchId,
-          claimToken: args.claimToken,
-          mocks: args.mocks
-        });
+        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) {
-        return this.rpc("releaseBatch", {
-          adapterId: this.adapterId,
-          batchId: args.batchId,
-          claimToken: args.claimToken,
-          reason: args.reason
-        });
+        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) {
-        return this.rpc("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
+      // Internal RPC
       // ===========================================================================
-      rpc(method, params) {
+      rpc(registry, method, params) {
         const payload = {
           jsonrpc: "2.0",
           id: crypto__default.default.randomUUID(),
@@ -982,11 +1269,11 @@ var init_daemon_client = __esm({
           const req = http__default.default.request(
             {
               method: "POST",
-              socketPath: this.ipcPath,
+              socketPath: registry.ipcPath,
               path: "/control",
               headers: {
                 "content-type": "application/json",
-                "x-mock-mcp-token": this.token
+                "x-mock-mcp-token": registry.token
               },
               timeout: 3e4
             },
@@ -1028,12 +1315,19 @@ __export(adapter_exports, {
 });
 async function runAdapter(opts = {}) {
   const logger = opts.logger ?? console;
-  const version = opts.version ?? "0.4.0";
-  logger.error("\u{1F50D} Connecting to mock-mcp daemon...");
-  const registry = await ensureDaemonRunning();
-  const adapterId = crypto__default.default.randomUUID();
-  const daemon = new exports.DaemonClient(registry.ipcPath, registry.token, adapterId);
-  logger.error(`\u2705 Connected to daemon (project: ${registry.projectId})`);
+  const version = opts.version ?? "0.5.0";
+  logger.error("\u{1F50D} Initializing mock-mcp adapter (multi-daemon mode)...");
+  const multiDaemon = new exports.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",
@@ -1051,15 +1345,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
           });
@@ -1069,14 +1363,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
@@ -1087,7 +1384,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
@@ -1099,7 +1396,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);
     }
   });
@@ -1113,53 +1410,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"
@@ -1218,8 +1548,7 @@ function formatProvideResult(result) {
 var TOOLS;
 var init_adapter = __esm({
   "src/adapter/adapter.ts"() {
-    init_daemon_client();
-    init_discovery();
+    init_multi_daemon_client();
     TOOLS = [
       {
         name: "get_status",
@@ -1355,7 +1684,100 @@ init_daemon();
 
 // src/adapter/index.ts
 init_adapter();
-init_daemon_client();
+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: crypto__default.default.randomUUID(),
+      method,
+      params
+    };
+    return new Promise((resolve, reject) => {
+      const req = http__default.default.request(
+        {
+          method: "POST",
+          socketPath: this.ipcPath,
+          path: "/control",
+          headers: {
+            "content-type": "application/json",
+            "x-mock-mcp-token": this.token
+          },
+          timeout: 3e4
+        },
+        (res) => {
+          let buf = "";
+          res.on("data", (chunk) => buf += chunk);
+          res.on("end", () => {
+            try {
+              const response = JSON.parse(buf);
+              if (response.error) {
+                reject(new Error(response.error.message));
+              } else {
+                resolve(response.result);
+              }
+            } catch (e) {
+              reject(e);
+            }
+          });
+        }
+      );
+      req.on("error", (err) => {
+        reject(new Error(`Daemon connection failed: ${err.message}`));
+      });
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("Daemon request timeout"));
+      });
+      req.end(JSON.stringify(payload));
+    });
+  }
+};
+
+// src/adapter/index.ts
+init_multi_daemon_client();
 
 // src/client/batch-mock-collector.ts
 init_discovery();
@@ -1421,11 +1843,19 @@ var BatchMockCollector = class {
   }
   /**
    * Resolve projectRoot from options.
-   * Priority: projectRoot > filePath > undefined (auto-detect)
+   * Priority: projectRoot (if valid) > filePath > projectRoot (fallback) > undefined (auto-detect)
+   *
+   * A projectRoot is "valid" if it contains .git or package.json. This prevents
+   * accidentally using a wrong directory (e.g., user's home directory) when the
+   * caller mistakenly passes process.cwd() as projectRoot.
    */
   resolveProjectRootFromOptions(options) {
     if (options.projectRoot) {
-      return options.projectRoot;
+      const hasGit = this.hasGitOrPackageJson(options.projectRoot);
+      if (hasGit) {
+        return options.projectRoot;
+      }
+      this.logger.warn(`[mock-mcp] Warning: projectRoot "${options.projectRoot}" doesn't contain .git or package.json`);
     }
     if (options.filePath) {
       let filePath = options.filePath;
@@ -1444,8 +1874,36 @@ var BatchMockCollector = class {
       this.logger.log(`[mock-mcp]     projectRoot: ${resolved}`);
       return resolved;
     }
+    if (options.projectRoot) {
+      this.logger.warn(`[mock-mcp] Warning: Using projectRoot "${options.projectRoot}" despite missing .git/package.json`);
+      return options.projectRoot;
+    }
     return void 0;
   }
+  /**
+   * Check if a directory contains .git or package.json
+   */
+  hasGitOrPackageJson(dir) {
+    try {
+      const gitPath = path__default.default.join(dir, ".git");
+      const pkgPath = path__default.default.join(dir, "package.json");
+      try {
+        const stat = fssync__default.default.statSync(gitPath);
+        if (stat.isDirectory() || stat.isFile()) {
+          return true;
+        }
+      } catch {
+      }
+      try {
+        fssync__default.default.accessSync(pkgPath, fssync__default.default.constants.F_OK);
+        return true;
+      } catch {
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
   /**
    * Ensures the underlying connection is ready for use.
    */
@@ -2047,7 +2505,7 @@ async function runStatusCommand(_args) {
     resolveProjectRoot: resolveProjectRoot2,
     computeProjectId: computeProjectId2,
     getPaths: getPaths2,
-    readRegistry: readRegistry2
+    readRegistry: readRegistry3
   } = await Promise.resolve().then(() => (init_discovery(), discovery_exports));
   const projectRoot = resolveProjectRoot2();
   const projectId = computeProjectId2(projectRoot);
@@ -2056,7 +2514,7 @@ async function runStatusCommand(_args) {
   console.log(`Project ID: ${projectId}`);
   console.log(`IPC Path: ${ipcPath}`);
   console.log("");
-  const registry = await readRegistry2(registryPath);
+  const registry = await readRegistry3(registryPath);
   if (!registry) {
     console.log("\u274C Daemon is not running (no registry found)");
     return;
@@ -2126,12 +2584,12 @@ async function runStopCommand(_args) {
     resolveProjectRoot: resolveProjectRoot2,
     computeProjectId: computeProjectId2,
     getPaths: getPaths2,
-    readRegistry: readRegistry2
+    readRegistry: readRegistry3
   } = await Promise.resolve().then(() => (init_discovery(), discovery_exports));
   const projectRoot = resolveProjectRoot2();
   const projectId = computeProjectId2(projectRoot);
   const { registryPath, ipcPath } = getPaths2(projectId);
-  const registry = await readRegistry2(registryPath);
+  const registry = await readRegistry3(registryPath);
   if (!registry) {
     console.log("Daemon is not running.");
     return;
@@ -2173,6 +2631,8 @@ USAGE:
 COMMANDS:
   adapter     Start the MCP adapter (default)
               This is what you configure in your MCP client.
+              The adapter automatically discovers ALL active daemons
+              across all projects - no configuration needed!
 
   daemon      Start the daemon process
               Usually auto-started by adapter/test code.
@@ -2187,6 +2647,7 @@ COMMANDS:
 
 EXAMPLES:
   # In your MCP client configuration (Cursor, Claude Desktop, etc.):
+  # Simple configuration - works across all projects automatically!
   {
     "mcpServers": {
       "mock-mcp": {
@@ -2202,6 +2663,11 @@ EXAMPLES:
   # Stop daemon:
   mock-mcp stop
 
+HOW IT WORKS:
+  1. Run your tests with MOCK_MCP=1 to start a daemon and make mock requests
+  2. The MCP adapter discovers all active daemons automatically
+  3. Use list_runs/claim_next_batch tools from any MCP client to provide mocks
+
 ENVIRONMENT:
   MOCK_MCP=1              Enable mock generation in test code
   MOCK_MCP_CACHE_DIR      Override cache directory for daemon files
@@ -2231,8 +2697,12 @@ if (isCliExecution) {
 }
 
 exports.BatchMockCollector = BatchMockCollector;
+exports.DaemonClient = DaemonClient;
+exports.cleanupGlobalIndex = cleanupGlobalIndex;
 exports.computeProjectId = computeProjectId;
 exports.connect = connect;
+exports.discoverAllDaemons = discoverAllDaemons;
 exports.ensureDaemonRunning = ensureDaemonRunning;
+exports.readGlobalIndex = readGlobalIndex;
 exports.resolveProjectRoot = resolveProjectRoot;
 exports.runAdapter = runAdapter;