metheus-governance-mcp-cli 0.2.52 → 0.2.53

package/README.md

@@ -20,23 +20,35 @@ Compatibility note: legacy command alias `metheus-governance-mcp` is still suppo
 npm install -g metheus-governance-mcp-cli@latest
 ```
 
-Install creates a local Telegram settings template here:
+Install creates local provider settings templates here:
 
 - `~/.metheus/telegram.env`
+- `~/.metheus/slack.env`
+- `~/.metheus/kakaotalk.env`
 
-This file is for the local Telegram bot secret only.
+These files are for local provider bot secrets only.
 
 - Store locally:
   - `TELEGRAM_BOT_TOKEN`
-- Server-side Metheus stores project Telegram destination metadata separately:
-  - `chat_id`
+  - `SLACK_BOT_TOKEN`
+  - `KAKAOTALK_BOT_TOKEN`
+- Server-side Metheus stores project chat destination metadata separately:
+  - provider
+  - `chat_id` / channel / room identifier
   - label / active state
-- Do not put project `chat_id` in the local Telegram env file.
+- Do not put project chat destination identifiers in local env files.
 
-Example template:
+Example templates:
 
 ```env
+# ~/.metheus/telegram.env
 TELEGRAM_BOT_TOKEN=
+
+# ~/.metheus/slack.env
+SLACK_BOT_TOKEN=
+
+# ~/.metheus/kakaotalk.env
+KAKAOTALK_BOT_TOKEN=
 ```
 
 ## One command bootstrap (recommended)
@@ -69,11 +81,13 @@ Recommended for Codex/Claude/Gemini/Antigravity/Cursor multi-workspace sessions:
 metheus-governance-mcp-cli setup --project-id <project_uuid> --ctxpack-key "<ctxpack_key>" --base-url https://metheus.gesiaplatform.com --workspace-dir auto
 ```
 
-`setup` also ensures the local Telegram template exists:
+`setup` also ensures local provider templates exist:
 
 - `~/.metheus/telegram.env`
+- `~/.metheus/slack.env`
+- `~/.metheus/kakaotalk.env`
 
-Fill only the bot token locally. Project Telegram `chat_id` destinations should be managed on the Metheus server as project Telegram destinations, not as local env values and not inside Chat Hooks.
+Fill only provider bot tokens 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.
 
 Gemini CLI note:
 - `gemini mcp` commands require Gemini auth to be configured first (`GEMINI_API_KEY` or `~/.gemini/settings.json` auth).
@@ -105,7 +119,8 @@ metheus-governance-mcp-cli doctor --project-id <project_uuid> --base-url https:/
 
 Checks:
 - auth token status (+ auto refresh attempt)
-- local Telegram env token presence
+- local provider env template presence
+- local provider token presence for active project destinations
 - codex/claude/gemini/antigravity/cursor registration state
 - gateway `tools/list` reachability
 - `project.summary` access
@@ -113,10 +128,14 @@ Checks:
 - smoke calls: `workitem.list`, `evidence.list`, `decision.list`
 
 Direct bot posting:
-- `me.send-bot-message` uses the local `TELEGRAM_BOT_TOKEN` from `~/.metheus/telegram.env`
+- `me.send-bot-message` uses local provider tokens from `~/.metheus/<provider>.env`
 - it does not use a server-stored bot token
-- the destination `chat_id` is resolved from the current project's saved Chat Destinations on the Metheus server
-- if multiple active Telegram destinations exist for the project, pass `destination_id` or `destination_label`
+- the destination identifier is resolved from the current project's saved Chat Destinations on the Metheus server
+- if multiple active destinations exist for the same provider, pass `destination_id` or `destination_label`
+- direct local delivery is implemented today for:
+  - Telegram
+  - Slack
+- KakaoTalk profiles and destinations can be stored now, but direct local delivery is not implemented yet
 
 ## Use in MCP
 

package/cli.mjs

