mock-mcp 0.3.1 → 0.5.0

package/dist/shared/index.cjs

@@ -0,0 +1,386 @@
+'use strict';
+
+var fs = require('fs/promises');
+var fssync = require('fs');
+var os = require('os');
+var path = require('path');
+var crypto = require('crypto');
+var child_process = require('child_process');
+var http = require('http');
+var url = require('url');
+var module$1 = require('module');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var fssync__default = /*#__PURE__*/_interopDefault(fssync);
+var os__default = /*#__PURE__*/_interopDefault(os);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var http__default = /*#__PURE__*/_interopDefault(http);
+
+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) {
+}
+var __curDirname = (() => {
+  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 resolveProjectRoot(startDir = process.cwd()) {
+  let current = path__default.default.resolve(startDir);
+  const root = path__default.default.parse(current).root;
+  while (current !== root) {
+    const gitPath = path__default.default.join(current, ".git");
+    try {
+      const stat = fssync__default.default.statSync(gitPath);
+      if (stat.isDirectory() || stat.isFile()) {
+        return current;
+      }
+    } catch {
+    }
+    const pkgPath = path__default.default.join(current, "package.json");
+    try {
+      fssync__default.default.accessSync(pkgPath, fssync__default.default.constants.F_OK);
+      return current;
+    } catch {
+    }
+    current = path__default.default.dirname(current);
+  }
+  return path__default.default.resolve(startDir);
+}
+function computeProjectId(projectRoot) {
+  const real = fssync__default.default.realpathSync(projectRoot);
+  return crypto__default.default.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__default.default.homedir();
+  if (home) {
+    return path__default.default.join(home, ".cache");
+  }
+  return os__default.default.tmpdir();
+}
+function getPaths(projectId, cacheDir) {
+  const base = path__default.default.join(getCacheDir(cacheDir), "mock-mcp");
+  const registryPath = path__default.default.join(base, `${projectId}.json`);
+  const lockPath = path__default.default.join(base, `${projectId}.lock`);
+  const ipcPath = process.platform === "win32" ? `\\\\.\\pipe\\mock-mcp-${projectId}` : path__default.default.join(base, `${projectId}.sock`);
+  return { base, registryPath, lockPath, ipcPath };
+}
+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 writeRegistry(registryPath, registry) {
+  await fs__default.default.writeFile(registryPath, JSON.stringify(registry, null, 2), {
+    encoding: "utf-8",
+    mode: 384
+    // Read/write for owner only
+  });
+}
+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();
+  });
+}
+async function tryAcquireLock(lockPath) {
+  try {
+    const fh = await fs__default.default.open(lockPath, "wx");
+    await fh.write(`${process.pid}
+`);
+    return fh;
+  } catch {
+    return null;
+  }
+}
+async function releaseLock(lockPath, fh) {
+  await fh.close();
+  await fs__default.default.rm(lockPath).catch(() => {
+  });
+}
+function randomToken() {
+  return crypto__default.default.randomBytes(24).toString("base64url");
+}
+function getDaemonEntryPath() {
+  try {
+    const cwdRequire = module$1.createRequire(url.pathToFileURL(path__default.default.join(process.cwd(), "index.js")).href);
+    const resolved = cwdRequire.resolve("mock-mcp");
+    const distDir = path__default.default.dirname(resolved);
+    const daemonEntry = path__default.default.join(distDir, "index.js");
+    if (fssync__default.default.existsSync(daemonEntry)) {
+      return daemonEntry;
+    }
+  } catch {
+  }
+  try {
+    const packageRoot = resolveProjectRoot(__curDirname);
+    const distPath = path__default.default.join(packageRoot, "dist", "index.js");
+    if (fssync__default.default.existsSync(distPath)) {
+      return distPath;
+    }
+  } catch {
+  }
+  if (process.argv[1]) {
+    return process.argv[1];
+  }
+  return path__default.default.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__default.default.mkdir(base, { recursive: true });
+  const existing = await readRegistry(registryPath);
+  debugLog(`Registry read result: ${existing ? "Found (PID " + existing.pid + ")" : "Null"}`);
+  if (existing) {
+    let healthy = false;
+    for (let i = 0; i < 3; i++) {
+      debugLog(`Checking health attempt ${i + 1}/3 on ${existing.ipcPath}`);
+      healthy = await healthCheck(existing.ipcPath);
+      if (healthy) break;
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    if (healthy) {
+      return existing;
+    }
+  }
+  if (process.platform !== "win32") {
+    try {
+      await fs__default.default.rm(ipcPath);
+    } catch {
+    }
+  }
+  const lock = await tryAcquireLock(lockPath);
+  if (lock) {
+    try {
+      const recheckReg = await readRegistry(registryPath);
+      if (recheckReg && await healthCheck(recheckReg.ipcPath)) {
+        return recheckReg;
+      }
+      const token = randomToken();
+      const daemonEntry = getDaemonEntryPath();
+      const child = child_process.spawn(
+        process.execPath,
+        [daemonEntry, "daemon", "--project-root", projectRoot, "--token", token],
+        {
+          detached: true,
+          stdio: ["ignore", "pipe", "pipe"],
+          env: {
+            ...process.env,
+            MOCK_MCP_CACHE_DIR: opts.cacheDir ?? ""
+          }
+        }
+      );
+      let daemonStderr = "";
+      let daemonStdout = "";
+      child.stdout?.on("data", (data) => {
+        const str = data.toString();
+        debugLog(`Daemon stdout: ${str}`);
+      });
+      child.stderr?.on("data", (data) => {
+        daemonStderr += data.toString();
+        debugLog(`Daemon stderr: ${data.toString()}`);
+      });
+      child.on("error", (err) => {
+        console.error(`[mock-mcp] Daemon spawn error: ${err.message}`);
+      });
+      child.on("exit", (code, signal) => {
+        if (code !== null && code !== 0) {
+          console.error(`[mock-mcp] Daemon exited with code: ${code}`);
+          if (daemonStderr) {
+            console.error(`[mock-mcp] Daemon stderr: ${daemonStderr.slice(0, 500)}`);
+          }
+        } else if (signal) {
+          console.error(`[mock-mcp] Daemon killed by signal: ${signal}`);
+        }
+      });
+      child.unref();
+      const deadline2 = Date.now() + timeoutMs;
+      while (Date.now() < deadline2) {
+        const reg = await readRegistry(registryPath);
+        if (reg && await healthCheck(reg.ipcPath)) {
+          return reg;
+        }
+        await sleep(50);
+      }
+      console.error("[mock-mcp] Daemon failed to start within timeout");
+      if (daemonStderr) {
+        console.error(`[mock-mcp] Daemon stderr:
+${daemonStderr}`);
+      }
+      throw new Error(
+        `Daemon start timeout after ${timeoutMs}ms. Check logs for details.`
+      );
+    } finally {
+      await releaseLock(lockPath, lock);
+    }
+  }
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const reg = await readRegistry(registryPath);
+    if (reg && await healthCheck(reg.ipcPath)) {
+      return reg;
+    }
+    await sleep(50);
+  }
+  throw new Error(
+    `Waiting for daemon timed out after ${timeoutMs}ms. Another process may have failed to start it.`
+  );
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/shared/protocol.ts
+var HELLO_TEST = "HELLO_TEST";
+var HELLO_ACK = "HELLO_ACK";
+var BATCH_MOCK_REQUEST = "BATCH_MOCK_REQUEST";
+var BATCH_MOCK_RESULT = "BATCH_MOCK_RESULT";
+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_PARSE = -32700;
+var RPC_ERROR_INVALID_REQUEST = -32600;
+var RPC_ERROR_METHOD_NOT_FOUND = -32601;
+var RPC_ERROR_INVALID_PARAMS = -32602;
+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";
+}
+
+exports.BATCH_MOCK_REQUEST = BATCH_MOCK_REQUEST;
+exports.BATCH_MOCK_RESULT = BATCH_MOCK_RESULT;
+exports.HEARTBEAT = HEARTBEAT;
+exports.HEARTBEAT_ACK = HEARTBEAT_ACK;
+exports.HELLO_ACK = HELLO_ACK;
+exports.HELLO_TEST = HELLO_TEST;
+exports.RPC_CLAIM_NEXT_BATCH = RPC_CLAIM_NEXT_BATCH;
+exports.RPC_ERROR_CONFLICT = RPC_ERROR_CONFLICT;
+exports.RPC_ERROR_EXPIRED = RPC_ERROR_EXPIRED;
+exports.RPC_ERROR_INTERNAL = RPC_ERROR_INTERNAL;
+exports.RPC_ERROR_INVALID_PARAMS = RPC_ERROR_INVALID_PARAMS;
+exports.RPC_ERROR_INVALID_REQUEST = RPC_ERROR_INVALID_REQUEST;
+exports.RPC_ERROR_METHOD_NOT_FOUND = RPC_ERROR_METHOD_NOT_FOUND;
+exports.RPC_ERROR_NOT_FOUND = RPC_ERROR_NOT_FOUND;
+exports.RPC_ERROR_PARSE = RPC_ERROR_PARSE;
+exports.RPC_ERROR_UNAUTHORIZED = RPC_ERROR_UNAUTHORIZED;
+exports.RPC_GET_BATCH = RPC_GET_BATCH;
+exports.RPC_GET_STATUS = RPC_GET_STATUS;
+exports.RPC_LIST_RUNS = RPC_LIST_RUNS;
+exports.RPC_PROVIDE_BATCH = RPC_PROVIDE_BATCH;
+exports.RPC_RELEASE_BATCH = RPC_RELEASE_BATCH;
+exports.computeProjectId = computeProjectId;
+exports.ensureDaemonRunning = ensureDaemonRunning;
+exports.getCacheDir = getCacheDir;
+exports.getDaemonEntryPath = getDaemonEntryPath;
+exports.getPaths = getPaths;
+exports.healthCheck = healthCheck;
+exports.isBatchMockRequestMessage = isBatchMockRequestMessage;
+exports.isHeartbeatMessage = isHeartbeatMessage;
+exports.isHelloTestMessage = isHelloTestMessage;
+exports.isJsonRpcRequest = isJsonRpcRequest;
+exports.randomToken = randomToken;
+exports.readRegistry = readRegistry;
+exports.releaseLock = releaseLock;
+exports.resolveProjectRoot = resolveProjectRoot;
+exports.sleep = sleep;
+exports.tryAcquireLock = tryAcquireLock;
+exports.writeRegistry = writeRegistry;

