metheus-governance-mcp-cli 0.2.26 → 0.2.28

package/README.md

@@ -48,6 +48,7 @@ metheus-governance-mcp-cli setup --project-id <project_uuid> --ctxpack-key "<ctx
 
 Gemini CLI note:
 - `gemini mcp` commands require Gemini auth to be configured first (`GEMINI_API_KEY` or `~/.gemini/settings.json` auth).
+- `setup` registers Gemini in both `user` and `project` scopes to improve auto-discovery across folders.
 
 When a client does not send workspace metadata (for example some Codex sessions),
 set a stable fallback root once:
@@ -58,7 +59,7 @@ metheus-governance-mcp-cli setup --project-id <project_uuid> --ctxpack-key "<ctx
 
 This sets fallback workspace context for clients that do not pass workspace metadata:
 - Codex/Antigravity/Cursor: `METHEUS_WORKSPACE_DIR` env
-- Gemini: pinned `--workspace-dir <fallback>` in registered MCP command
+- Gemini: pinned `--workspace-dir <fallback>` and `METHEUS_WORKSPACE_DIR` in MCP registration
 
 Guardrail note:
 - By default, CLI blocks reading/writing ctxpack sync metadata when workspace root resolves to the home directory.
@@ -93,6 +94,8 @@ Checks:
 
 Antigravity note:
 - this CLI manages MCP registration via Antigravity local config file (`mcp.json`) because Antigravity does not provide full `mcp list/get/remove` subcommands.
+- for compatibility across Antigravity variants, setup writes both `mcpServers` and `servers` keys.
+- proxy stdio now supports both `Content-Length` framed MCP and JSONL input for VS Code-family clients.
 
 Cursor note:
 - this CLI manages MCP registration via Cursor global MCP config (`~/.cursor/mcp.json`).

package/cli.mjs

@@ -124,8 +124,8 @@ function loadAntigravityMcpConfig() {
   return {
     filePath,
     config: {
+      mcpServers: {},
       servers: {},
-      inputs: [],
     },
   };
 }