@@ -15,7 +15,27 @@ 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 TELEGRAM_ENV_RELATIVE_PATH = path.join(".metheus", "telegram.env");
+const PROVIDER_ENV_CONFIG = {
+  telegram: {
+    relativePath: path.join(".metheus", "telegram.env"),
+    tokenKey: "TELEGRAM_BOT_TOKEN",
+    label: "Telegram",
+    verifyURL: "https://api.telegram.org",
+  },
+  slack: {
+    relativePath: path.join(".metheus", "slack.env"),
+    tokenKey: "SLACK_BOT_TOKEN",
+    label: "Slack",
+    verifyURL: "https://slack.com/api/auth.test",
+  },
+  kakaotalk: {
+    relativePath: path.join(".metheus", "kakaotalk.env"),
+    tokenKey: "KAKAOTALK_BOT_TOKEN",
+    label: "KakaoTalk",
+    verifyURL: "",
+  },
+};
+const PROVIDER_ENV_ORDER = Object.keys(PROVIDER_ENV_CONFIG);
 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";
@@ -58,8 +78,8 @@ function printUsage() {
       `  ${ALLOW_HOME_WORKSPACE_ENV_KEY}=1 to allow using home directory as workspace root (disabled by default).`,
       "  If env is missing, stored token file is used:",
       `    ${AUTH_STORE_RELATIVE_PATH}`,
-      "  Local Telegram bot token template is stored at:",
-      `    ${TELEGRAM_ENV_RELATIVE_PATH}`,
+      "  Local provider bot token templates are stored under:",
+      ...PROVIDER_ENV_ORDER.map((provider) => `    ${PROVIDER_ENV_CONFIG[provider].relativePath}`),
       "",
     ].join("\n"),
   );
@@ -479,36 +499,57 @@ function authStoreFilePath() {
   return resolveHomeFilePath(AUTH_STORE_RELATIVE_PATH);
 }
 
