metheus-governance-mcp-cli 0.2.11 → 0.2.13

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();
 
@@ -30,12 +35,12 @@ function printUsage() {
       "Metheus Governance MCP CLI",
       "",
       "Usage:",
-      `  ${cmd} [--project-id <uuid>] [--ctxpack-key <key>] [--base-url <url>] [--workspace-dir <path>] [--flow <auto|device|callback|manual>]`,
+      `  ${cmd} [--project-id <uuid>] [--ctxpack-key <key>] [--base-url <url>] [--workspace-dir <path|auto>] [--flow <auto|device|callback|manual>]`,
       `  ${cmd} init [--project-id <uuid>] [--ctxpack-key <key>] [--base-url <url>] [--flow <auto|device|callback|manual>]`,
-      `  ${cmd} setup [--project-id <uuid>] [--ctxpack-key <key>] [--base-url <url>] [--workspace-dir <path>] [--name <server_name>]`,
+      `  ${cmd} setup [--project-id <uuid>] [--ctxpack-key <key>] [--base-url <url>] [--workspace-dir <path|auto>] [--name <server_name>]`,
       `  ${cmd} doctor [--project-id <uuid>] [--ctxpack-key <key>] [--base-url <url>] [--timeout-seconds <n>]`,
-      `  ${cmd} proxy [--project-id <uuid>] [--ctxpack-key <key>] [--base-url <url>] [--workspace-dir <path>] [--include-drafts <true|false>] [--auto-pull-on-conflict <true|false>] [--timeout-seconds <n>]`,
-      `  ${cmd} ctxpack pull [--project-id <uuid>] [--base-url <url>] [--workspace-dir <path>] [--paths <csv>] [--timeout-seconds <n>]`,
+      `  ${cmd} proxy [--project-id <uuid>] [--ctxpack-key <key>] [--base-url <url>] [--workspace-dir <path|auto>] [--include-drafts <true|false>] [--auto-pull-on-conflict <true|false>] [--timeout-seconds <n>]`,
+      `  ${cmd} ctxpack pull [--project-id <uuid>] [--base-url <url>] [--workspace-dir <path|auto>] [--paths <csv>] [--timeout-seconds <n>]`,
       `  ${cmd} auth status`,
       `  ${cmd} auth login [--base-url <url>] [--flow <auto|device|callback|manual>] [--keycloak-url <url>] [--realm <name>] [--client-id <id>] [--open-browser <true|false>] [--callback-port <n>] [--timeout-seconds <n>] [--manual <true|false>]`,
       `  ${cmd} auth set --token <jwt> [--refresh-token <token>] [--base-url <url>]`,
@@ -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) {
@@ -113,6 +285,13 @@ function resolveWorkspaceDir(rawPath) {
   return path.resolve(process.cwd());
 }
 
+function isAutoWorkspaceMode(rawValue) {
+  const value = String(rawValue || "")
+    .trim()
+    .toLowerCase();
+  return value === "auto" || value === "dynamic" || value === "client";
+}
+
 function fileURIToLocalPath(rawValue) {
   const value = String(rawValue || "").trim();
   if (!value || !/^file:\/\//i.test(value)) return "";
@@ -3832,13 +4011,17 @@ function resolveSetupContext(flags) {
   const ctxpackKey = String(flags["ctxpack-key"] || buildCtxpackKeyFromMeta(workspaceMeta) || "").trim();
   const baseURL = String(flags["base-url"] || DEFAULT_SITE_URL).trim().replace(/\/+$/, "");
   const workspaceDirRaw = String(flags["workspace-dir"] || "").trim();
-  const hasExplicitWorkspaceDir = workspaceDirRaw.length > 0;
-  const workspaceDir = resolveWorkspaceDir(hasExplicitWorkspaceDir ? workspaceDirRaw : process.cwd());
+  const workspaceAutoMode = isAutoWorkspaceMode(workspaceDirRaw);
+  const hasWorkspaceDirFlag = workspaceDirRaw.length > 0;
+  const shouldPinWorkspaceDir = !workspaceAutoMode;
+  const workspaceDir = resolveWorkspaceDir(
+    hasWorkspaceDirFlag && !workspaceAutoMode ? workspaceDirRaw : process.cwd(),
+  );
   const serverName = String(flags.name || DEFAULT_SERVER_NAME).trim() || DEFAULT_SERVER_NAME;
   const proxyArgs = ["--base-url", `${baseURL}/governance/mcp`];
-  // Default mode: do not pin workspace path in MCP registration.
-  // Let client runtime cwd resolve per open folder/workspace.
-  if (hasExplicitWorkspaceDir) {
+  // Default mode pins workspace path to where setup/init runs.
+  // Use --workspace-dir auto when runtime auto-detection is preferred.
+  if (shouldPinWorkspaceDir) {
     proxyArgs.push("--workspace-dir", workspaceDir);
   }
   if (projectID) proxyArgs.push("--project-id", projectID);
@@ -3848,7 +4031,8 @@ function resolveSetupContext(flags) {
     ctxpackKey,
     baseURL,
     workspaceDir,
-    hasExplicitWorkspaceDir,
+    shouldPinWorkspaceDir,
+    workspaceAutoMode,
     serverName,
     proxyArgs,
   };
@@ -3880,9 +4064,7 @@ function runSetupInternal(flags, options = {}) {
   process.stdout.write(ensureOnly ? "\nEnsure complete.\n" : "\nInstall complete.\n");
   process.stdout.write(`Server:    ${context.serverName}\n`);
   process.stdout.write(`Gateway:   ${context.baseURL}/governance/mcp\n`);
-  process.stdout.write(
-    `Workspace: ${context.hasExplicitWorkspaceDir ? context.workspaceDir : "auto (client current folder)"}\n`,
-  );
+  process.stdout.write(`Workspace: ${context.shouldPinWorkspaceDir ? context.workspaceDir : "auto (client current folder)"}\n`);
   process.stdout.write(`Project:   ${context.projectID || "auto-detect from .metheus_ctxpack_sync.json"}\n`);
   if (context.ctxpackKey) {
     process.stdout.write(`Ctxpack:   ${context.ctxpackKey}\n`);
@@ -3923,6 +4105,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.13",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [