metheus-governance-mcp-cli 0.2.11 → 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) {
@@ -3923,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.11",
+  "version": "0.2.12",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [