metheus-governance-mcp-cli 0.2.57 → 0.2.59

package/cli.mjs

@@ -6,7 +6,7 @@ import path from "node:path";
 import process from "node:process";
 import readline from "node:readline";
 import { fileURLToPath } from "node:url";
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import http from "node:http";
 import https from "node:https";
@@ -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) {
@@ -1135,7 +1363,7 @@ function buildRunnerShellInvocation(command) {
   };
 }
 
-function runLocalAICommand({ command, inputPayload, route, destination }) {
+async function runLocalAICommand({ command, inputPayload, route, destination }) {
   const invocation = buildRunnerShellInvocation(command);
   const stdinText = `${JSON.stringify(inputPayload, null, 2)}\n`;
   const env = {
@@ -1146,16 +1374,72 @@ function runLocalAICommand({ command, inputPayload, route, destination }) {
     METHEUS_RUNNER_CHAT_ID: String(destination.chatID || "").trim(),
     METHEUS_RUNNER_DESTINATION_LABEL: String(destination.label || "").trim(),
   };
-  const result = spawnSync(invocation.file, invocation.args, {
-    encoding: "utf8",
-    input: stdinText,
-    env,
-    maxBuffer: 4 * 1024 * 1024,
+  const result = await new Promise((resolve, reject) => {
+    const child = spawn(invocation.file, invocation.args, {
+      env,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    let stdoutText = "";
+    let stderrText = "";
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    const maxBufferBytes = 4 * 1024 * 1024;
+    let settled = false;
+
+    function finishWithError(error) {
+      if (settled) return;
+      settled = true;
+      try {
+        child.kill();
+      } catch {}
+      reject(error);
+    }
+
+    function appendOutput(chunk, target) {
+      const text = String(chunk || "");
+      if (!text) return;
+      const bytes = Buffer.byteLength(text);
+      if (target === "stdout") {
+        stdoutBytes += bytes;
+        if (stdoutBytes > maxBufferBytes) {
+          finishWithError(new Error("runner command exceeded stdout buffer limit"));
+          return;
+        }
+        stdoutText += text;
+        return;
+      }
+      stderrBytes += bytes;
+      if (stderrBytes > maxBufferBytes) {
+        finishWithError(new Error("runner command exceeded stderr buffer limit"));
+        return;
+      }
+      stderrText += text;
+    }
+
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      reject(error);
+    });
+    child.stdout.on("data", (chunk) => appendOutput(chunk, "stdout"));
+    child.stderr.on("data", (chunk) => appendOutput(chunk, "stderr"));
+    child.on("close", (status, signal) => {
+      if (settled) return;
+      settled = true;
+      resolve({
+        status,
+        signal,
+        stdoutText: stdoutText.trim(),
+        stderrText: stderrText.trim(),
+      });
+    });
+    child.stdin.on("error", () => {});
+    child.stdin.end(stdinText);
   });
-  const stdoutText = String(result.stdout || "").trim();
-  const stderrText = String(result.stderr || "").trim();
-  if (result.error) {
-    throw new Error(String(result.error?.message || result.error));
+  const stdoutText = String(result.stdoutText || "").trim();
+  const stderrText = String(result.stderrText || "").trim();
+  if (result.signal) {
+    throw new Error(stderrText || stdoutText || `runner command terminated by signal ${result.signal}`);
   }
   if (result.status !== 0) {
     throw new Error(stderrText || stdoutText || `runner command exited with status ${result.status}`);
@@ -1244,9 +1528,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 +1748,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 +1770,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 +1802,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,
     };
   }
@@ -1507,12 +1824,41 @@ async function processRunnerRouteOnce(route, runtime, mode) {
     selectedRecord,
     contextWindow,
   });
-  const aiResult = runLocalAICommand({
-    command: normalizedRoute.command,
-    inputPayload: aiPayload,
-    route: normalizedRoute,
+  await maybeSendRunnerChatAction({
+    provider: normalizedRoute.provider,
     destination,
+    timeoutSeconds: runtime.timeoutSeconds,
+    action: "typing",
   });
+  let typingRequestInFlight = false;
+  const typingInterval = setInterval(() => {
+    if (typingRequestInFlight) return;
+    typingRequestInFlight = true;
+    maybeSendRunnerChatAction({
+      provider: normalizedRoute.provider,
+      destination,
+      timeoutSeconds: runtime.timeoutSeconds,
+      action: "typing",
+    })
+      .catch(() => {})
+      .finally(() => {
+        typingRequestInFlight = false;
+      });
+  }, 4000);
+  if (typeof typingInterval.unref === "function") {
+    typingInterval.unref();
+  }
+  let aiResult;
+  try {
+    aiResult = await runLocalAICommand({
+      command: normalizedRoute.command,
+      inputPayload: aiPayload,
+      route: normalizedRoute,
+      destination,
+    });
+  } finally {
+    clearInterval(typingInterval);
+  }
   if (aiResult.skip) {
     saveRunnerRouteState(
       routeKey,
@@ -1596,7 +1942,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 +1966,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) {
@@ -1916,6 +2262,73 @@ async function deliverLocalProviderMessage({
   throw new Error(`${providerEnvConfig(normalizedProvider).label} local delivery is not implemented yet`);
 }
 
+async function sendLocalProviderChatAction({
+  provider,
+  token,
+  destination,
+  action,
+  timeoutSeconds,
+}) {
+  const normalizedProvider = normalizeBotProvider(provider);
+  if (normalizedProvider === "telegram") {
+    const requestURL = `https://api.telegram.org/bot${token}/sendChatAction`;
+    const payload = {
+      chat_id: destination.chatID,
+      action: String(action || "typing").trim() || "typing",
+    };
+    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),
+    };
+  }
+  return {
+    statusCode: 204,
+    body: { ok: true, skipped: true },
+    ok: true,
+    url: "",
+  };
+}
+
+async function maybeSendRunnerChatAction({
+  provider,
+  destination,
+  timeoutSeconds,
+  action = "typing",
+}) {
+  const providerEnv = loadProviderEnvConfig(provider);
+  if (!providerEnv.ok) {
+    return {
+      ok: false,
+      skipped: true,
+      detail: providerEnv.error,
+    };
+  }
+  try {
+    const result = await sendLocalProviderChatAction({
+      provider,
+      token: providerEnv.token,
+      destination,
+      action,
+      timeoutSeconds,
+    });
+    return {
+      ok: Boolean(result.ok),
+      skipped: false,
+      detail: result.ok ? "" : String(safeObject(result.body).description || safeObject(result.body).error || "").trim(),
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      skipped: false,
+      detail: String(err?.message || err),
+    };
+  }
+}
+
 function resolveWorkspaceDir(rawPath) {
   const input = String(rawPath || "").trim();
   if (input) {

package/package.json

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