metheus-governance-mcp-cli 0.2.25 → 0.2.28

package/README.md

@@ -7,9 +7,9 @@ Compatibility note: legacy command alias `metheus-governance-mcp` is still suppo
 - `metheus-governance-mcp-cli` (no args): bootstrap mode
   - checks auth token
   - if token is missing/expired, starts `auth login`
-  - checks Codex/Claude MCP registration
+  - checks Codex/Claude/Gemini/Antigravity/Cursor MCP registration
   - registers only missing clients
-- `setup`: register `metheus-governance-mcp` into Codex/Claude (if installed)
+- `setup`: register `metheus-governance-mcp` into Codex/Claude/Gemini/Antigravity/Cursor (if installed)
 - `doctor`: run end-to-end health checks (auth/registration/gateway/project/ctxpack/tools)
 - `proxy`: stdio MCP bridge to Metheus HTTPS gateway
 - `auth`: save/check/clear local Metheus token used by proxy
@@ -40,12 +40,16 @@ metheus-governance-mcp-cli setup --project-id <project_uuid> --ctxpack-key "<ctx
 `setup` defaults to `--workspace-dir auto` (dynamic workspace detection).
 Use an explicit path only when you intentionally want a fixed workspace.
 
-Recommended for Codex/Claude multi-workspace sessions:
+Recommended for Codex/Claude/Gemini/Antigravity/Cursor multi-workspace sessions:
 
 ```bash
 metheus-governance-mcp-cli setup --project-id <project_uuid> --ctxpack-key "<ctxpack_key>" --base-url https://metheus.gesiaplatform.com --workspace-dir auto
 ```
 
+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:
 
@@ -53,7 +57,9 @@ set a stable fallback root once:
 metheus-governance-mcp-cli setup --project-id <project_uuid> --ctxpack-key "<ctxpack_key>" --base-url https://metheus.gesiaplatform.com --workspace-dir auto --workspace-fallback-dir C:\code_test
 ```
 
-This registers `METHEUS_WORKSPACE_DIR` for Codex MCP so ctxpack sync still resolves safely.
+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>` 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.
@@ -76,7 +82,7 @@ metheus-governance-mcp-cli doctor --project-id <project_uuid> --base-url https:/
 
 Checks:
 - auth token status (+ auto refresh attempt)
-- codex/claude registration state
+- codex/claude/gemini/antigravity/cursor registration state
 - gateway `tools/list` reachability
 - `project.summary` access
 - ctxpack auto sync status
@@ -84,7 +90,15 @@ Checks:
 
 ## Use in MCP
 
-`setup` auto-registers this server for `codex` and `claude` when those CLIs are available.
+`setup` auto-registers this server for `codex`, `claude`, `gemini`, `antigravity`, and `cursor` when those CLIs are available.
+
+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`).
 
 Local bootstrap tools exposed by proxy:
 

package/cli.mjs

@@ -27,6 +27,7 @@ const SELF_UPDATE_ENV_KEY = "METHEUS_CLI_AUTO_UPDATE";
 const SELF_UPDATE_GUARD_ENV_KEY = "METHEUS_CLI_SELF_UPDATE_ATTEMPTED";
 const ALLOW_HOME_WORKSPACE_ENV_KEY = "METHEUS_ALLOW_HOME_WORKSPACE";
 const AUTO_CTXPACK_SYNC_INTERVAL_MS = 60 * 1000;
+const MCP_CLIENTS = ["codex", "claude", "gemini", "antigravity", "cursor"];
 const autoCtxpackSyncTracker = new Map();
 
 function printUsage() {
@@ -85,6 +86,159 @@ function resolveHomeFilePath(relativePath) {
   return path.join(home, relativePath);
 }
 
+function antigravityMcpConfigFilePath() {
+  const home = String(process.env.USERPROFILE || process.env.HOME || "").trim();
+  if (process.platform === "win32") {
+    const appData = String(process.env.APPDATA || "").trim();
+    if (appData) {
+      return path.join(appData, "Antigravity", "User", "mcp.json");
+    }
+    if (home) {
+      return path.join(home, "AppData", "Roaming", "Antigravity", "User", "mcp.json");
+    }
+  }
+  if (process.platform === "darwin" && home) {
+    return path.join(home, "Library", "Application Support", "Antigravity", "User", "mcp.json");
+  }
+  const xdgConfig = String(process.env.XDG_CONFIG_HOME || "").trim();
+  if (xdgConfig) {
+    return path.join(xdgConfig, "Antigravity", "User", "mcp.json");
+  }
+  if (home) {
+    return path.join(home, ".config", "Antigravity", "User", "mcp.json");
+  }
+  return path.resolve(process.cwd(), ".antigravity", "mcp.json");
+}
+
+function loadAntigravityMcpConfig() {
+  const filePath = antigravityMcpConfigFilePath();
+  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: {},
+      servers: {},
+    },
+  };
+}
+
+function saveAntigravityMcpConfig(filePath, config) {
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(config, null, "\t")}\n`, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getAntigravityServerEntry(serverName) {
+  const { config } = loadAntigravityMcpConfig();
+  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) {
+    return path.join(home, ".cursor", "mcp.json");
+  }
+  return path.resolve(process.cwd(), ".cursor", "mcp.json");
+}
+
+function loadCursorMcpConfig() {
+  const filePath = cursorMcpConfigFilePath();
+  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 saveCursorMcpConfig(filePath, config) {
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getCursorServerEntry(serverName) {
+  const { config } = loadCursorMcpConfig();
+  const servers = safeObject(config?.mcpServers);
+  const entry = safeObject(servers[serverName]);
+  if (!entry.command && !entry.url) return null;
+  return entry;
+}
+
 function updateStateFilePath() {
   return resolveHomeFilePath(SELF_UPDATE_STATE_RELATIVE_PATH);
 }
@@ -1392,7 +1546,7 @@ async function runAuthLoginManual(flags) {
   if (exp) {
     process.stdout.write(`Token expires: ${exp}\n`);
   }
-  process.stdout.write("Restart Codex/Claude session to apply new token to MCP proxy.\n");
+  process.stdout.write("Restart Codex/Claude/Gemini/Antigravity/Cursor session to apply new token to MCP proxy.\n");
 }
 
 async function runAuthLoginCallback(flags, baseURL, oidc) {
@@ -1474,7 +1628,7 @@ async function runAuthLoginCallback(flags, baseURL, oidc) {
     process.stdout.write("Refresh token saved.\n");
   }
   process.stdout.write("Auth login complete (callback flow).\n");
-  process.stdout.write("Restart Codex/Claude session to apply new token to MCP proxy.\n");
+  process.stdout.write("Restart Codex/Claude/Gemini/Antigravity/Cursor session to apply new token to MCP proxy.\n");
 }
 
 async function runAuthLoginDevice(flags, baseURL, oidc) {
@@ -1541,7 +1695,7 @@ async function runAuthLoginDevice(flags, baseURL, oidc) {
     process.stdout.write("Refresh token saved.\n");
   }
   process.stdout.write("Auth login complete (device flow).\n");
-  process.stdout.write("Restart Codex/Claude session to apply new token to MCP proxy.\n");
+  process.stdout.write("Restart Codex/Claude/Gemini/Antigravity/Cursor session to apply new token to MCP proxy.\n");
 }
 
 async function runAuthLogin(flags) {
@@ -1825,7 +1979,7 @@ async function runDoctor(flags) {
     );
   }
 
-  for (const cliBin of ["codex", "claude"]) {
+  for (const cliBin of MCP_CLIENTS) {
     if (!commandExists(cliBin)) {
       addDoctorCheck(rows, "warn", `${cliBin} CLI`, "not installed; registration check skipped");
       continue;
@@ -3790,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;
 
@@ -4126,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 = {}) {
@@ -4140,7 +4419,7 @@ function runCLICommand(cliBin, args, options = {}) {
     return direct;
   }
   // On Windows, npm global CLIs are often .cmd wrappers.
-  // Fallback through cmd.exe so tools like "claude" are discoverable.
+  // Fallback through cmd.exe so tools like "claude"/"gemini"/"antigravity"/"cursor" are discoverable.
   return spawnSync("cmd.exe", ["/d", "/s", "/c", cliBin, ...args], execOptions);
 }
 
@@ -4149,21 +4428,123 @@ function commandExists(bin) {
   return check.status === 0;
 }
 
+function escapeRegExp(value) {
+  return String(value || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function hasServerNameInListJSON(value, serverName) {
+  if (Array.isArray(value)) {
+    return value.some((entry) => hasServerNameInListJSON(entry, serverName));
+  }
+  if (!value || typeof value !== "object") return false;
+  if (String(value.name || "").trim() === serverName) return true;
+  return Object.values(value).some((entry) => hasServerNameInListJSON(entry, serverName));
+}
+
 function tryRegister(cliBin, serverName, proxyArgs, options = {}) {
   const selfPath = fileURLToPath(import.meta.url);
-  const baseAddArgs =
-    cliBin === "claude"
-      ? ["mcp", "add", "--scope", "user", serverName]
-      : ["mcp", "add", serverName];
   const workspaceEnv = String(options.workspaceDir || "").trim();
-  const codexEnvArgs =
+  if (cliBin === "cursor") {
+    const { filePath, config } = loadCursorMcpConfig();
+    const nextConfig = safeObject(config);
+    const nextServers = safeObject(nextConfig.mcpServers);
+    const existing = safeObject(nextServers[serverName]);
+    const args = [selfPath, "proxy", ...proxyArgs];
+    const entry = {
+      ...existing,
+      command: process.execPath,
+      args,
+    };
+    const existingEnv = safeObject(existing.env);
+    if (workspaceEnv) {
+      entry.env = {
+        ...existingEnv,
+        METHEUS_WORKSPACE_DIR: workspaceEnv,
+      };
+    } else if (existingEnv.METHEUS_WORKSPACE_DIR) {
+      const nextEnv = { ...existingEnv };
+      delete nextEnv.METHEUS_WORKSPACE_DIR;
+      if (Object.keys(nextEnv).length > 0) {
+        entry.env = nextEnv;
+      } else {
+        delete entry.env;
+      }
+    }
+    nextServers[serverName] = entry;
+    nextConfig.mcpServers = nextServers;
+    return saveCursorMcpConfig(filePath, nextConfig);
+  }
+  if (cliBin === "antigravity") {
+    const { filePath, config } = loadAntigravityMcpConfig();
+    const nextConfig = safeObject(config);
+    const nextServers = safeObject(nextConfig.mcpServers ?? nextConfig.servers);
+    const existing = safeObject(nextServers[serverName]);
+    const args = [selfPath, "proxy", ...proxyArgs];
+    const entry = {
+      ...existing,
+      command: process.execPath,
+      args,
+    };
+    const existingEnv = safeObject(existing.env);
+    if (workspaceEnv) {
+      entry.env = {
+        ...existingEnv,
+        METHEUS_WORKSPACE_DIR: workspaceEnv,
+      };
+    } else if (existingEnv.METHEUS_WORKSPACE_DIR) {
+      const nextEnv = { ...existingEnv };
+      delete nextEnv.METHEUS_WORKSPACE_DIR;
+      if (Object.keys(nextEnv).length > 0) {
+        entry.env = nextEnv;
+      } else {
+        delete entry.env;
+      }
+    }
+    nextServers[serverName] = entry;
+    nextConfig.mcpServers = nextServers;
+    nextConfig.servers = { ...nextServers };
+    return saveAntigravityMcpConfig(filePath, nextConfig);
+  }
+  if (cliBin === "gemini") {
+    // Register in both user+project scopes for broader auto-discovery across folders.
+    const geminiProxyArgs = workspaceEnv
+      ? withWorkspaceDirArg(proxyArgs, workspaceEnv)
+      : [...proxyArgs];
+    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 legacyRun.status === 0;
+  }
+
+  const baseAddArgs = (() => {
+    if (cliBin === "claude") return ["mcp", "add", "--scope", "user", serverName];
+    return ["mcp", "add", serverName];
+  })();
+  const envArgs =
     cliBin === "codex" && workspaceEnv
       ? ["--env", `METHEUS_WORKSPACE_DIR=${workspaceEnv}`]
       : [];
-  if (codexEnvArgs.length > 0) {
+  if (envArgs.length > 0) {
     const envAttempts = [];
-    envAttempts.push([...baseAddArgs, ...codexEnvArgs, "--", process.execPath, selfPath, "proxy", ...proxyArgs]);
-    envAttempts.push([...baseAddArgs, ...codexEnvArgs, process.execPath, selfPath, "proxy", ...proxyArgs]);
+    envAttempts.push([...baseAddArgs, ...envArgs, "--", process.execPath, selfPath, "proxy", ...proxyArgs]);
+    envAttempts.push([...baseAddArgs, ...envArgs, process.execPath, selfPath, "proxy", ...proxyArgs]);
     for (const args of envAttempts) {
       const run = runCLICommand(cliBin, args, { stdio: "inherit" });
       if (run.status === 0) return true;
@@ -4182,6 +4563,29 @@ function tryRegister(cliBin, serverName, proxyArgs, options = {}) {
 }
 
 function runRemove(cliBin, serverName) {
+  if (cliBin === "cursor") {
+    const { filePath, config } = loadCursorMcpConfig();
+    const nextConfig = safeObject(config);
+    const nextServers = safeObject(nextConfig.mcpServers);
+    if (Object.prototype.hasOwnProperty.call(nextServers, serverName)) {
+      delete nextServers[serverName];
+      nextConfig.mcpServers = nextServers;
+      saveCursorMcpConfig(filePath, nextConfig);
+    }
+    return;
+  }
+  if (cliBin === "antigravity") {
+    const { filePath, config } = loadAntigravityMcpConfig();
+    const nextConfig = safeObject(config);
+    const nextServers = safeObject(nextConfig.mcpServers ?? nextConfig.servers);
+    if (Object.prototype.hasOwnProperty.call(nextServers, serverName)) {
+      delete nextServers[serverName];
+      nextConfig.mcpServers = nextServers;
+      nextConfig.servers = { ...nextServers };
+      saveAntigravityMcpConfig(filePath, nextConfig);
+    }
+    return;
+  }
   if (cliBin === "claude") {
     runCLICommand(cliBin, ["mcp", "remove", serverName, "-s", "user"], {
       stdio: "ignore",
@@ -4191,10 +4595,32 @@ 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;
+  }
   runCLICommand(cliBin, ["mcp", "remove", serverName], { stdio: "ignore" });
 }
 
 function isRegistered(cliBin, serverName) {
+  if (cliBin === "cursor") {
+    return Boolean(getCursorServerEntry(serverName));
+  }
+  if (cliBin === "antigravity") {
+    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 || "")}`;
+    const pattern = new RegExp(`(^|[\\s"'])${escapeRegExp(serverName)}([\\s"':]|$)`, "m");
+    return pattern.test(text);
+  }
   const args =
     cliBin === "claude"
       ? ["mcp", "get", serverName]
@@ -4204,6 +4630,26 @@ function isRegistered(cliBin, serverName) {
 }
 
 function getRegisteredTransport(cliBin, serverName) {
+  if (cliBin === "cursor") {
+    const entry = getCursorServerEntry(serverName);
+    if (!entry) return null;
+    return {
+      type: "stdio",
+      command: String(entry.command || "").trim(),
+      args: Array.isArray(entry.args) ? entry.args : [],
+      env: safeObject(entry.env),
+    };
+  }
+  if (cliBin === "antigravity") {
+    const entry = getAntigravityServerEntry(serverName);
+    if (!entry) return null;
+    return {
+      type: "stdio",
+      command: String(entry.command || "").trim(),
+      args: Array.isArray(entry.args) ? entry.args : [],
+      env: safeObject(entry.env),
+    };
+  }
   if (cliBin !== "codex") return null;
   const run = runCLICommand(cliBin, ["mcp", "get", serverName, "--json"], { stdio: "pipe" });
   if (run.status !== 0) return null;
@@ -4289,7 +4735,7 @@ function resolveSetupContext(flags) {
 function runSetupInternal(flags, options = {}) {
   const ensureOnly = Boolean(options.ensureOnly);
   const context = resolveSetupContext(flags);
-  const clients = ["codex", "claude"];
+  const clients = [...MCP_CLIENTS];
   const results = [];
 
   for (const cliBin of clients) {
@@ -4305,7 +4751,7 @@ function runSetupInternal(flags, options = {}) {
       ? context.workspaceDir
       : context.workspaceFallbackDir;
 
-    if (cliBin === "codex" && !context.hasWorkspaceDirFlag && !context.hasWorkspaceFallbackDirFlag) {
+    if ((cliBin === "codex" || cliBin === "cursor" || cliBin === "antigravity") && !context.hasWorkspaceDirFlag && !context.hasWorkspaceFallbackDirFlag) {
       const transport = getRegisteredTransport(cliBin, context.serverName);
       if (transport) {
         const existingWorkspaceDir = extractWorkspaceDirArg(transport.args);
@@ -4348,7 +4794,7 @@ function runSetupInternal(flags, options = {}) {
     process.stdout.write(`Ctxpack:   ${context.ctxpackKey}\n`);
   }
   if (results.length === 0) {
-    process.stdout.write("No codex/claude CLI found. Registration skipped.\n");
+    process.stdout.write("No codex/claude/gemini/antigravity/cursor CLI found. Registration skipped.\n");
     return;
   }
   for (const row of results) {

package/package.json

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