-function telegramEnvFilePath() {
-  return resolveHomeFilePath(TELEGRAM_ENV_RELATIVE_PATH);
+function normalizeBotProvider(rawValue) {
+  const value = String(rawValue || "").trim().toLowerCase();
+  if (Object.prototype.hasOwnProperty.call(PROVIDER_ENV_CONFIG, value)) {
+    return value;
+  }
+  return "telegram";
 }
 
-function telegramEnvTemplate() {
+function providerEnvConfig(provider) {
+  return PROVIDER_ENV_CONFIG[normalizeBotProvider(provider)];
+}
+
+function providerEnvFilePath(provider) {
+  return resolveHomeFilePath(providerEnvConfig(provider).relativePath);
+}
+
+function providerEnvTemplate(provider) {
+  const config = providerEnvConfig(provider);
   return [
-    "# Metheus local Telegram bot settings",
+    `# Metheus local ${config.label} bot settings`,
     "# Keep this file on your machine only. Do not commit it.",
-    "# Store only the Telegram bot token locally.",
-    "# Project chat_id must be managed on the Metheus server as a project Telegram destination.",
+    `# Store only the ${config.label} bot token locally.`,
+    "# Project chat destinations must be managed on the Metheus server.",
     "",
-    "TELEGRAM_BOT_TOKEN=",
+    `${config.tokenKey}=`,
     "",
   ].join("\n");
 }
 
-function ensureTelegramEnvTemplate() {
-  const filePath = telegramEnvFilePath();
+function ensureProviderEnvTemplate(provider) {
+  const filePath = providerEnvFilePath(provider);
   try {
     if (fs.existsSync(filePath)) {
       return { filePath, created: false, existed: true };
     }
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, telegramEnvTemplate(), "utf8");
+    fs.writeFileSync(filePath, providerEnvTemplate(provider), "utf8");
     return { filePath, created: true, existed: false };
   } catch (err) {
     return { filePath, created: false, existed: false, error: String(err?.message || err) };
   }
 }
 
+function ensureAllProviderEnvTemplates() {
+  const out = {};
+  for (const provider of PROVIDER_ENV_ORDER) {
+    out[provider] = ensureProviderEnvTemplate(provider);
+  }
+  return out;
+}
+
 function parseSimpleEnvText(rawText) {
   const out = {};
   const lines = String(rawText || "").split(/\r?\n/);
@@ -531,12 +572,16 @@ function parseSimpleEnvText(rawText) {
   return out;
 }
 
-function loadTelegramEnvConfig() {
-  const ensured = ensureTelegramEnvTemplate();
+function loadProviderEnvConfig(provider) {
+  const normalizedProvider = normalizeBotProvider(provider);
+  const config = providerEnvConfig(normalizedProvider);
+  const ensured = ensureProviderEnvTemplate(normalizedProvider);
   const filePath = ensured.filePath;
   if (ensured.error) {
     return {
       ok: false,
+      provider: normalizedProvider,
+      providerLabel: config.label,
       filePath,
       error: ensured.error,
       token: "",
@@ -545,23 +590,29 @@ function loadTelegramEnvConfig() {
   try {
     const raw = fs.readFileSync(filePath, "utf8");
     const parsed = parseSimpleEnvText(raw);
-    const token = String(parsed.TELEGRAM_BOT_TOKEN || "").trim();
+    const token = String(parsed[config.tokenKey] || "").trim();
     if (!token) {
       return {
         ok: false,
+        provider: normalizedProvider,
+        providerLabel: config.label,
         filePath,
-        error: `TELEGRAM_BOT_TOKEN is missing in ${filePath}`,
+        error: `${config.tokenKey} is missing in ${filePath}`,
         token: "",
       };
     }
     return {
       ok: true,
+      provider: normalizedProvider,
+      providerLabel: config.label,
       filePath,
       token,
     };
   } catch (err) {
     return {
       ok: false,
+      provider: normalizedProvider,
+      providerLabel: config.label,
       filePath,
       error: String(err?.message || err),
       token: "",
@@ -569,6 +620,132 @@ function loadTelegramEnvConfig() {
   }
 }
 
+function telegramEnvFilePath() {
+  return providerEnvFilePath("telegram");
+}
+
+function telegramEnvTemplate() {
+  return providerEnvTemplate("telegram");
+}
+
+function ensureTelegramEnvTemplate() {
+  return ensureProviderEnvTemplate("telegram");
+}
+
+function loadTelegramEnvConfig() {
+  return loadProviderEnvConfig("telegram");
+}
+
+async function verifyLocalProviderToken(provider, envConfig, timeoutSeconds) {
+  const normalizedProvider = normalizeBotProvider(provider);
+  if (!envConfig?.ok) {
+    return {
+      ok: false,
+      detail: envConfig?.error || "local provider env is not ready",
+    };
+  }
+  if (normalizedProvider === "telegram") {
+    const me = safeObject(
+      await getJSONWithoutAuth(`https://api.telegram.org/bot${envConfig.token}/getMe`, timeoutSeconds),
+    );
+    if (Boolean(me.ok) && safeObject(me.result).id) {
+      return {
+        ok: true,
+        detail: `reachable as @${String(safeObject(me.result).username || "").trim() || "-"}`,
+      };
+    }
+    return {
+      ok: false,
+      detail: "getMe returned an unexpected payload",
+    };
+  }
+  if (normalizedProvider === "slack") {
+    const response = await postJSONWithoutAuth(
+      "https://slack.com/api/auth.test",
+      timeoutSeconds,
+      {},
+      {
+        authorization: `Bearer ${envConfig.token}`,
+      },
+    );
+    const responseJSON = parseJSONText(response.bodyText);
+    if (response.statusCode >= 200 && response.statusCode < 300 && responseJSON?.ok) {
+      const team = String(responseJSON.team || "").trim() || "-";
+      const user = String(responseJSON.user || "").trim() || "-";
+      return {
+        ok: true,
+        detail: `reachable as ${user} on ${team}`,
+      };
+    }
+    return {
+      ok: false,
+      detail: String(responseJSON?.error || response.bodyText || "auth.test failed").trim(),
+    };
+  }
+  return {
+    ok: false,
+    detail: `${providerEnvConfig(normalizedProvider).label} local verification is not implemented yet`,
+  };
+}
+
+async function deliverLocalProviderMessage({
+  provider,
+  token,
+  destination,
+  text,
+  disableWebPagePreview,
+  replyToMessageID,
+  timeoutSeconds,
+}) {
+  const normalizedProvider = normalizeBotProvider(provider);
+  if (normalizedProvider === "telegram") {
+    const requestURL = `https://api.telegram.org/bot${token}/sendMessage`;
+    const payload = {
+      chat_id: destination.chatID,
+      text,
+      disable_web_page_preview: disableWebPagePreview,
+    };
+    if (replyToMessageID > 0) {
+      payload.reply_to_message_id = replyToMessageID;
+    }
+    const response = await postJSONWithoutAuth(requestURL, timeoutSeconds, payload);
+    const responseJSON = parseJSONText(response.bodyText);
+    return {
+      statusCode: response.statusCode,
+      body: responseJSON || response.bodyText,
+      ok: response.statusCode >= 200 && response.statusCode < 300 && Boolean(responseJSON?.ok ?? true),
+      url: sanitizeTelegramAPIURL(requestURL),
+      replySupported: true,
+    };
+  }
+  if (normalizedProvider === "slack") {
+    const requestURL = "https://slack.com/api/chat.postMessage";
+    const payload = {
+      channel: destination.chatID,
+      text,
+      unfurl_links: disableWebPagePreview === false,
+      unfurl_media: disableWebPagePreview === false,
+    };
+    const response = await postJSONWithoutAuth(
+      requestURL,
+      timeoutSeconds,
+      payload,
+      {
+        authorization: `Bearer ${token}`,
+      },
+    );
+    const responseJSON = parseJSONText(response.bodyText);
+    return {
+      statusCode: response.statusCode,
+      body: responseJSON || response.bodyText,
+      ok: response.statusCode >= 200 && response.statusCode < 300 && Boolean(responseJSON?.ok ?? false),
+      url: requestURL,
+      replySupported: false,
+    };
+  }
+  throw new Error(`${providerEnvConfig(normalizedProvider).label} local delivery is not implemented yet`);
+}
+
 function resolveWorkspaceDir(rawPath) {
   const input = String(rawPath || "").trim();
   if (input) {
@@ -2199,28 +2376,14 @@ async function runDoctor(flags) {
     includeDrafts: true,
   });
   const rows = [];
-
-  const telegramEnv = loadTelegramEnvConfig();
-  if (!telegramEnv.ok) {
-    addDoctorCheck(rows, "warn", "local telegram env", `${telegramEnv.error} (${telegramEnv.filePath})`);
-  } else {
-    addDoctorCheck(rows, "ok", "local telegram env", `token configured (${telegramEnv.filePath})`);
-    try {
-      const me = safeObject(
-        await getJSONWithoutAuth(`https://api.telegram.org/bot${telegramEnv.token}/getMe`, timeoutSeconds),
-      );
-      if (Boolean(me.ok) && safeObject(me.result).id) {
-        addDoctorCheck(
-          rows,
-          "ok",
-          "local telegram bot",
-          `reachable as @${String(safeObject(me.result).username || "").trim() || "-"}`,
-        );
-      } else {
-        addDoctorCheck(rows, "warn", "local telegram bot", "getMe returned an unexpected payload");
-      }
-    } catch (err) {
-      addDoctorCheck(rows, "warn", "local telegram bot", String(err?.message || err));
+  const providerTemplates = ensureAllProviderEnvTemplates();
+  for (const provider of PROVIDER_ENV_ORDER) {
+    const ensured = providerTemplates[provider];
+    const label = providerEnvConfig(provider).label;
+    if (ensured.error) {
+      addDoctorCheck(rows, "warn", `local ${provider} env`, `${ensured.error} (${ensured.filePath})`);
+    } else {
+      addDoctorCheck(rows, "ok", `local ${provider} env`, `template ready (${ensured.filePath})`);
     }
   }
 
@@ -2240,6 +2403,42 @@ async function runDoctor(flags) {
       "auth token",
       `configured (${resolved.source || "unknown"}${tokenExpiryIso(token) ? `, expires ${tokenExpiryIso(token)}` : ""})`,
     );
+
+    if (context.projectID && isUUID(context.projectID)) {
+      try {
+        const destinationURL = `${normalizeSiteBaseURL(context.baseURL)}/api/v1/projects/${encodeURIComponent(context.projectID)}/chat-destinations`;
+        const destinations = ensureArray(await getJSONWithAuth(destinationURL, timeoutSeconds, token))
+          .map(normalizeChatDestination)
+          .filter((item) => item.isActive && item.chatID);
+        const activeProviders = Array.from(new Set(destinations.map((item) => normalizeBotProvider(item.provider))));
+        if (activeProviders.length === 0) {
+          addDoctorCheck(rows, "warn", "project chat destinations", "no active project chat destinations configured");
+        } else {
+          addDoctorCheck(rows, "ok", "project chat destinations", activeProviders.join(", "));
+        }
+        for (const provider of activeProviders) {
+          const envConfig = loadProviderEnvConfig(provider);
+          if (!envConfig.ok) {
+            addDoctorCheck(rows, "warn", `local ${provider} token`, `${envConfig.error} (${envConfig.filePath})`);
+            continue;
+          }
+          addDoctorCheck(rows, "ok", `local ${provider} token`, `configured (${envConfig.filePath})`);
+          try {
+            const verification = await verifyLocalProviderToken(provider, envConfig, timeoutSeconds);
+            addDoctorCheck(
+              rows,
+              verification.ok ? "ok" : "warn",
+              `local ${provider} bot`,
+              verification.detail,
+            );
+          } catch (err) {
+            addDoctorCheck(rows, "warn", `local ${provider} bot`, String(err?.message || err));
+          }
+        }
+      } catch (err) {
+        addDoctorCheck(rows, "warn", "project chat destinations", String(err?.message || err));
+      }
+    }
   }
 
   for (const cliBin of MCP_CLIENTS) {
@@ -4086,24 +4285,26 @@ function normalizeChatDestination(record) {
   };
 }
 
-function selectProjectChatDestination(destinations, selectors = {}) {
+function selectProjectChatDestination(destinations, selectors = {}, provider = "telegram") {
+  const normalizedProvider = normalizeBotProvider(provider);
+  const providerLabel = providerEnvConfig(normalizedProvider).label;
   const list = ensureArray(destinations)
     .map(normalizeChatDestination)
-    .filter((item) => item.provider === "telegram" && item.chatID && item.isActive);
+    .filter((item) => item.provider === normalizedProvider && item.chatID && item.isActive);
   const destinationID = String(selectors.destinationID || "").trim();
   const destinationLabel = String(selectors.destinationLabel || "").trim().toLowerCase();
 
   if (destinationID) {
     const match = list.find((item) => item.id === destinationID);
     if (!match) {
-      throw new Error(`project chat destination ${destinationID} was not found or is inactive`);
+      throw new Error(`${providerLabel} project chat destination ${destinationID} was not found or is inactive`);
     }
     return match;
   }
   if (destinationLabel) {
     const match = list.find((item) => item.label.toLowerCase() === destinationLabel);
     if (!match) {
-      throw new Error(`project chat destination label "${selectors.destinationLabel}" was not found or is inactive`);
+      throw new Error(`${providerLabel} project chat destination label "${selectors.destinationLabel}" was not found or is inactive`);
     }
     return match;
   }
@@ -4111,11 +4312,11 @@ function selectProjectChatDestination(destinations, selectors = {}) {
     return list[0];
   }
   if (list.length === 0) {
-    throw new Error("no active Telegram chat destination is configured for this project");
+    throw new Error(`no active ${providerLabel} chat destination is configured for this project`);
   }
   const labels = list.map((item) => item.label || item.id).filter(Boolean);
   throw new Error(
-    `multiple active Telegram chat destinations exist for this project; pass destination_id or destination_label (${labels.join(", ")})`,
+    `multiple active ${providerLabel} chat destinations exist for this project; pass destination_id or destination_label (${labels.join(", ")})`,
   );
 }
 
@@ -4148,11 +4349,6 @@ async function handleLocalBotMessageToolCall({
     throw new Error("project_id is required for local bot delivery; set --project-id during setup or include project_id");
   }
 
-  const telegramEnv = loadTelegramEnvConfig();
-  if (!telegramEnv.ok) {
-    throw new Error(`local telegram env is not ready (${telegramEnv.error})`);
-  }
-
   const siteBaseURL = normalizeSiteBaseURL(args.baseURL);
   const encodedBotID = encodeURIComponent(botID);
   const encodedProjectID = encodeURIComponent(projectID);
@@ -4166,12 +4362,13 @@ async function handleLocalBotMessageToolCall({
   if (bot.is_active === false || bot.isActive === false) {
     throw new Error("bot is inactive");
   }
+  const provider = normalizeBotProvider(bot.provider);
 
   const destinations = ensureArray(await getJSONWithAuth(destinationURL, args.timeoutSeconds, token));
   const destination = selectProjectChatDestination(destinations, {
     destinationID,
     destinationLabel,
-  });
+  }, provider);
 
   const disableWebPagePreview = boolFromRaw(
     Object.prototype.hasOwnProperty.call(toolArgs, "disable_web_page_preview")
@@ -4188,28 +4385,31 @@ async function handleLocalBotMessageToolCall({
     throw new Error("reply_to_message_id must be a positive integer");
   }
 
-  const telegramURL = `https://api.telegram.org/bot${telegramEnv.token}/sendMessage`;
-  const telegramPayload = {
-    chat_id: destination.chatID,
-    text,
-    disable_web_page_preview: disableWebPagePreview,
-  };
-  if (replyToMessageID > 0) {
-    telegramPayload.reply_to_message_id = replyToMessageID;
+  const providerEnv = loadProviderEnvConfig(provider);
+  if (!providerEnv.ok) {
+    throw new Error(`local ${provider} env is not ready (${providerEnv.error})`);
   }
 
-  const response = await postJSONWithoutAuth(telegramURL, args.timeoutSeconds, telegramPayload);
-  const responseJSON = parseJSONText(response.bodyText);
-  const deliveryOK = response.statusCode >= 200 && response.statusCode < 300 && Boolean(responseJSON?.ok ?? true);
-  if (!deliveryOK) {
+  const delivery = await deliverLocalProviderMessage({
+    provider,
+    token: providerEnv.token,
+    destination,
+    text,
+    disableWebPagePreview,
+    replyToMessageID,
+    timeoutSeconds: args.timeoutSeconds,
+  });
+  if (!delivery.ok) {
+    const responseJSON = safeObject(delivery.body);
     const errorDetail =
-      String(responseJSON?.description || response.bodyText || "").trim() || `telegram api status ${response.statusCode}`;
-    if (response.statusCode === 401 || /unauthorized/i.test(errorDetail)) {
+      String(responseJSON.description || responseJSON.error || JSON.stringify(delivery.body || "")).trim()
+      || `${provider} api status ${delivery.statusCode}`;
+    if (delivery.statusCode === 401 || /unauthorized|invalid_auth/i.test(errorDetail)) {
       throw new Error(
-        `local telegram delivery failed (Unauthorized). Check TELEGRAM_BOT_TOKEN in ${telegramEnv.filePath}`,
+        `local ${provider} delivery failed (Unauthorized). Check ${providerEnvConfig(provider).tokenKey} in ${providerEnv.filePath}`,
       );
     }
-    throw new Error(`local telegram delivery failed (${errorDetail})`);
+    throw new Error(`local ${provider} delivery failed (${errorDetail})`);
   }
 
   return jsonRpcResult(
@@ -4217,7 +4417,7 @@ async function handleLocalBotMessageToolCall({
     buildLocalToolRPCResult("me.send-bot-message", {
       ok: true,
       local_delivery: true,
-      provider: "telegram",
+      provider,
       bot_id: String(bot.id || botID).trim(),
       bot_name: String(bot.name || "").trim(),
       bot_role: String(bot.bot_role || bot.botRole || "").trim(),
@@ -4225,9 +4425,10 @@ async function handleLocalBotMessageToolCall({
       destination_id: destination.id,
       destination_label: destination.label,
       chat_id: destination.chatID,
-      status: response.statusCode,
-      url: sanitizeTelegramAPIURL(telegramURL),
-      body: responseJSON || response.bodyText,
+      status: delivery.statusCode,
+      url: delivery.url,
+      body: delivery.body,
+      reply_supported: delivery.replySupported,
     }),
   );
 }
@@ -5704,7 +5905,7 @@ function runSetupInternal(flags, options = {}) {
   const context = resolveSetupContext(flags);
   const clients = [...MCP_CLIENTS];
   const results = [];
-  const telegramEnv = ensureTelegramEnvTemplate();
+  const providerTemplates = ensureAllProviderEnvTemplates();
 
   for (const cliBin of clients) {
     if (!commandExists(cliBin)) continue;
@@ -5754,12 +5955,16 @@ function runSetupInternal(flags, options = {}) {
     process.stdout.write(`Fallback:  ${context.workspaceFallbackDir} (METHEUS_WORKSPACE_DIR)\n`);
   }
   process.stdout.write(`Project:   ${context.projectID || "auto-detect from .metheus_ctxpack_sync.json"}\n`);
-  if (telegramEnv.error) {
-    process.stdout.write(`Telegram:  template unavailable (${telegramEnv.error})\n`);
-  } else {
-    process.stdout.write(
-      `Telegram:  ${telegramEnv.created ? "template created" : "template ready"} (${telegramEnv.filePath})\n`,
-    );
+  for (const provider of PROVIDER_ENV_ORDER) {
+    const ensured = providerTemplates[provider];
+    const label = providerEnvConfig(provider).label;
+    if (ensured.error) {
+      process.stdout.write(`${label}:  template unavailable (${ensured.error})\n`);
+    } else {
+      process.stdout.write(
+        `${label}:  ${ensured.created ? "template created" : "template ready"} (${ensured.filePath})\n`,
+      );
+    }
   }
   if (context.ctxpackKey) {
     process.stdout.write(`Ctxpack:   ${context.ctxpackKey}\n`);
@@ -5782,12 +5987,17 @@ function runSelftest(flags = {}) {
   const checks = [];
   const push = (name, ok, detail = "") => checks.push({ name, ok: Boolean(ok), detail: String(detail || "") });
 
-  const parsedEnv = parseSimpleEnvText("\n# comment\nTELEGRAM_BOT_TOKEN=\"abc:123\"\nEMPTY=\n");
+  const parsedEnv = parseSimpleEnvText("\n# comment\nTELEGRAM_BOT_TOKEN=\"abc:123\"\nSLACK_BOT_TOKEN=xoxb-test\nEMPTY=\n");
   push(
     "telegram_env_parse_token",
     String(parsedEnv.TELEGRAM_BOT_TOKEN || "") === "abc:123",
     `token=${String(parsedEnv.TELEGRAM_BOT_TOKEN || "(missing)")}`,
   );
+  push(
+    "slack_env_parse_token",
+    String(parsedEnv.SLACK_BOT_TOKEN || "") === "xoxb-test",
+    `token=${String(parsedEnv.SLACK_BOT_TOKEN || "(missing)")}`,
+  );
 
   try {
     const selected = selectProjectChatDestination(
@@ -5796,6 +6006,7 @@ function runSelftest(flags = {}) {
         { id: "dest-2", provider: "slack", label: "Slack", chat_id: "C123", is_active: true },
       ],
       {},
+      "telegram",
     );
     push(
       "telegram_destination_select_single_active",
@@ -5813,6 +6024,7 @@ function runSelftest(flags = {}) {
         { id: "dest-2", provider: "telegram", label: "Room B", chat_id: "-1002", is_active: true },
       ],
       {},
+      "telegram",
     );
     push("telegram_destination_multi_requires_selector", false, "selection unexpectedly succeeded");
   } catch (err) {

package/package.json

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

package/postinstall.mjs

@@ -4,38 +4,44 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
-const RELATIVE_PATH = path.join(".metheus", "telegram.env");
+const PROVIDERS = [
+  ["telegram", "TELEGRAM_BOT_TOKEN", "Telegram"],
+  ["slack", "SLACK_BOT_TOKEN", "Slack"],
+  ["kakaotalk", "KAKAOTALK_BOT_TOKEN", "KakaoTalk"],
+];
 
-function resolveTargetPath() {
+function resolveTargetPath(provider) {
   const home = String(process.env.USERPROFILE || process.env.HOME || os.homedir() || "").trim();
   if (!home) return "";
-  return path.join(home, RELATIVE_PATH);
+  return path.join(home, ".metheus", `${provider}.env`);
 }
 
-function template() {
+function template(label, tokenKey) {
   return [
-    "# Metheus local Telegram bot settings",
+    `# Metheus local ${label} bot settings`,
     "# Keep this file on your machine only. Do not commit it.",
-    "# Store only the Telegram bot token locally.",
-    "# Project chat_id must be managed on the Metheus server as a project Telegram destination.",
+    `# Store only the ${label} bot token locally.`,
+    "# Project chat destinations must be managed on the Metheus server.",
     "",
-    "TELEGRAM_BOT_TOKEN=",
+    `${tokenKey}=`,
     "",
   ].join("\n");
 }
 
 function main() {
-  const filePath = resolveTargetPath();
-  if (!filePath) return;
-  try {
-    if (fs.existsSync(filePath)) return;
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, template(), "utf8");
-    process.stdout.write(`[metheus-governance-mcp-cli] created ${filePath}\n`);
-  } catch (err) {
-    process.stderr.write(
-      `[metheus-governance-mcp-cli] could not create ${filePath}: ${String(err?.message || err)}\n`,
-    );
+  for (const [provider, tokenKey, label] of PROVIDERS) {
+    const filePath = resolveTargetPath(provider);
+    if (!filePath) continue;
+    try {
+      if (fs.existsSync(filePath)) continue;
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      fs.writeFileSync(filePath, template(label, tokenKey), "utf8");
+      process.stdout.write(`[metheus-governance-mcp-cli] created ${filePath}\n`);
+    } catch (err) {
+      process.stderr.write(
+        `[metheus-governance-mcp-cli] could not create ${filePath}: ${String(err?.message || err)}\n`,
+      );
+    }
   }
 }