metheus-governance-mcp-cli 0.2.20 → 0.2.22

package/cli.mjs

@@ -1913,7 +1913,7 @@ async function runDoctor(flags) {
   );
 
   const syncStatus = String(summary.ctxpack_sync_status || "").trim();
-  if (["downloaded", "updated", "current"].includes(syncStatus)) {
+  if (["downloaded", "updated", "current", "home_fallback"].includes(syncStatus)) {
     addDoctorCheck(
       rows,
       "ok",
@@ -2489,20 +2489,15 @@ function syncCtxpackToLocalCache({
   const status = String(ctxpack?.status || "").trim() || "draft";
   const files = normalizeCtxpackFiles(ctxpack?.files);
   const resolvedWorkspaceDir = resolveWorkspaceDir(workspaceDir);
-  const cacheDir = path.join(ctxpackCacheRootDir(resolvedWorkspaceDir), projectID);
+  const isHomeFallback = isHomeWorkspaceRoot(resolvedWorkspaceDir) && !allowHomeWorkspaceRoot();
+  const cacheDir = path.join(
+    isHomeFallback ? homeCtxpackCacheRootDir() : ctxpackCacheRootDir(resolvedWorkspaceDir),
+    projectID,
+  );
   const metaPath = path.join(cacheDir, CTXPACK_META_FILENAME);
-  const workspaceMetaPath = path.join(resolvedWorkspaceDir, CTXPACK_META_FILENAME);
-
-  if (isHomeWorkspaceRoot(resolvedWorkspaceDir) && !allowHomeWorkspaceRoot()) {
-    return {
-      sync_status: "guarded",
-      sync_message:
-        "Workspace root resolved to home directory. Guardrail blocked ctxpack local write. Use --workspace-dir <project_path> or --workspace-dir auto.",
-      local_path: cacheDir,
-      workspace_path: resolvedWorkspaceDir,
-      local_file_count: 0,
-    };
-  }
+  const workspaceMetaPath = isHomeFallback
+    ? metaPath
+    : path.join(resolvedWorkspaceDir, CTXPACK_META_FILENAME);
 
   if (!workspaceSignalTrusted) {
     return {
@@ -2549,8 +2544,10 @@ function syncCtxpackToLocalCache({
       // Best-effort metadata refresh for workspace-root auto-detection.
     }
     return {
-      sync_status: "current",
-      sync_message: "Local ctxpack cache is up to date.",
+      sync_status: isHomeFallback ? "home_fallback" : "current",
+      sync_message: isHomeFallback
+        ? "Ctxpack cached in home directory. Workspace was not detected; use --workspace-dir for project-local cache."
+        : "Local ctxpack cache is up to date.",
       local_path: cacheDir,
       workspace_path: resolvedWorkspaceDir,
       local_file_count: files.length,
@@ -2571,10 +2568,12 @@ function syncCtxpackToLocalCache({
     fs.writeFileSync(workspaceMetaPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
 
     return {
-      sync_status: previousMeta ? "updated" : "downloaded",
-      sync_message: previousMeta
-        ? "Ctxpack updated to latest server version."
-        : "Ctxpack downloaded to local cache.",
+      sync_status: isHomeFallback ? "home_fallback" : (previousMeta ? "updated" : "downloaded"),
+      sync_message: isHomeFallback
+        ? "Ctxpack cached in home directory. Workspace was not detected; use --workspace-dir for project-local cache."
+        : (previousMeta
+          ? "Ctxpack updated to latest server version."
+          : "Ctxpack downloaded to local cache."),
       local_path: cacheDir,
       workspace_path: resolvedWorkspaceDir,
       local_file_count: files.length,
@@ -4126,11 +4125,18 @@ function tryRegister(cliBin, serverName, proxyArgs, options = {}) {
     cliBin === "codex" && workspaceEnv
       ? ["--env", `METHEUS_WORKSPACE_DIR=${workspaceEnv}`]
       : [];
-  const attempts = [];
   if (codexEnvArgs.length > 0) {
-    attempts.push([...baseAddArgs, ...codexEnvArgs, "--", process.execPath, selfPath, "proxy", ...proxyArgs]);
-    attempts.push([...baseAddArgs, ...codexEnvArgs, process.execPath, selfPath, "proxy", ...proxyArgs]);
+    const envAttempts = [];
+    envAttempts.push([...baseAddArgs, ...codexEnvArgs, "--", process.execPath, selfPath, "proxy", ...proxyArgs]);
+    envAttempts.push([...baseAddArgs, ...codexEnvArgs, process.execPath, selfPath, "proxy", ...proxyArgs]);
+    for (const args of envAttempts) {
+      const run = runCLICommand(cliBin, args, { stdio: "inherit" });
+      if (run.status === 0) return true;
+    }
+    // Do not silently downgrade to no-env registration when fallback env was requested.
+    return false;
   }
+  const attempts = [];
   attempts.push([...baseAddArgs, "--", process.execPath, selfPath, "proxy", ...proxyArgs]);
   attempts.push([...baseAddArgs, process.execPath, selfPath, "proxy", ...proxyArgs]);
   for (const args of attempts) {
@@ -4162,6 +4168,44 @@ function isRegistered(cliBin, serverName) {
   return run.status === 0;
 }
 
+function getRegisteredTransport(cliBin, serverName) {
+  if (cliBin !== "codex") return null;
+  const run = runCLICommand(cliBin, ["mcp", "get", serverName, "--json"], { stdio: "pipe" });
+  if (run.status !== 0) return null;
+  const parsed = tryJsonParse(String(run.stdout || ""));
+  const transport = safeObject(parsed?.transport);
+  if (!transport.type) return null;
+  return transport;
+}
+
+function extractWorkspaceDirArg(args) {
+  if (!Array.isArray(args)) return "";
+  for (let i = 0; i < args.length; i += 1) {
+    if (String(args[i] || "").trim() !== "--workspace-dir") continue;
+    return String(args[i + 1] || "").trim();
+  }
+  return "";
+}
+
+function withWorkspaceDirArg(args, workspaceDir) {
+  const next = [];
+  let replaced = false;
+  for (let i = 0; i < args.length; i += 1) {
+    const token = String(args[i] || "").trim();
+    if (token !== "--workspace-dir") {
+      next.push(args[i]);
+      continue;
+    }
+    next.push("--workspace-dir", workspaceDir);
+    i += 1;
+    replaced = true;
+  }
+  if (!replaced) {
+    next.push("--workspace-dir", workspaceDir);
+  }
+  return next;
+}
+
 function resolveSetupContext(flags) {
   const workspaceMeta = loadWorkspaceMeta(process.cwd());
   const projectID = String(flags["project-id"] || workspaceMeta.project_id || "").trim();
@@ -4170,6 +4214,8 @@ function resolveSetupContext(flags) {
   const workspaceDirRaw = String(flags["workspace-dir"] || "").trim();
   const workspaceFallbackDirRaw = String(flags["workspace-fallback-dir"] || "").trim();
   const hasWorkspaceDirFlag = Object.prototype.hasOwnProperty.call(flags, "workspace-dir");
+  const hasWorkspaceFallbackDirFlag = Object.prototype.hasOwnProperty.call(flags, "workspace-fallback-dir");
+  const hasAnySetupOverride = Object.keys(safeObject(flags)).length > 0;
   // Default to auto workspace mode for safer multi-project Codex sessions.
   const workspaceAutoMode = !hasWorkspaceDirFlag || isAutoWorkspaceMode(workspaceDirRaw);
   // Pin only when user explicitly set a non-auto workspace-dir.
@@ -4195,6 +4241,9 @@ function resolveSetupContext(flags) {
     baseURL,
     workspaceDir,
     workspaceFallbackDir,
+    hasWorkspaceDirFlag,
+    hasWorkspaceFallbackDirFlag,
+    hasAnySetupOverride,
     shouldPinWorkspaceDir,
     workspaceAutoMode,
     serverName,
@@ -4211,13 +4260,36 @@ function runSetupInternal(flags, options = {}) {
   for (const cliBin of clients) {
     if (!commandExists(cliBin)) continue;
     const alreadyRegistered = isRegistered(cliBin, context.serverName);
+    if (ensureOnly && alreadyRegistered && !context.hasAnySetupOverride) {
+      results.push({ cliBin, ok: true, action: "kept" });
+      continue;
+    }
+
+    let proxyArgsForRegister = [...context.proxyArgs];
+    let workspaceEnvForRegister = context.shouldPinWorkspaceDir
+      ? context.workspaceDir
+      : context.workspaceFallbackDir;
+
+    if (cliBin === "codex" && !context.hasWorkspaceDirFlag && !context.hasWorkspaceFallbackDirFlag) {
+      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);
+        }
+      }
+    }
+
     if (!ensureOnly || alreadyRegistered) {
       runRemove(cliBin, context.serverName);
     }
-    const ok = tryRegister(cliBin, context.serverName, context.proxyArgs, {
-      workspaceDir: context.shouldPinWorkspaceDir
-        ? context.workspaceDir
-        : context.workspaceFallbackDir,
+    const ok = tryRegister(cliBin, context.serverName, proxyArgsForRegister, {
+      workspaceDir: workspaceEnvForRegister,
     });
     const action = ensureOnly
       ? alreadyRegistered

package/package.json

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