metheus-governance-mcp-cli 0.2.55 → 0.2.58

package/cli.mjs

@@ -897,6 +897,80 @@ function parseArchivedChatComment(rawBody) {
   };
 }
 
+function joinTextParts(parts, separator = " ") {
+  return ensureArray(parts)
+    .map((value) => String(value || "").trim())
+    .filter(Boolean)
+    .join(separator);
+}
+
+function toISOStringFromUnix(rawValue) {
+  const numeric = Number(rawValue || 0);
+  if (!Number.isFinite(numeric) || numeric <= 0) {
+    return new Date().toISOString();
+  }
+  return new Date(numeric * 1000).toISOString();
+}
+
+function collectTelegramUpdateText(message) {
+  return firstNonEmptyString([message?.text, message?.caption]);
+}
+
+function normalizeLocalTelegramUpdate(rawUpdate) {
+  const update = safeObject(rawUpdate);
+  const message = safeObject(update.message || update.edited_message);
+  if (!message || Object.keys(message).length === 0) {
+    return null;
+  }
+  const chat = safeObject(message.chat);
+  const from = safeObject(message.from);
+  const replyTo = safeObject(message.reply_to_message);
+  const text = collectTelegramUpdateText(message);
+  if (!text) {
+    return null;
+  }
+  return {
+    eventName: update.edited_message ? "telegram.message.updated" : "telegram.message.created",
+    updateID: intFromRawAllowZero(update.update_id, 0),
+    messageID: intFromRawAllowZero(message.message_id, 0),
+    chatID: String(chat.id || "").trim(),
+    chatType: String(chat.type || "").trim(),
+    chatTitle: firstNonEmptyString([chat.title, chat.username, joinTextParts([chat.first_name, chat.last_name]), chat.id]),
+    fromID: String(from.id || "").trim(),
+    fromName: firstNonEmptyString([joinTextParts([from.first_name, from.last_name]), from.username, from.id]),
+    fromUsername: String(from.username || "").trim(),
+    fromIsBot: Boolean(from.is_bot),
+    text,
+    occurredAt: toISOStringFromUnix(message.edit_date || message.date),
+    messageThreadID: String(message.message_thread_id || "").trim(),
+    replyToMessageID: intFromRawAllowZero(replyTo.message_id, 0),
+  };
+}
+
+function buildArchivedInboundMessageKey(chatID, messageID) {
+  return `${String(chatID || "").trim()}:${intFromRawAllowZero(messageID, 0)}`;
+}
+
+function formatTelegramInboundArchiveComment(normalized) {
+  const headerLines = [
+    `[Telegram ${normalized.eventName === "telegram.message.updated" ? "edited" : "message"}]`,
+    `chat_id: ${normalized.chatID || "<missing>"}`,
+    `message_id: ${normalized.messageID || "<missing>"}`,
+    `occurred_at: ${normalized.occurredAt || new Date().toISOString()}`,
+    `sender: ${normalized.fromName || normalized.fromUsername || normalized.fromID || "unknown"}`,
+  ];
+  if (normalized.fromUsername) {
+    headerLines.push(`telegram_username: @${normalized.fromUsername.replace(/^@+/, "")}`);
+  }
+  if (normalized.messageThreadID) {
+    headerLines.push(`telegram_topic_id: ${normalized.messageThreadID}`);
+  }
+  if (normalized.replyToMessageID > 0) {
+    headerLines.push(`reply_to_message_id: ${normalized.replyToMessageID}`);
+  }
+  return `${headerLines.join("\n")}\n\n${String(normalized.text || "").trim()}`;
+}
+
 function formatBotReplyArchiveComment({
   provider,
   bot,
@@ -1026,6 +1100,65 @@ async function createThreadComment({
   return safeObject(parseJSONText(responseText));
 }
 
+async function getTelegramAPIJSON(token, methodName, timeoutSeconds, query = {}) {
+  const requestURL = new URL(`https://api.telegram.org/bot${token}/${methodName}`);
+  Object.entries(safeObject(query)).forEach(([key, value]) => {
+    if (value == null || value === "") return;
+    requestURL.searchParams.set(key, String(value));
+  });
+  const parsed = safeObject(await getJSONWithoutAuth(requestURL.toString(), timeoutSeconds));
+  if (parsed.ok === false) {
+    throw new Error(String(parsed.description || `${methodName} failed`).trim());
+  }
+  return parsed;
+}
+
+async function postTelegramAPIJSON(token, methodName, timeoutSeconds, payload = {}) {
+  const requestURL = `https://api.telegram.org/bot${token}/${methodName}`;
+  const response = await postJSONWithoutAuth(requestURL, timeoutSeconds, payload);
+  const parsed = safeObject(parseJSONText(response.bodyText));
+  if (!(response.statusCode >= 200 && response.statusCode < 300) || parsed.ok === false) {
+    const error = new Error(String(parsed.description || response.bodyText || `${methodName} failed`).trim() || `${methodName} failed`);
+    error.statusCode = response.statusCode;
+    error.responseBody = response.bodyText;
+    throw error;
+  }
+  return parsed;
+}
+
+async function getTelegramWebhookInfo(token, timeoutSeconds) {
+  return safeObject(await getTelegramAPIJSON(token, "getWebhookInfo", timeoutSeconds));
+}
+
+async function deleteTelegramWebhook(token, timeoutSeconds) {
+  return safeObject(await postTelegramAPIJSON(token, "deleteWebhook", timeoutSeconds, {
+    drop_pending_updates: false,
+  }));
+}
+
+async function getTelegramUpdates(token, timeoutSeconds, offset = 0) {
+  try {
+    return safeObject(await getTelegramAPIJSON(token, "getUpdates", timeoutSeconds, {
+      timeout: 0,
+      offset: offset > 0 ? offset : "",
+      allowed_updates: JSON.stringify(["message", "edited_message"]),
+    }));
+  } catch (err) {
+    const statusCode = Number(err?.statusCode || 0);
+    const errorText = String(err?.responseBody || err?.message || "").toLowerCase();
+    const webhookConflict = statusCode === 409 || errorText.includes("webhook") || errorText.includes("getupdates");
+    if (!webhookConflict) {
+      throw err;
+    }
+    await deleteTelegramWebhook(token, timeoutSeconds);
+    return safeObject(await getTelegramAPIJSON(token, "getUpdates", timeoutSeconds, {
+      timeout: 0,
+      offset: offset > 0 ? offset : "",
+      allowed_updates: JSON.stringify(["message", "edited_message"]),
+    }));
+  }
+}
+
 function looksLikeArchiveWorkItemTitle(title, provider) {
   const text = String(title || "").trim().toLowerCase();
   if (!text) return false;
@@ -1118,6 +1251,101 @@ async function discoverArchiveThreadForDestination({
   );
 }
 
+async function archiveLocalTelegramMessagesForRoute({
+  routeKey,
+  routeState,
+  runtime,
+  destination,
+  archiveThread,
+}) {
+  const envConfig = loadProviderEnvConfig("telegram");
+  if (!envConfig.ok) {
+    throw new Error(envConfig.error || "TELEGRAM_BOT_TOKEN is not configured");
+  }
+
+  const state = safeObject(routeState);
+  let webhookClearedURL = "";
+  if (!boolFromRaw(state.local_telegram_polling_ready, false)) {
+    const webhookInfo = safeObject(await getTelegramWebhookInfo(envConfig.token, runtime.timeoutSeconds).catch(() => ({})));
+    const currentWebhookURL = String(safeObject(webhookInfo.result).url || "").trim();
+    if (currentWebhookURL) {
+      await deleteTelegramWebhook(envConfig.token, runtime.timeoutSeconds);
+      webhookClearedURL = currentWebhookURL;
+    }
+    saveRunnerRouteState(routeKey, {
+      local_receive_mode: "telegram_get_updates",
+      local_telegram_polling_ready: true,
+      local_telegram_webhook_cleared_url: webhookClearedURL,
+      local_telegram_webhook_cleared_at: webhookClearedURL ? new Date().toISOString() : state.local_telegram_webhook_cleared_at,
+    });
+  }
+
+  const lastUpdateID = intFromRawAllowZero(state.last_provider_update_id ?? state.last_telegram_update_id, 0);
+  const updatesEnvelope = await getTelegramUpdates(envConfig.token, runtime.timeoutSeconds, lastUpdateID > 0 ? lastUpdateID + 1 : 0);
+  const updates = ensureArray(updatesEnvelope.result)
+    .map(normalizeLocalTelegramUpdate)
+    .filter(Boolean);
+  const highestUpdateID = updates.reduce((max, item) => Math.max(max, intFromRawAllowZero(item.updateID, 0)), lastUpdateID);
+
+  saveRunnerRouteState(routeKey, {
+    local_receive_mode: "telegram_get_updates",
+    local_telegram_polling_ready: true,
+    last_provider_update_id: highestUpdateID,
+    last_local_poll_at: new Date().toISOString(),
+  });
+
+  if (!updates.length) {
+    return {
+      importedCommentIDs: [],
+      importedCount: 0,
+      lastUpdateID: highestUpdateID,
+    };
+  }
+
+  const existingComments = await listThreadComments({
+    siteBaseURL: runtime.baseURL,
+    threadID: archiveThread.threadID,
+    token: runtime.token,
+    timeoutSeconds: runtime.timeoutSeconds,
+    limit: 200,
+    actorUserID: runtime.actor.user_id,
+  });
+  const existingKeys = new Set(
+    existingComments
+      .map(normalizeArchiveCommentRecord)
+      .map((record) => record.parsedArchive)
+      .filter((parsed) => parsed && isInboundArchiveKind(parsed.kind) && parsed.chatID)
+      .map((parsed) => buildArchivedInboundMessageKey(parsed.chatID, parsed.messageID)),
+  );
+
+  const importedCommentIDs = [];
+  for (const update of updates) {
+    if (String(update.chatID || "").trim() !== String(destination.chatID || "").trim()) continue;
+    if (update.fromIsBot) continue;
+    if (!String(update.text || "").trim()) continue;
+    const dedupeKey = buildArchivedInboundMessageKey(update.chatID, update.messageID);
+    if (existingKeys.has(dedupeKey)) continue;
+    const createdComment = await createThreadComment({
+      siteBaseURL: runtime.baseURL,
+      token: runtime.token,
+      timeoutSeconds: runtime.timeoutSeconds,
+      threadID: archiveThread.threadID,
+      actorUserID: runtime.actor.user_id,
+      body: formatTelegramInboundArchiveComment(update),
+    });
+    if (String(createdComment.id || "").trim()) {
+      importedCommentIDs.push(String(createdComment.id || "").trim());
+    }
+    existingKeys.add(dedupeKey);
+  }
+
+  return {
+    importedCommentIDs,
+    importedCount: importedCommentIDs.length,
+    lastUpdateID: highestUpdateID,
+  };
+}
+
 function buildRunnerShellInvocation(command) {
   const text = String(command || "").trim();
   if (!text) {
@@ -1244,9 +1472,11 @@ function buildRunnerRouteStateFromComment(record, patch = {}) {
 
 function saveRunnerRouteState(routeKey, routeState) {
   const current = loadBotRunnerState();
+  const previous = safeObject(current.routes[routeKey]);
   const nextRoutes = {
     ...safeObject(current.routes),
     [routeKey]: {
+      ...previous,
       ...safeObject(routeState),
       updated_at: new Date().toISOString(),
     },
@@ -1462,6 +1692,20 @@ async function processRunnerRouteOnce(route, runtime, mode) {
     archiveThreadID: normalizedRoute.archiveThreadID,
     archiveWorkItemID: normalizedRoute.archiveWorkItemID,
   });
+  const importOutcome = await archiveLocalTelegramMessagesForRoute({
+    routeKey,
+    routeState: currentState,
+    runtime,
+    destination,
+    archiveThread,
+  });
+  saveRunnerRouteState(routeKey, {
+    local_receive_mode: "telegram_get_updates",
+    local_telegram_polling_ready: true,
+    last_provider_update_id: intFromRawAllowZero(importOutcome.lastUpdateID, 0),
+    last_local_poll_at: new Date().toISOString(),
+  });
+  const refreshedState = safeObject(loadBotRunnerState().routes[routeKey]);
   const comments = await listThreadComments({
     siteBaseURL: runtime.baseURL,
     threadID: archiveThread.threadID,
@@ -1470,7 +1714,22 @@ async function processRunnerRouteOnce(route, runtime, mode) {
     actorUserID: runtime.actor.user_id,
     limit: Math.max(50, normalizedRoute.contextComments * 6),
   });
-  const pending = selectPendingArchiveComments(comments, currentState, mode);
+  const orderedComments = ensureArray(comments)
+    .map(normalizeArchiveCommentRecord)
+    .filter((record) => record.id && record.parsedArchive)
+    .sort(compareArchiveCommentRecords);
+  const inboundComments = orderedComments.filter((record) => isInboundArchiveKind(record.parsedArchive.kind));
+  const importedRecords = ensureArray(importOutcome.importedCommentIDs)
+    .map((commentID) => orderedComments.find((record) => record.id === commentID))
+    .filter(Boolean);
+  const pending = importedRecords.length > 0
+    ? {
+        ordered: orderedComments,
+        latest: inboundComments.length ? inboundComments[inboundComments.length - 1] : null,
+        shouldPrime: false,
+        pending: importedRecords,
+      }
+    : selectPendingArchiveComments(comments, refreshedState, mode);
   if (pending.shouldPrime && pending.latest) {
     saveRunnerRouteState(routeKey, buildRunnerRouteStateFromComment(pending.latest, { primed: true }));
     return {
@@ -1487,7 +1746,9 @@ async function processRunnerRouteOnce(route, runtime, mode) {
       route_key: routeKey,
       route_name: normalizedRoute.name,
       outcome: "idle",
-      detail: "no new archived inbound messages",
+      detail: importOutcome.importedCount > 0
+        ? "local telegram updates imported but no pending archive comments were selected"
+        : "no new local telegram messages or archived inbound messages",
       thread_id: archiveThread.threadID,
     };
   }
@@ -1596,7 +1857,6 @@ async function runRunnerOnce(flags) {
 }
 
 async function runRunnerStart(flags) {
-  const runtime = await resolveRunnerContext(flags);
   const jsonMode = boolFromRaw(flags.json, false);
   const routes = resolveRunnerRoutes(flags, "start");
   const schedules = new Map();
@@ -1621,6 +1881,7 @@ async function runRunnerStart(flags) {
           continue;
         }
         try {
+          const runtime = await resolveRunnerContext(flags);
           const result = await processRunnerRouteOnce(normalizedRoute, runtime, "start");
           printRunnerResult("start", result, jsonMode);
         } catch (err) {

package/package.json

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

package/scripts/local-bot-ai-bridge.mjs

@@ -56,6 +56,50 @@ function resolveWorkspaceDir(rawValue) {
   return process.cwd();
 }
 
+function resolveLocalCliCommand(commandName) {
+  const name = String(commandName || "").trim();
+  if (!name) {
+    throw new Error("command name is required");
+  }
+  if (process.platform === "win32") {
+    const candidates = [
+      path.join(process.env.APPDATA || "", "npm", `${name}.cmd`),
+      path.join(process.env.APPDATA || "", "npm", `${name}.ps1`),
+      path.join(process.env.APPDATA || "", "npm", name),
+    ].filter(Boolean);
+    for (const candidate of candidates) {
+      if (candidate && fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return name;
+}
+
+function quoteWindowsShellArg(value) {
+  const text = String(value ?? "");
+  if (!text) return '""';
+  if (!/[\s"&|<>^()]/.test(text)) return text;
+  return `"${text.replace(/"/g, '""')}"`;
+}
+
+function spawnCli(commandPath, args, options) {
+  const executable = String(commandPath || "").trim();
+  if (!executable) {
+    throw new Error("command path is required");
+  }
+  const normalizedArgs = Array.isArray(args) ? args.map((item) => String(item)) : [];
+  if (process.platform === "win32" && /\.(cmd|bat)$/i.test(executable)) {
+    const commandLine = [quoteWindowsShellArg(executable), ...normalizedArgs.map(quoteWindowsShellArg)].join(" ");
+    return spawnSync(
+      process.env.ComSpec || "cmd.exe",
+      ["/d", "/s", "/c", commandLine],
+      options,
+    );
+  }
+  return spawnSync(executable, normalizedArgs, options);
+}
+
 function buildPrompt(payload, { terse = true } = {}) {
   const safePayload = payload && typeof payload === "object" ? payload : {};
   const trigger = safePayload.trigger && typeof safePayload.trigger === "object" ? safePayload.trigger : {};
@@ -117,8 +161,9 @@ function normalizeCliResponse(rawText) {
 
 function runCodex(promptText, workspaceDir) {
   const outputPath = path.join(os.tmpdir(), `metheus-runner-codex-${Date.now()}.txt`);
-  const result = spawnSync(
-    "codex",
+  const codexCommand = resolveLocalCliCommand("codex");
+  const result = spawnCli(
+    codexCommand,
     [
       "exec",
       "-",
@@ -148,8 +193,9 @@ function runCodex(promptText, workspaceDir) {
 }
 
 function runClaude(promptText) {
-  const result = spawnSync(
-    "claude",
+  const claudeCommand = resolveLocalCliCommand("claude");
+  const result = spawnCli(
+    claudeCommand,
     [
       "-p",
       promptText,
@@ -175,8 +221,9 @@ function runClaude(promptText) {
 }
 
 function runGemini(promptText) {
-  const result = spawnSync(
-    "gemini",
+  const geminiCommand = resolveLocalCliCommand("gemini");
+  const result = spawnCli(
+    geminiCommand,
     [
       "-p",
       promptText,