metheus-governance-mcp-cli 0.2.42 → 0.2.44

package/cli.mjs

@@ -683,12 +683,18 @@ function resolveWorkspaceDirForRequest(defaultWorkspaceDir, requestObj, toolArgs
   if (strongRequestResolved) {
     return strongRequestResolved;
   }
-  if (strongEnvResolved) {
-    return strongEnvResolved;
-  }
   if (weakRequestResolved) {
+    // Prefer client-provided current workspace over fallback env, unless request resolves to home.
+    if (isHomeWorkspaceRoot(weakRequestResolved)) {
+      if (strongEnvResolved && !isHomeWorkspaceRoot(strongEnvResolved)) {
+        return strongEnvResolved;
+      }
+    }
     return weakRequestResolved;
   }
+  if (strongEnvResolved) {
+    return strongEnvResolved;
+  }
 
   const localPreferredCandidates = [
     defaultWorkspaceDir,
@@ -2749,11 +2755,11 @@ function syncCtxpackToLocalCache({
     ? metaPath
     : path.join(resolvedWorkspaceDir, CTXPACK_META_FILENAME);
 
-  if (!workspaceSignalTrusted && !isHomeFallback) {
+  if (!workspaceSignalTrusted) {
     return {
       sync_status: "guarded",
       sync_message:
-        "Workspace signal is missing in auto mode. Guardrail blocked ctxpack local write to avoid wrong folder sync.",
+        "Workspace signal is missing in auto mode. Guardrail blocked ctxpack local write.",
       local_path: cacheDir,
       workspace_path: resolvedWorkspaceDir,
       local_file_count: 0,
@@ -3632,6 +3638,15 @@ function shouldUseSafeToolAliasesForClient(initParamsRaw) {
   return name.includes("cursor") || name.includes("antigravity");
 }
 
+function canTrustProcessCwdForClient(clientNameRaw) {
+  const name = String(clientNameRaw || "").trim().toLowerCase();
+  if (!name) return false;
+  // Codex app-server may not pass workspace signals reliably; never trust bare process.cwd().
+  if (name.includes("codex")) return false;
+  // VS Code forks generally spawn MCP in active workspace folder.
+  return name.includes("cursor") || name.includes("antigravity");
+}
+
 function displayToolNameForClient(canonicalName, useSafeToolAliases = false) {
   const canonical = String(canonicalName || "").trim();
   if (!canonical) return "";
@@ -4216,6 +4231,7 @@ async function runProxy(flags) {
   let sessionUseSafeToolAliases = false;
   let sessionToolAliasToCanonical = new Map();
   let sessionToolCanonicalToAlias = new Map();
+  let sessionClientName = "";
 
   // Proxy-initiated requests (e.g., roots/list) pending client responses.
   const pendingProxyRequests = new Map(); // id → callback(responseObj)
@@ -4347,8 +4363,13 @@ async function runProxy(flags) {
       return;
     }
 
-    if (isJsonRpcMethod(requestObj, "initialize") && shouldUseSafeToolAliasesForClient(requestObj?.params)) {
-      sessionUseSafeToolAliases = true;
+    if (isJsonRpcMethod(requestObj, "initialize")) {
+      const initParams = safeObject(requestObj?.params);
+      const initClientInfo = safeObject(initParams.clientInfo);
+      sessionClientName = String(initClientInfo.name || "").trim().toLowerCase();
+      if (shouldUseSafeToolAliasesForClient(initParams)) {
+        sessionUseSafeToolAliases = true;
+      }
     }
     if (sessionUseSafeToolAliases) {
       requestObj = rewriteAliasedToolCallToCanonical(requestObj, sessionToolAliasToCanonical);
@@ -4374,10 +4395,13 @@ async function runProxy(flags) {
       }
       if (!sessionWorkspaceDir) {
         const currentCwdCandidate = sanitizeWorkspaceCandidate(process.cwd());
-        if (currentCwdCandidate && !isHomeWorkspaceRoot(currentCwdCandidate)) {
+        if (
+          currentCwdCandidate &&
+          !isHomeWorkspaceRoot(currentCwdCandidate) &&
+          canTrustProcessCwdForClient(sessionClientName)
+        ) {
           sessionWorkspaceDir = currentCwdCandidate;
-          // VS Code forks (Antigravity, Cursor) set cwd to workspace folder
-          // when spawning MCP server processes, so treat plausible cwd as trusted.
+          // For selected clients, process cwd is a valid workspace signal.
           sessionWorkspaceTrusted = true;
         }
       }
@@ -4388,9 +4412,12 @@ async function runProxy(flags) {
         }
       }
     }
+    const hasWeakRequestWorkspaceSignal =
+      Boolean(weakRequestWorkspaceCandidate) && !isHomeWorkspaceRoot(weakRequestWorkspaceCandidate);
     const workspaceSignalTrusted =
       args.explicitPinnedWorkspace ||
       sessionWorkspaceTrusted ||
+      hasWeakRequestWorkspaceSignal ||
       Boolean(strongRequestWorkspaceCandidate || strongEnvWorkspaceCandidate);
     const requestWorkspaceDir = args.explicitPinnedWorkspace
       ? resolveWorkspaceDir(args.workspaceDir || process.cwd())
@@ -5149,13 +5176,9 @@ function runSetupInternal(flags, options = {}) {
       const transport = getRegisteredTransport(cliBin, context.serverName);
       if (transport) {
         const existingWorkspaceDir = extractWorkspaceDirArg(transport.args);
-        const existingEnv = safeObject(transport.env);
-        const existingWorkspaceEnv = String(existingEnv.METHEUS_WORKSPACE_DIR || "").trim();
         if (existingWorkspaceDir && !isAutoWorkspaceMode(existingWorkspaceDir)) {
           proxyArgsForRegister = withWorkspaceDirArg(proxyArgsForRegister, existingWorkspaceDir);
           workspaceEnvForRegister = "";
-        } else if (!workspaceEnvForRegister && existingWorkspaceEnv) {
-          workspaceEnvForRegister = resolveWorkspaceDir(existingWorkspaceEnv);
         }
       }
     }
@@ -5266,10 +5289,21 @@ function runSelftest(flags = {}) {
     const originalWorkspaceEnv = process.env.METHEUS_WORKSPACE_DIR;
     const forcedEnvWorkspace = path.join(tempRoot, "forced-workspace");
     const defaultWorkspace = path.join(tempRoot, "default-workspace");
+    const weakRequestWorkspace = path.join(tempRoot, "weak-request-workspace");
     fs.mkdirSync(forcedEnvWorkspace, { recursive: true });
     fs.mkdirSync(defaultWorkspace, { recursive: true });
+    fs.mkdirSync(weakRequestWorkspace, { recursive: true });
     process.env.METHEUS_WORKSPACE_DIR = forcedEnvWorkspace;
     const resolvedByEnvPriority = resolveWorkspaceDirForRequest(defaultWorkspace, {}, {});
+    const resolvedByWeakRequestPriority = resolveWorkspaceDirForRequest(
+      defaultWorkspace,
+      {
+        params: {
+          cwd: weakRequestWorkspace,
+        },
+      },
+      {},
+    );
     if (typeof originalWorkspaceEnv === "string") {
       process.env.METHEUS_WORKSPACE_DIR = originalWorkspaceEnv;
     } else {
@@ -5282,6 +5316,13 @@ function runSelftest(flags = {}) {
       envPriorityOk,
       `env=${forcedEnvWorkspace} default=${defaultWorkspace} resolved=${resolvedByEnvPriority || "(none)"}`,
     );
+    const weakRequestPriorityOk =
+      normalizedPathForCompare(resolvedByWeakRequestPriority) === normalizedPathForCompare(weakRequestWorkspace);
+    push(
+      "workspace_weak_request_priority_over_env",
+      weakRequestPriorityOk,
+      `request=${weakRequestWorkspace} env=${forcedEnvWorkspace} resolved=${resolvedByWeakRequestPriority || "(none)"}`,
+    );
   } catch (err) {
     push("workspace_env_guard_test_setup", false, String(err?.message || err));
   } finally {

package/package.json

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