metheus-governance-mcp-cli 0.2.10 → 0.2.12

package/cli.mjs

@@ -14,12 +14,17 @@ const DEFAULT_SITE_URL = "https://metheus.gesiaplatform.com";
 const DEFAULT_BASE_URL = `${DEFAULT_SITE_URL}/governance/mcp`;
 const DEFAULT_SERVER_NAME = "metheus-governance-mcp";
 const AUTH_STORE_RELATIVE_PATH = path.join(".metheus", "governance-mcp-auth.json");
+const SELF_UPDATE_STATE_RELATIVE_PATH = path.join(".metheus", "governance-mcp-cli-update.json");
 const CTXPACK_CACHE_RELATIVE_DIR = path.join(".metheus", "ctxpack-cache");
 const CTXPACK_META_FILENAME = ".metheus_ctxpack_sync.json";
 const CTXPACK_PUSH_TOOL_NAMES = ["ctxpack.push", "ctxpack.update", "ctxpack.save"];
 const CLI_META = loadCLIMeta();
 const CLI_NAME = CLI_META.name || "metheus-governance-mcp-cli";
 const CLI_VERSION = CLI_META.version || "0.0.0";
+const SELF_UPDATE_CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000;
+const SELF_UPDATE_TIMEOUT_SECONDS = 6;
+const SELF_UPDATE_ENV_KEY = "METHEUS_CLI_AUTO_UPDATE";
+const SELF_UPDATE_GUARD_ENV_KEY = "METHEUS_CLI_SELF_UPDATE_ATTEMPTED";
 const AUTO_CTXPACK_SYNC_INTERVAL_MS = 60 * 1000;
 const autoCtxpackSyncTracker = new Map();
 