package/dist/shared/index.d.cts

@@ -0,0 +1,4 @@
+export { j as DaemonPaths, D as DaemonRegistry, E as EnsureDaemonOptions, c as computeProjectId, i as ensureDaemonRunning, g as getCacheDir, f as getDaemonEntryPath, a as getPaths, h as healthCheck, e as randomToken, b as readRegistry, d as releaseLock, r as resolveProjectRoot, s as sleep, t as tryAcquireLock, w as writeRegistry } from '../discovery-Dc2LdF8q.cjs';
+export { B as BATCH_MOCK_REQUEST, b as BATCH_MOCK_RESULT, y as BatchMockRequestMessage, z as BatchMockResultMessage, W as BatchRecord, U as BatchStatus, G as ClaimNextBatchParams, I as ClaimNextBatchResult, M as GetBatchParams, S as GetBatchResult, N as GetStatusResult, c as HEARTBEAT, d as HEARTBEAT_ACK, a as HELLO_ACK, H as HELLO_TEST, C as HeartbeatAckMessage, A as HeartbeatMessage, x as HelloAckMessage, w as HelloTestMessage, F as JsonRpcError, J as JsonRpcRequest, E as JsonRpcResponse, O as ListRunsResult, P as ProvideBatchParams, K as ProvideBatchResult, f as RPC_CLAIM_NEXT_BATCH, q as RPC_ERROR_CONFLICT, r as RPC_ERROR_EXPIRED, n as RPC_ERROR_INTERNAL, m as RPC_ERROR_INVALID_PARAMS, k as RPC_ERROR_INVALID_REQUEST, l as RPC_ERROR_METHOD_NOT_FOUND, o as RPC_ERROR_NOT_FOUND, j as RPC_ERROR_PARSE, p as RPC_ERROR_UNAUTHORIZED, i as RPC_GET_BATCH, R as RPC_GET_STATUS, e as RPC_LIST_RUNS, g as RPC_PROVIDE_BATCH, h as RPC_RELEASE_BATCH, L as ReleaseBatchParams, Q as RunInfo, V as RunRecord, T as TestChannelIncomingMessage, D as TestChannelOutgoingMessage, t as isBatchMockRequestMessage, u as isHeartbeatMessage, s as isHelloTestMessage, v as isJsonRpcRequest } from '../protocol-xZu-wb0n.cjs';
+import 'node:fs';
+import '../types-BKREdsyr.cjs';

package/dist/shared/index.d.ts

@@ -0,0 +1,4 @@
+export { j as DaemonPaths, D as DaemonRegistry, E as EnsureDaemonOptions, c as computeProjectId, i as ensureDaemonRunning, g as getCacheDir, f as getDaemonEntryPath, a as getPaths, h as healthCheck, e as randomToken, b as readRegistry, d as releaseLock, r as resolveProjectRoot, s as sleep, t as tryAcquireLock, w as writeRegistry } from '../discovery-Dc2LdF8q.js';
+export { B as BATCH_MOCK_REQUEST, b as BATCH_MOCK_RESULT, y as BatchMockRequestMessage, z as BatchMockResultMessage, W as BatchRecord, U as BatchStatus, G as ClaimNextBatchParams, I as ClaimNextBatchResult, M as GetBatchParams, S as GetBatchResult, N as GetStatusResult, c as HEARTBEAT, d as HEARTBEAT_ACK, a as HELLO_ACK, H as HELLO_TEST, C as HeartbeatAckMessage, A as HeartbeatMessage, x as HelloAckMessage, w as HelloTestMessage, F as JsonRpcError, J as JsonRpcRequest, E as JsonRpcResponse, O as ListRunsResult, P as ProvideBatchParams, K as ProvideBatchResult, f as RPC_CLAIM_NEXT_BATCH, q as RPC_ERROR_CONFLICT, r as RPC_ERROR_EXPIRED, n as RPC_ERROR_INTERNAL, m as RPC_ERROR_INVALID_PARAMS, k as RPC_ERROR_INVALID_REQUEST, l as RPC_ERROR_METHOD_NOT_FOUND, o as RPC_ERROR_NOT_FOUND, j as RPC_ERROR_PARSE, p as RPC_ERROR_UNAUTHORIZED, i as RPC_GET_BATCH, R as RPC_GET_STATUS, e as RPC_LIST_RUNS, g as RPC_PROVIDE_BATCH, h as RPC_RELEASE_BATCH, L as ReleaseBatchParams, Q as RunInfo, V as RunRecord, T as TestChannelIncomingMessage, D as TestChannelOutgoingMessage, t as isBatchMockRequestMessage, u as isHeartbeatMessage, s as isHelloTestMessage, v as isJsonRpcRequest } from '../protocol-CiwaQFOt.js';
+import 'node:fs';
+import '../types-BKREdsyr.js';