metheus-governance-mcp-cli 0.2.33 → 0.2.35

package/cli.mjs

@@ -4031,11 +4031,71 @@ async function runProxy(flags) {
     timeoutSeconds: intFromRaw(flags["timeout-seconds"], 30),
   };
   const gatewayURL = buildGatewayURL(args);
+  // Diagnostic: log workspace resolution context to file for debugging.
+  try {
+    const _diagDir = path.join(String(process.env.USERPROFILE || process.env.HOME || "."), ".metheus");
+    fs.mkdirSync(_diagDir, { recursive: true });
+    fs.appendFileSync(
+      path.join(_diagDir, "mcp-proxy-diag.log"),
+      `[${new Date().toISOString()}] boot: cwd=${process.cwd()} workspace-dir=${workspaceDirRaw} autoMode=${workspaceAutoMode} pinned=${pinnedWorkspaceDir || "(none)"} METHEUS_WORKSPACE_DIR=${process.env.METHEUS_WORKSPACE_DIR || "(unset)"}\n`,
+    );
+  } catch { /* best-effort */ }
   let lastRefreshAttemptAtMs = 0;
   let lastRefreshError = "";
   let sessionWorkspaceDir = "";
   let sessionWorkspaceTrusted = false;
 
+  // Proxy-initiated requests (e.g., roots/list) pending client responses.
+  const pendingProxyRequests = new Map(); // id → callback(responseObj)
+  let proxyRequestIdCounter = 0;
+
+  /**
+   * Probe the MCP client for workspace roots via the standard roots/list request.
+   * This allows the proxy to discover the actual workspace folder even when the client
+   * (e.g., Antigravity) sets process.cwd() to its install directory instead of the workspace.
+   */
+  function sendRootsListProbe() {
+    const id = `_proxy_roots_${++proxyRequestIdCounter}`;
+    pendingProxyRequests.set(id, (response) => {
+      const roots = Array.isArray(response?.result?.roots) ? response.result.roots : [];
+      let foundWorkspace = "";
+      for (const root of roots) {
+        const candidate = sanitizeWorkspaceCandidate(String(root?.uri || root?.path || root?.name || ""));
+        if (candidate) {
+          foundWorkspace = candidate;
+          break;
+        }
+      }
+      try {
+        const _diagDir = path.join(String(process.env.USERPROFILE || process.env.HOME || "."), ".metheus");
+        fs.appendFileSync(
+          path.join(_diagDir, "mcp-proxy-diag.log"),
+          foundWorkspace
+            ? `[${new Date().toISOString()}] roots/list: workspace=${foundWorkspace} from ${roots.length} root(s)\n`
+            : `[${new Date().toISOString()}] roots/list: no valid workspace from ${roots.length} root(s), raw=${JSON.stringify(roots).substring(0, 300)}\n`,
+        );
+      } catch { /* best-effort */ }
+      if (foundWorkspace) {
+        sessionWorkspaceDir = foundWorkspace;
+        sessionWorkspaceTrusted = true;
+      }
+    });
+    // Timeout: if client does not respond within 10 seconds, discard the pending callback.
+    setTimeout(() => {
+      if (pendingProxyRequests.has(id)) {
+        pendingProxyRequests.delete(id);
+        try {
+          const _diagDir = path.join(String(process.env.USERPROFILE || process.env.HOME || "."), ".metheus");
+          fs.appendFileSync(
+            path.join(_diagDir, "mcp-proxy-diag.log"),
+            `[${new Date().toISOString()}] roots/list: timeout (client did not respond)\n`,
+          );
+        } catch { /* best-effort */ }
+      }
+    }, 10000);
+    process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, method: "roots/list" })}\n`);
+  }
+
   const handleIncomingMessage = async (lineRaw) => {
     const line = String(lineRaw || "").trim();
     if (!line) return;
@@ -4046,6 +4106,15 @@ async function runProxy(flags) {
       return;
     }
 
+    // Intercept responses to proxy-initiated requests (e.g., roots/list).
+    // These have an id but no method field — they are client responses, not new requests.
+    if (!requestObj.method && requestObj.id != null && pendingProxyRequests.has(String(requestObj.id))) {
+      const callback = pendingProxyRequests.get(String(requestObj.id));
+      pendingProxyRequests.delete(String(requestObj.id));
+      try { callback(requestObj); } catch { /* best-effort */ }
+      return;
+    }
+
     let resolved = resolveCurrentAccessToken();
     if (!resolved.token) {
       const nowMs = Date.now();
@@ -4131,6 +4200,15 @@ async function runProxy(flags) {
           requestObj,
           toolArgs,
         );
+    if (isJsonRpcMethod(requestObj, "tools/call")) {
+      try {
+        const _diagDir = path.join(String(process.env.USERPROFILE || process.env.HOME || "."), ".metheus");
+        fs.appendFileSync(
+          path.join(_diagDir, "mcp-proxy-diag.log"),
+          `[${new Date().toISOString()}] tools/call: tool=${toolName} sessionWS=${sessionWorkspaceDir} resolvedWS=${requestWorkspaceDir} trusted=${workspaceSignalTrusted} strongReq=${strongRequestWorkspaceCandidate || "(none)"} strongEnv=${strongEnvWorkspaceCandidate || "(none)"}\n`,
+        );
+      } catch { /* best-effort */ }
+    }
     let autoSyncSummary = null;
     if (isJsonRpcMethod(requestObj, "tools/call")) {
       autoSyncSummary = await maybeAutoSyncCtxpackForCall({
@@ -4358,6 +4436,19 @@ async function runProxy(flags) {
             patched = appendLocalToolToToolsList(patched);
           } else if (isJsonRpcMethod(requestObj, "initialize")) {
             patched = appendProjectHintToInitialize(patched, args);
+            // Log initialize params for workspace debugging.
+            try {
+              const _diagDir = path.join(String(process.env.USERPROFILE || process.env.HOME || "."), ".metheus");
+              const initParams = safeObject(requestObj?.params);
+              fs.appendFileSync(
+                path.join(_diagDir, "mcp-proxy-diag.log"),
+                `[${new Date().toISOString()}] initialize: clientInfo=${JSON.stringify(initParams.clientInfo || {})} capabilities=${JSON.stringify(initParams.capabilities || {})} rootUri=${initParams.rootUri || "(none)"} workspaceFolders=${JSON.stringify(initParams.workspaceFolders || []).substring(0, 300)}\n`,
+              );
+            } catch { /* best-effort */ }
+            // Probe client workspace roots via MCP roots/list protocol.
+            // Use setImmediate so the initialize response is flushed to stdout first;
+            // the client must see the response before it can handle server-initiated requests.
+            setImmediate(() => sendRootsListProbe());
           } else if (isJsonRpcMethod(requestObj, "tools/call") && toolName === "workitem.list") {
             patched = await appendWorkitemListHints(patched, args, toolArgs, token, workspaceSignalTrusted);
           } else if (isJsonRpcMethod(requestObj, "tools/call") && toolName === "ctxpack.ensure") {

package/package.json

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