@@ -44,6 +49,7 @@ function printUsage() {
       "",
       "Environment:",
       "  METHEUS_TOKEN or MCP_AUTH_TOKEN is used first for proxy requests.",
+      `  ${SELF_UPDATE_ENV_KEY}=0 to disable startup auto-update check.`,
       "  If env is missing, stored token file is used:",
       `    ${AUTH_STORE_RELATIVE_PATH}`,
       "",
@@ -69,6 +75,176 @@ function printVersion() {
   process.stdout.write(`${CLI_NAME} ${CLI_VERSION}\n`);
 }
 
+function resolveHomeFilePath(relativePath) {
+  const home = String(process.env.USERPROFILE || process.env.HOME || "").trim();
+  if (!home) {
+    return path.resolve(process.cwd(), relativePath);
+  }
+  return path.join(home, relativePath);
+}
+
+function updateStateFilePath() {
+  return resolveHomeFilePath(SELF_UPDATE_STATE_RELATIVE_PATH);
+}
+
+function loadSelfUpdateState() {
+  const filePath = updateStateFilePath();
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { filePath, checkedAt: "", latestVersion: "", installedVersion: "", updatedAt: "" };
+    }
+    return {
+      filePath,
+      checkedAt: String(parsed.checked_at || "").trim(),
+      latestVersion: String(parsed.latest_version || "").trim(),
+      installedVersion: String(parsed.installed_version || "").trim(),
+      updatedAt: String(parsed.updated_at || "").trim(),
+    };
+  } catch {
+    return { filePath, checkedAt: "", latestVersion: "", installedVersion: "", updatedAt: "" };
+  }
+}
+
+function saveSelfUpdateState(nextState) {
+  const filePath = updateStateFilePath();
+  const payload = {
+    package_name: CLI_NAME,
+    checked_at: String(nextState?.checkedAt || "").trim() || new Date().toISOString(),
+    latest_version: String(nextState?.latestVersion || "").trim(),
+    installed_version: String(nextState?.installedVersion || "").trim(),
+    updated_at: String(nextState?.updatedAt || "").trim(),
+  };
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+
+function parseSemver(rawVersion) {
+  const match = String(rawVersion || "")
+    .trim()
+    .match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+  if (!match) return null;
+  return {
+    major: Number.parseInt(match[1], 10),
+    minor: Number.parseInt(match[2], 10),
+    patch: Number.parseInt(match[3], 10),
+    prerelease: String(match[4] || "").trim(),
+  };
+}
+
+function compareSemver(leftRaw, rightRaw) {
+  const left = parseSemver(leftRaw);
+  const right = parseSemver(rightRaw);
+  if (!left || !right) {
+    return String(leftRaw || "").localeCompare(String(rightRaw || ""));
+  }
+  if (left.major !== right.major) return left.major - right.major;
+  if (left.minor !== right.minor) return left.minor - right.minor;
+  if (left.patch !== right.patch) return left.patch - right.patch;
+  const leftPre = left.prerelease;
+  const rightPre = right.prerelease;
+  if (leftPre === rightPre) return 0;
+  if (!leftPre) return 1;
+  if (!rightPre) return -1;
+  return leftPre.localeCompare(rightPre);
+}
+
+function hasNoUpdateFlag(argv) {
+  return argv.some((arg) => String(arg || "").trim().toLowerCase() === "--no-update");
+}
+
+function parseIsoMs(raw) {
+  const parsed = Date.parse(String(raw || "").trim());
+  if (!Number.isFinite(parsed) || parsed <= 0) return 0;
+  return parsed;
+}
+
+async function fetchLatestCLIVersion(timeoutSeconds = SELF_UPDATE_TIMEOUT_SECONDS) {
+  const url = `https://registry.npmjs.org/${encodeURIComponent(CLI_NAME)}/latest`;
+  const body = await getJSON(url, timeoutSeconds);
+  return String(body?.version || "").trim();
+}
+
+function applyRerunExitResult(runResult) {
+  if (runResult?.error) {
+    process.stderr.write(`[${CLI_NAME}] restart failed: ${String(runResult.error.message || runResult.error)}\n`);
+    return;
+  }
+  if (typeof runResult?.status === "number") {
+    process.exit(runResult.status);
+    return;
+  }
+  if (runResult?.signal) {
+    process.kill(process.pid, runResult.signal);
+    return;
+  }
+  process.exit(0);
+}
+
+async function maybeAutoUpdate(commandToken, argv) {
+  const command = String(commandToken || "").trim().toLowerCase();
+  if (command === "proxy") return;
+  if (command === "-v" || command === "--version" || command === "version") return;
+  if (command === "-h" || command === "--help") return;
+  if (String(process.env[SELF_UPDATE_GUARD_ENV_KEY] || "").trim() === "1") return;
+  if (hasNoUpdateFlag(argv)) return;
+  if (!boolFromRaw(process.env[SELF_UPDATE_ENV_KEY], true)) return;
+
+  const nowIso = new Date().toISOString();
+  const cached = loadSelfUpdateState();
+  let latestVersion = "";
+  const checkedMs = parseIsoMs(cached.checkedAt);
+  if (checkedMs > 0 && Date.now() - checkedMs < SELF_UPDATE_CHECK_INTERVAL_MS) {
+    latestVersion = cached.latestVersion;
+  }
+  if (!latestVersion) {
+    try {
+      latestVersion = await fetchLatestCLIVersion(SELF_UPDATE_TIMEOUT_SECONDS);
+    } catch {
+      latestVersion = "";
+    }
+    saveSelfUpdateState({
+      checkedAt: nowIso,
+      latestVersion,
+      installedVersion: CLI_VERSION,
+      updatedAt: cached.updatedAt,
+    });
+  }
+
+  if (!latestVersion || compareSemver(latestVersion, CLI_VERSION) <= 0) {
+    return;
+  }
+
+  process.stderr.write(`[${CLI_NAME}] update available (${CLI_VERSION} -> ${latestVersion}). Installing...\n`);
+  const run = runCLICommand("npm", ["install", "-g", `${CLI_NAME}@latest`], {
+    stdio: "inherit",
+  });
+  if (run.status !== 0) {
+    process.stderr.write(`[${CLI_NAME}] auto-update failed. Continue with current version ${CLI_VERSION}.\n`);
+    return;
+  }
+
+  const updatedAt = new Date().toISOString();
+  saveSelfUpdateState({
+    checkedAt: updatedAt,
+    latestVersion,
+    installedVersion: latestVersion,
+    updatedAt,
+  });
+  process.stderr.write(`[${CLI_NAME}] updated to ${latestVersion}. Restarting...\n`);
+
+  const selfPath = fileURLToPath(import.meta.url);
+  const rerun = spawnSync(process.execPath, [selfPath, ...argv], {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      [SELF_UPDATE_GUARD_ENV_KEY]: "1",
+    },
+  });
+  applyRerunExitResult(rerun);
+}
+
 function parseArgs(argv) {
   const out = {};
   for (let i = 0; i < argv.length; i += 1) {
@@ -98,11 +274,7 @@ function normalizeToken(raw) {
 }
 
 function authStoreFilePath() {
-  const home = String(process.env.USERPROFILE || process.env.HOME || "").trim();
-  if (!home) {
-    return path.resolve(process.cwd(), AUTH_STORE_RELATIVE_PATH);
-  }
-  return path.join(home, AUTH_STORE_RELATIVE_PATH);
+  return resolveHomeFilePath(AUTH_STORE_RELATIVE_PATH);
 }
 
 function resolveWorkspaceDir(rawPath) {
@@ -140,12 +312,33 @@ function firstNonEmptyString(values) {
   return "";
 }
 
+function isEditorInstallDirectory(candidatePath) {
+  const normalized = String(candidatePath || "").replace(/\//g, "\\").toLowerCase();
+  if (!normalized) return false;
+  // Guard against runtime cwd/env resolving to editor installation directory
+  // instead of the actual opened workspace.
+  if (normalized.includes("\\appdata\\local\\programs\\microsoft vs code")) return true;
+  if (normalized.includes("\\program files\\microsoft vs code")) return true;
+  if (normalized.includes("\\program files (x86)\\microsoft vs code")) return true;
+  return false;
+}
+
+function sanitizeWorkspaceCandidate(rawCandidate) {
+  const fileCandidate = fileURIToLocalPath(rawCandidate);
+  const candidate = firstNonEmptyString([fileCandidate, rawCandidate]);
+  if (!candidate) return "";
+  const resolved = resolveWorkspaceDir(candidate);
+  if (!resolved) return "";
+  if (isEditorInstallDirectory(resolved)) return "";
+  return resolved;
+}
+
 function extractWorkspaceCandidateFromFolders(rawFolders) {
   if (!Array.isArray(rawFolders)) return "";
   for (const folder of rawFolders) {
     if (typeof folder === "string") {
-      const direct = firstNonEmptyString([fileURIToLocalPath(folder), folder]);
-      if (direct) return resolveWorkspaceDir(direct);
+      const direct = sanitizeWorkspaceCandidate(folder);
+      if (direct) return direct;
       continue;
     }
     if (!folder || typeof folder !== "object" || Array.isArray(folder)) continue;
@@ -157,8 +350,8 @@ function extractWorkspaceCandidateFromFolders(rawFolders) {
       folder.root_path,
       folder.rootPath,
     ]);
-    const candidate = firstNonEmptyString([fileURIToLocalPath(uriValue), uriValue]);
-    if (candidate) return resolveWorkspaceDir(candidate);
+    const candidate = sanitizeWorkspaceCandidate(uriValue);
+    if (candidate) return candidate;
   }
   return "";
 }
@@ -192,10 +385,7 @@ function extractWorkspaceCandidateFromRequest(requestObj, toolArgs) {
     meta.root_uri,
     meta.rootUri,
   ]);
-  const fileCandidate = fileURIToLocalPath(rawCandidate);
-  const candidate = firstNonEmptyString([fileCandidate, rawCandidate]);
-  if (!candidate) return "";
-  return resolveWorkspaceDir(candidate);
+  return sanitizeWorkspaceCandidate(rawCandidate);
 }
 
 function extractWorkspaceCandidateFromEnv() {
@@ -208,26 +398,22 @@ function extractWorkspaceCandidateFromEnv() {
     process.env.WORKSPACE_DIR,
     process.env.WORKSPACE_FOLDER,
     process.env.VSCODE_WORKSPACE_FOLDER,
-    process.env.VSCODE_CWD,
     process.env.PWD,
     process.env.INIT_CWD,
+    process.env.VSCODE_CWD,
   ]);
-  const fileCandidate = fileURIToLocalPath(rawCandidate);
-  const candidate = firstNonEmptyString([fileCandidate, rawCandidate]);
-  if (!candidate) return "";
-  return resolveWorkspaceDir(candidate);
+  return sanitizeWorkspaceCandidate(rawCandidate);
 }
 
 function resolveWorkspaceDirForRequest(defaultWorkspaceDir, requestObj, toolArgs) {
   const requestCandidate = extractWorkspaceCandidateFromRequest(requestObj, toolArgs);
   const envCandidate = extractWorkspaceCandidateFromEnv();
-  const candidate = firstNonEmptyString([
-    requestCandidate,
-    envCandidate,
-    defaultWorkspaceDir,
-    process.cwd(),
-  ]);
-  return resolveWorkspaceDir(candidate);
+  const homeCandidate = firstNonEmptyString([process.env.USERPROFILE, process.env.HOME]);
+  for (const rawCandidate of [requestCandidate, envCandidate, defaultWorkspaceDir, process.cwd(), homeCandidate]) {
+    const resolved = sanitizeWorkspaceCandidate(rawCandidate);
+    if (resolved) return resolved;
+  }
+  return resolveWorkspaceDir(process.cwd());
 }
 
 function resolveProjectIDForRequest({
@@ -3508,14 +3694,10 @@ async function runProxy(flags) {
     } else if (envWorkspaceCandidate) {
       sessionWorkspaceDir = envWorkspaceCandidate;
     }
-    const requestWorkspaceDir = resolveWorkspaceDir(
-      firstNonEmptyString([
-        requestWorkspaceCandidate,
-        envWorkspaceCandidate,
-        sessionWorkspaceDir,
-        args.workspaceDir,
-        process.cwd(),
-      ]),
+    const requestWorkspaceDir = resolveWorkspaceDirForRequest(
+      firstNonEmptyString([sessionWorkspaceDir, args.workspaceDir, process.cwd()]),
+      requestObj,
+      toolArgs,
     );
     let autoSyncSummary = null;
     if (isJsonRpcMethod(requestObj, "tools/call")) {
@@ -3913,6 +4095,7 @@ async function runBootstrap(flags) {
 async function main() {
   const [, , rawCommand, ...rest] = process.argv;
   const command = String(rawCommand || "");
+  await maybeAutoUpdate(command, process.argv.slice(2));
 
   if (command === "-v" || command === "--version" || command === "version") {
     printVersion();

package/package.json

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