metheus-governance-mcp-cli 0.2.92 → 0.2.93

package/README.md

@@ -164,6 +164,8 @@ metheus-governance-mcp-cli setup --project-id <project_uuid> --ctxpack-key "<ctx
 - `~/.metheus/kakaotalk.env`
 - `~/.metheus/bot-runner.json`
 
+When `telegram.env` already exists, bootstrap/setup keeps your secrets but auto-normalizes the file to the latest named-entry layout so stale keys such as `TELEGRAM_BOT_<NAME>_BOT_*` are rewritten to `TELEGRAM_BOT_<NAME>_*`.
+
 Fill provider bot secrets and provider-local transport options locally. Project chat destination identifiers should be managed on the Metheus server as project chat destinations, not as local env values and not inside legacy Chat Hooks/webhooks.
 
 `~/.metheus/bot-runner.json` is the local automation profile for:

package/cli.mjs

@@ -1053,7 +1053,12 @@ function ensureProviderEnvTemplate(provider) {
   const filePath = providerEnvFilePath(provider);
   try {
     if (fs.existsSync(filePath)) {
-      return { filePath, created: false, existed: true };
+      return {
+        filePath,
+        created: false,
+        existed: true,
+        normalized: normalizeExistingProviderEnvFile(provider, filePath),
+      };
     }
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     fs.writeFileSync(filePath, providerEnvTemplate(provider), "utf8");
@@ -2636,6 +2641,15 @@ function parseSimpleEnvText(rawText) {
   return out;
 }
 
+function formatProviderEnvValue(rawValue) {
+  const text = String(rawValue ?? "");
+  if (!text) return "";
+  if (/^[A-Za-z0-9_./:@,\-]+$/.test(text)) {
+    return text;
+  }
+  return JSON.stringify(text);
+}
+
 function normalizeTelegramBotEnvKey(rawValue, fallback = "") {
   const normalized = String(rawValue || "")
     .trim()
@@ -2705,6 +2719,124 @@ function collectTelegramEnvBotEntries(parsedEnv) {
   return Array.from(entries.values());
 }
 
+function isTelegramEntryEnvKey(rawKey) {
+  return /^TELEGRAM_BOT_([A-Z0-9_]+)_(TOKEN|USERNAME|SERVER_BOT_ID|ROLE_PROFILE|AI_CLIENT|AI_MODEL|AI_PERMISSION_MODE|AI_REASONING_EFFORT)$/i
+    .test(String(rawKey || "").trim());
+}
+
+function telegramEntryCommentNameForEnv(entry) {
+  const current = safeObject(entry);
+  const username = normalizeTelegramBotUsername(current.username || "");
+  if (username) return username;
+  const key = normalizeTelegramBotEnvKey(current.key || "", "telegram_bot");
+  if (!key) return "telegram_bot";
+  return key.endsWith("_bot") ? key : `${key}_bot`;
+}
+
+function renderNormalizedTelegramEnv(parsedEnv) {
+  const parsed = safeObject(parsedEnv);
+  const entries = collectTelegramEnvBotEntries(parsed)
+    .filter((entry) => (
+      entry.token
+      || entry.username
+      || entry.serverBotID
+      || entry.roleProfile
+      || entry.client
+      || entry.model
+      || entry.permissionMode
+      || entry.reasoningEffort
+    ))
+    .sort((left, right) => String(left.key || "").localeCompare(String(right.key || "")));
+  const defaultBotKey = normalizeTelegramBotEnvKey(parsed.TELEGRAM_DEFAULT_BOT_KEY || "", "");
+  if (defaultBotKey) {
+    entries.sort((left, right) => {
+      if (left.key === defaultBotKey) return -1;
+      if (right.key === defaultBotKey) return 1;
+      return String(left.key || "").localeCompare(String(right.key || ""));
+    });
+  }
+  const lines = [
+    "# Metheus local Telegram bot settings",
+    "# Keep this file on your machine only. Do not commit it.",
+    "# Store Telegram bot secrets, AI bindings, and local transport options only.",
+    "",
+    `TELEGRAM_API_BASE_URL=${formatProviderEnvValue(parsed.TELEGRAM_API_BASE_URL || "")}`,
+    `TELEGRAM_AUTO_CLEAR_WEBHOOK=${boolFromRaw(parsed.TELEGRAM_AUTO_CLEAR_WEBHOOK, true) ? "true" : "false"}`,
+    `TELEGRAM_ALLOWED_UPDATES=${formatProviderEnvValue(String(parsed.TELEGRAM_ALLOWED_UPDATES || "").trim() || "message,edited_message")}`,
+    `TELEGRAM_DEFAULT_BOT_KEY=${formatProviderEnvValue(defaultBotKey || "")}`,
+    "",
+    "# Legacy fallback",
+    `TELEGRAM_BOT_TOKEN=${formatProviderEnvValue(parsed.TELEGRAM_BOT_TOKEN || "")}`,
+    "",
+  ];
+  if (!entries.length) {
+    lines.push("# No named Telegram bot entries configured yet", "");
+  } else {
+    entries.forEach((entry) => {
+      const upper = String(entry.key || "").trim().toUpperCase();
+      lines.push(
+        `# Telegram bot entry: ${telegramEntryCommentNameForEnv(entry)}`,
+        `TELEGRAM_BOT_${upper}_SERVER_BOT_ID=${formatProviderEnvValue(entry.serverBotID || "")}`,
+      );
+      if (String(entry.username || "").trim()) {
+        lines.push(`TELEGRAM_BOT_${upper}_USERNAME=${formatProviderEnvValue(entry.username || "")}`);
+      }
+      lines.push(
+        `TELEGRAM_BOT_${upper}_TOKEN=${formatProviderEnvValue(entry.token || "")}`,
+        `TELEGRAM_BOT_${upper}_ROLE_PROFILE=${formatProviderEnvValue(entry.roleProfile || "")}`,
+        `TELEGRAM_BOT_${upper}_AI_CLIENT=${formatProviderEnvValue(entry.client || "")}`,
+        `TELEGRAM_BOT_${upper}_AI_MODEL=${formatProviderEnvValue(entry.model || "")}`,
+        `TELEGRAM_BOT_${upper}_AI_PERMISSION_MODE=${formatProviderEnvValue(entry.permissionMode || "")}`,
+        `TELEGRAM_BOT_${upper}_AI_REASONING_EFFORT=${formatProviderEnvValue(entry.reasoningEffort || "")}`,
+        "",
+      );
+    });
+  }
+  const knownKeys = new Set([
+    "TELEGRAM_API_BASE_URL",
+    "TELEGRAM_AUTO_CLEAR_WEBHOOK",
+    "TELEGRAM_ALLOWED_UPDATES",
+    "TELEGRAM_DEFAULT_BOT_KEY",
+    "TELEGRAM_BOT_TOKEN",
+  ]);
+  entries.forEach((entry) => {
+    const upper = String(entry.key || "").trim().toUpperCase();
+    knownKeys.add(`TELEGRAM_BOT_${upper}_SERVER_BOT_ID`);
+    knownKeys.add(`TELEGRAM_BOT_${upper}_USERNAME`);
+    knownKeys.add(`TELEGRAM_BOT_${upper}_TOKEN`);
+    knownKeys.add(`TELEGRAM_BOT_${upper}_ROLE_PROFILE`);
+    knownKeys.add(`TELEGRAM_BOT_${upper}_AI_CLIENT`);
+    knownKeys.add(`TELEGRAM_BOT_${upper}_AI_MODEL`);
+    knownKeys.add(`TELEGRAM_BOT_${upper}_AI_PERMISSION_MODE`);
+    knownKeys.add(`TELEGRAM_BOT_${upper}_AI_REASONING_EFFORT`);
+  });
+  const extras = Object.keys(parsed)
+    .filter((key) => !knownKeys.has(key) && !isTelegramEntryEnvKey(key))
+    .sort((left, right) => left.localeCompare(right));
+  if (extras.length) {
+    lines.push("# Additional preserved keys");
+    extras.forEach((key) => {
+      lines.push(`${key}=${formatProviderEnvValue(parsed[key])}`);
+    });
+    lines.push("");
+  }
+  return `${lines.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd()}\n`;
+}
+
+function normalizeExistingProviderEnvFile(provider, filePath) {
+  if (normalizeBotProvider(provider) !== "telegram") return false;
+  const raw = fs.readFileSync(filePath, "utf8");
+  const rendered = renderNormalizedTelegramEnv(parseSimpleEnvText(raw));
+  if (raw.replace(/\r\n/g, "\n") === rendered.replace(/\r\n/g, "\n")) {
+    return false;
+  }
+  fs.writeFileSync(filePath, rendered, {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+  return true;
+}
+
 function resolveTelegramEnvConfig(parsedEnv, filePath, config, selectors = {}) {
   const parsed = safeObject(parsedEnv);
   const legacyToken = String(parsed.TELEGRAM_BOT_TOKEN || "").trim();
@@ -5114,6 +5246,20 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
       && telegramEnvV2ByUsername.allowedUpdates.includes("channel_post"),
     `bot=${String(telegramEnvV2ByUsername.botKey || "(none)")} updates=${String((telegramEnvV2ByUsername.allowedUpdates || []).join(","))}`,
   );
+  const telegramEnvNormalizedText = renderNormalizedTelegramEnv(parseSimpleEnvText(`
+TELEGRAM_DEFAULT_BOT_KEY=ryoai_bot
+TELEGRAM_BOT_RYOAI_BOT_SERVER_BOT_ID=bot-ryoai
+TELEGRAM_BOT_RYOAI_BOT_TOKEN=ryoai-token
+  `));
+  push(
+    "telegram_env_existing_file_auto_normalizes_named_keys",
+    telegramEnvNormalizedText.includes("TELEGRAM_DEFAULT_BOT_KEY=ryoai")
+      && telegramEnvNormalizedText.includes("TELEGRAM_BOT_RYOAI_SERVER_BOT_ID=bot-ryoai")
+      && telegramEnvNormalizedText.includes("TELEGRAM_BOT_RYOAI_TOKEN=ryoai-token")
+      && telegramEnvNormalizedText.includes("# Telegram bot entry: ryoai_bot")
+      && !telegramEnvNormalizedText.includes("TELEGRAM_BOT_RYOAI_BOT_TOKEN"),
+    telegramEnvNormalizedText,
+  );
   const telegramSupport = getProviderSupport("telegram");
   push(
     "provider_support_telegram_full_runner",

package/lib/bot-commands.mjs

@@ -441,6 +441,15 @@ function telegramEntryEnvKeys(botKey) {
   };
 }
 
+function telegramEntryCommentName(entry) {
+  const current = safeObject(entry);
+  const username = String(current.username || "").trim();
+  if (username) return username;
+  const key = String(current.key || "").trim();
+  if (!key) return "telegram_bot";
+  return key.endsWith("_bot") ? key : `${key}_bot`;
+}
+
 function persistTelegramUsername(entry) {
   const current = safeObject(entry);
   if (current.__preferServerIdentity) return "";
@@ -491,6 +500,11 @@ function telegramKnownKeys(parsedEnv, deps) {
   return keys;
 }
 
+function isTelegramEntryEnvKey(rawKey) {
+  return /^TELEGRAM_BOT_([A-Z0-9_]+)_(TOKEN|USERNAME|SERVER_BOT_ID|ROLE_PROFILE|AI_CLIENT|AI_MODEL|AI_PERMISSION_MODE|AI_REASONING_EFFORT)$/i
+    .test(String(rawKey || "").trim());
+}
+
 function renderTelegramEnv(parsedEnv, deps) {
   const parsed = safeObject(parsedEnv);
   const collectEntries = requireDependency(deps, "collectTelegramEnvBotEntries");
@@ -535,7 +549,7 @@ function renderTelegramEnv(parsedEnv, deps) {
     entries.forEach((entry) => {
       const keys = telegramEntryEnvKeys(entry.key);
       const entryLines = [
-        `# Telegram bot entry: ${entry.key}`,
+        `# Telegram bot entry: ${telegramEntryCommentName(entry)}`,
         `${keys.serverBotID}=${formatEnvValue(entry.serverBotID || "")}`,
       ];
       if (String(entry.username || "").trim()) {
@@ -555,7 +569,7 @@ function renderTelegramEnv(parsedEnv, deps) {
   }
   const knownKeys = telegramKnownKeys(parsed, deps);
   const extras = Object.keys(parsed)
-    .filter((key) => !knownKeys.has(key))
+    .filter((key) => !knownKeys.has(key) && !isTelegramEntryEnvKey(key))
     .sort((left, right) => left.localeCompare(right));
   if (extras.length) {
     lines.push("# Additional preserved keys");

package/package.json

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