@@ -142,12 +142,58 @@ function saveAntigravityMcpConfig(filePath, config) {
 
 function getAntigravityServerEntry(serverName) {
   const { config } = loadAntigravityMcpConfig();
-  const servers = safeObject(config?.servers);
+  const servers = safeObject(config?.mcpServers ?? config?.servers);
   const entry = safeObject(servers[serverName]);
   if (!entry.command && !entry.url) return null;
   return entry;
 }
 
+function geminiSettingsFilePath(scope = "project") {
+  const normalized = String(scope || "project").trim().toLowerCase();
+  if (normalized === "user") {
+    const home = String(process.env.USERPROFILE || process.env.HOME || "").trim();
+    if (home) {
+      return path.join(home, ".gemini", "settings.json");
+    }
+  }
+  return path.resolve(process.cwd(), ".gemini", "settings.json");
+}
+
+function loadGeminiSettings(scope = "project") {
+  const filePath = geminiSettingsFilePath(scope);
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const parsed = tryJsonParse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return { filePath, config: parsed };
+    }
+  } catch {
+    // no-op
+  }
+  return {
+    filePath,
+    config: {
+      mcpServers: {},
+    },
+  };
+}
+
+function getGeminiServerEntryByScope(serverName, scope = "project") {
+  const { config } = loadGeminiSettings(scope);
+  const servers = safeObject(config?.mcpServers);
+  const entry = safeObject(servers[serverName]);
+  if (!entry.command && !entry.url) return null;
+  return entry;
+}
+
+function getGeminiServerEntry(serverName) {
+  return (
+    getGeminiServerEntryByScope(serverName, "project")
+    || getGeminiServerEntryByScope(serverName, "user")
+    || null
+  );
+}
+
 function cursorMcpConfigFilePath() {
   const home = String(process.env.USERPROFILE || process.env.HOME || "").trim();
   if (home) {
@@ -3898,12 +3944,7 @@ async function runProxy(flags) {
   let sessionWorkspaceDir = "";
   let sessionWorkspaceTrusted = false;
 
-  const rl = readline.createInterface({
-    input: process.stdin,
-    crlfDelay: Infinity,
-  });
-
-  rl.on("line", async (lineRaw) => {
+  const handleIncomingMessage = async (lineRaw) => {
     const line = String(lineRaw || "").trim();
     if (!line) return;
 
@@ -4234,7 +4275,137 @@ async function runProxy(flags) {
         `${JSON.stringify(jsonRpcError(requestObj, -32001, String(err?.message || err)))}\n`,
       );
     }
+  };
+
+  let pendingInputBuffer = Buffer.alloc(0);
+  let messageQueue = Promise.resolve();
+
+  function queueMessage(messageText) {
+    const nextText = String(messageText || "");
+    if (!nextText.trim()) return;
+    messageQueue = messageQueue
+      .then(() => handleIncomingMessage(nextText))
+      .catch((err) => {
+        process.stderr.write(`${String(err?.stack || err)}\n`);
+      });
+  }
+
+  function indexOfBuffer(haystack, needle) {
+    return haystack.indexOf(needle);
+  }
+
+  function startsWithContentLengthHeader(buffer) {
+    if (!Buffer.isBuffer(buffer) || buffer.length === 0) return false;
+    let start = 0;
+    while (start < buffer.length && (buffer[start] === 0x0d || buffer[start] === 0x0a)) {
+      start += 1;
+    }
+    const previewLength = Math.min(96, buffer.length - start);
+    if (previewLength <= 0) return false;
+    const preview = buffer.subarray(start, start + previewLength).toString("utf8");
+    return /^\s*content-length\s*:/i.test(preview);
+  }
+
+  function extractFramedMessage(buffer) {
+    const crlfDelimiter = Buffer.from("\r\n\r\n");
+    const lfDelimiter = Buffer.from("\n\n");
+    let headerEnd = indexOfBuffer(buffer, crlfDelimiter);
+    let delimiterLength = crlfDelimiter.length;
+    if (headerEnd < 0) {
+      headerEnd = indexOfBuffer(buffer, lfDelimiter);
+      delimiterLength = lfDelimiter.length;
+    }
+    if (headerEnd < 0) return null;
+
+    const headerText = buffer.subarray(0, headerEnd).toString("utf8");
+    const match = /content-length\s*:\s*(\d+)/i.exec(headerText);
+    if (!match) {
+      // Malformed framed payload; drop header block and continue.
+      return {
+        message: "",
+        remaining: buffer.subarray(headerEnd + delimiterLength),
+      };
+    }
+
+    const bodyLength = Number.parseInt(String(match[1] || "0"), 10);
+    if (!Number.isFinite(bodyLength) || bodyLength < 0) {
+      return {
+        message: "",
+        remaining: buffer.subarray(headerEnd + delimiterLength),
+      };
+    }
+
+    const bodyStart = headerEnd + delimiterLength;
+    const bodyEnd = bodyStart + bodyLength;
+    if (buffer.length < bodyEnd) return null;
+    const message = buffer.subarray(bodyStart, bodyEnd).toString("utf8");
+    return {
+      message,
+      remaining: buffer.subarray(bodyEnd),
+    };
+  }
+
+  function extractLineMessage(buffer) {
+    const newlineIndex = buffer.indexOf(0x0a);
+    if (newlineIndex < 0) return null;
+    let lineBuffer = buffer.subarray(0, newlineIndex);
+    if (lineBuffer.length > 0 && lineBuffer[lineBuffer.length - 1] === 0x0d) {
+      lineBuffer = lineBuffer.subarray(0, lineBuffer.length - 1);
+    }
+    return {
+      message: lineBuffer.toString("utf8"),
+      remaining: buffer.subarray(newlineIndex + 1),
+    };
+  }
+
+  function pumpInputBuffer() {
+    // Supports both MCP framed stdio (Content-Length) and JSONL input.
+    while (pendingInputBuffer.length > 0) {
+      let trimmedLeading = pendingInputBuffer;
+      while (
+        trimmedLeading.length > 0
+        && (trimmedLeading[0] === 0x0d || trimmedLeading[0] === 0x0a)
+      ) {
+        trimmedLeading = trimmedLeading.subarray(1);
+      }
+      pendingInputBuffer = trimmedLeading;
+      if (pendingInputBuffer.length === 0) break;
+
+      if (startsWithContentLengthHeader(pendingInputBuffer)) {
+        const framed = extractFramedMessage(pendingInputBuffer);
+        if (!framed) break;
+        pendingInputBuffer = framed.remaining;
+        if (String(framed.message || "").trim()) {
+          queueMessage(framed.message);
+        }
+        continue;
+      }
+
+      const lineMessage = extractLineMessage(pendingInputBuffer);
+      if (!lineMessage) break;
+      pendingInputBuffer = lineMessage.remaining;
+      if (String(lineMessage.message || "").trim()) {
+        queueMessage(lineMessage.message);
+      }
+    }
+  }
+
+  process.stdin.on("data", (chunk) => {
+    const nextChunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    pendingInputBuffer = pendingInputBuffer.length
+      ? Buffer.concat([pendingInputBuffer, nextChunk])
+      : nextChunk;
+    pumpInputBuffer();
+  });
+
+  process.stdin.on("end", () => {
+    const trailing = String(pendingInputBuffer.toString("utf8") || "").trim();
+    if (trailing) {
+      queueMessage(trailing);
+    }
   });
+
+  process.stdin.resume();
 }
 
 function runCLICommand(cliBin, args, options = {}) {
@@ -4306,7 +4477,7 @@ function tryRegister(cliBin, serverName, proxyArgs, options = {}) {
   if (cliBin === "antigravity") {
     const { filePath, config } = loadAntigravityMcpConfig();
     const nextConfig = safeObject(config);
-    const nextServers = safeObject(nextConfig.servers);
+    const nextServers = safeObject(nextConfig.mcpServers ?? nextConfig.servers);
     const existing = safeObject(nextServers[serverName]);
     const args = [selfPath, "proxy", ...proxyArgs];
     const entry = {
@@ -4330,25 +4501,36 @@ function tryRegister(cliBin, serverName, proxyArgs, options = {}) {
       }
     }
     nextServers[serverName] = entry;
-    nextConfig.servers = nextServers;
-    if (!Array.isArray(nextConfig.inputs)) {
-      nextConfig.inputs = [];
-    }
+    nextConfig.mcpServers = nextServers;
+    nextConfig.servers = { ...nextServers };
     return saveAntigravityMcpConfig(filePath, nextConfig);
   }
   if (cliBin === "gemini") {
-    // Gemini CLI (0.31.x) currently supports:
-    // gemini mcp add <name> <commandOrUrl> [args...]
-    // It does not expose --env for MCP registration, so pin workspace-dir directly.
+    // Register in both user+project scopes for broader auto-discovery across folders.
     const geminiProxyArgs = workspaceEnv
       ? withWorkspaceDirArg(proxyArgs, workspaceEnv)
       : [...proxyArgs];
-    const run = runCLICommand(
+    const geminiEnvArgs = workspaceEnv
+      ? ["-e", `METHEUS_WORKSPACE_DIR=${workspaceEnv}`]
+      : [];
+    const geminiBaseArgs = [serverName, process.execPath, selfPath, "proxy", ...geminiProxyArgs];
+    let ok = false;
+    const scopedAttempts = [
+      ["mcp", "add", "-s", "user", ...geminiEnvArgs, ...geminiBaseArgs],
+      ["mcp", "add", "-s", "project", ...geminiEnvArgs, ...geminiBaseArgs],
+    ];
+    for (const args of scopedAttempts) {
+      const run = runCLICommand(cliBin, args, { stdio: "inherit" });
+      if (run.status === 0) ok = true;
+    }
+    if (ok) return true;
+    // Backward compatibility for older Gemini CLI variants without scope/env flags.
+    const legacyRun = runCLICommand(
       cliBin,
       ["mcp", "add", serverName, process.execPath, selfPath, "proxy", ...geminiProxyArgs],
       { stdio: "inherit" },
     );
-    return run.status === 0;
+    return legacyRun.status === 0;
   }
 
   const baseAddArgs = (() => {
@@ -4395,13 +4577,11 @@ function runRemove(cliBin, serverName) {
   if (cliBin === "antigravity") {
     const { filePath, config } = loadAntigravityMcpConfig();
     const nextConfig = safeObject(config);
-    const nextServers = safeObject(nextConfig.servers);
+    const nextServers = safeObject(nextConfig.mcpServers ?? nextConfig.servers);
     if (Object.prototype.hasOwnProperty.call(nextServers, serverName)) {
       delete nextServers[serverName];
-      nextConfig.servers = nextServers;
-      if (!Array.isArray(nextConfig.inputs)) {
-        nextConfig.inputs = [];
-      }
+      nextConfig.mcpServers = nextServers;
+      nextConfig.servers = { ...nextServers };
       saveAntigravityMcpConfig(filePath, nextConfig);
     }
     return;
@@ -4416,6 +4596,8 @@ function runRemove(cliBin, serverName) {
     return;
   }
   if (cliBin === "gemini") {
+    runCLICommand(cliBin, ["mcp", "remove", "-s", "project", serverName], { stdio: "ignore" });
+    runCLICommand(cliBin, ["mcp", "remove", "-s", "user", serverName], { stdio: "ignore" });
     runCLICommand(cliBin, ["mcp", "remove", serverName], { stdio: "ignore" });
     return;
   }
@@ -4430,6 +4612,9 @@ function isRegistered(cliBin, serverName) {
     return Boolean(getAntigravityServerEntry(serverName));
   }
   if (cliBin === "gemini") {
+    if (getGeminiServerEntry(serverName)) {
+      return true;
+    }
     const listRun = runCLICommand(cliBin, ["mcp", "list"], { stdio: "pipe" });
     if (listRun.status !== 0) return false;
     const text = `${String(listRun.stdout || "")}\n${String(listRun.stderr || "")}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metheus-governance-mcp-cli",
-  "version": "0.2.26",
+  "version": "0.2.28",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [