@fre4x/telegram 1.1.3 → 1.1.5

package/README.md

@@ -4,7 +4,7 @@ Telegram MCP server implementing Claude Code Channels for bidirectional communic
 
 ## Features
 
-- **Push Notifications:** Sends incoming Telegram messages directly to the Claude Code session via `notifications/push_event`.
+- **Push Notifications:** Sends incoming Telegram messages to the connected MCP client via `notifications/message` (claude/channel protocol).
 - **Bidirectional Chat:** Allows Claude to send messages to Telegram using the `send_telegram_message` tool.
 - **Security:** Filters incoming messages based on an allowed user ID.
 - **Remote Control:** (Planned) Approve or deny Claude's tool-use prompts from your mobile device.
@@ -62,14 +62,19 @@ If you are using this plugin as a bidirectional Claude Code channel rather than
 claude --channels plugin:telegram --dangerously-load-development-channels
 ```
 
-## Development
+## Mock Mode
+
+Run without a real bot token (returns fixture data of identical shape):
 
 ```bash
-npm run dev
+MOCK=true npx @fre4x/telegram
 ```
 
-Run the MCP Inspector:
+## Development
 
 ```bash
-npm run inspector
+npm run dev       # tsx, no build
+npm run build     # esbuild → dist/
+npm test          # vitest unit tests (MOCK=true)
+npm run inspector # MCP Inspector (MOCK=true)
 ```

package/dist/index.js

@@ -13,7 +13,11 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -3112,6 +3116,9 @@ var require_utils = __commonJS({
     "use strict";
     var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
     var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+    var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
+    var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
+    var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
     function stringArrayToHexStripped(input) {
       let acc = "";
       let code = 0;
@@ -3304,27 +3311,77 @@ var require_utils = __commonJS({
       }
       return output.join("");
     }
-    function normalizeComponentEncoding(component, esc2) {
-      const func = esc2 !== true ? escape : unescape;
-      if (component.scheme !== void 0) {
-        component.scheme = func(component.scheme);
-      }
-      if (component.userinfo !== void 0) {
-        component.userinfo = func(component.userinfo);
-      }
-      if (component.host !== void 0) {
-        component.host = func(component.host);
+    var HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
+    var HOST_DELIM_RE = /[@/?#:]/g;
+    var HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
+    function reescapeHostDelimiters(host, isIP) {
+      const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
+      re.lastIndex = 0;
+      return host.replace(re, (ch) => HOST_DELIMS[ch]);
+    }
+    function normalizePercentEncoding(input, decodeUnreserved = false) {
+      if (input.indexOf("%") === -1) {
+        return input;
       }
-      if (component.path !== void 0) {
-        component.path = func(component.path);
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decodeUnreserved && isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        output += input[i];
       }
-      if (component.query !== void 0) {
-        component.query = func(component.query);
+      return output;
+    }
+    function normalizePathEncoding(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decoded !== "." && isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        if (isPathCharacter(input[i])) {
+          output += input[i];
+        } else {
+          output += escape(input[i]);
+        }
       }
-      if (component.fragment !== void 0) {
-        component.fragment = func(component.fragment);
+      return output;
+    }
+    function escapePreservingEscapes(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            output += "%" + hex3.toUpperCase();
+            i += 2;
+            continue;
+          }
+        }
+        output += escape(input[i]);
       }
-      return component;
+      return output;
     }
     function recomposeAuthority(component) {
       const uriTokens = [];
@@ -3339,7 +3396,7 @@ var require_utils = __commonJS({
           if (ipV6res.isIPV6 === true) {
             host = `[${ipV6res.escapedHost}]`;
           } else {
-            host = component.host;
+            host = reescapeHostDelimiters(host, false);
           }
         }
         uriTokens.push(host);
@@ -3353,7 +3410,10 @@ var require_utils = __commonJS({
     module.exports = {
       nonSimpleDomain,
       recomposeAuthority,
-      normalizeComponentEncoding,
+      reescapeHostDelimiters,
+      normalizePercentEncoding,
+      normalizePathEncoding,
+      escapePreservingEscapes,
       removeDotSegments,
       isIPv4,
       isUUID,
@@ -3577,12 +3637,12 @@ var require_schemes = __commonJS({
 var require_fast_uri = __commonJS({
   "../node_modules/fast-uri/index.js"(exports, module) {
     "use strict";
-    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
+    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
     function normalize2(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
-        serialize(parse3(uri, options), options);
+        normalizeString(uri, options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
         parse3(serialize(uri, options), options);
@@ -3649,19 +3709,9 @@ var require_fast_uri = __commonJS({
       return target;
     }
     function equal(uriA, uriB, options) {
-      if (typeof uriA === "string") {
-        uriA = unescape(uriA);
-        uriA = serialize(normalizeComponentEncoding(parse3(uriA, options), true), { ...options, skipEscape: true });
-      } else if (typeof uriA === "object") {
-        uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
-      }
-      if (typeof uriB === "string") {
-        uriB = unescape(uriB);
-        uriB = serialize(normalizeComponentEncoding(parse3(uriB, options), true), { ...options, skipEscape: true });
-      } else if (typeof uriB === "object") {
-        uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
-      }
-      return uriA.toLowerCase() === uriB.toLowerCase();
+      const normalizedA = normalizeComparableURI(uriA, options);
+      const normalizedB = normalizeComparableURI(uriB, options);
+      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
     }
     function serialize(cmpts, opts) {
       const component = {
@@ -3686,12 +3736,12 @@ var require_fast_uri = __commonJS({
       if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
       if (component.path !== void 0) {
         if (!options.skipEscape) {
-          component.path = escape(component.path);
+          component.path = escapePreservingEscapes(component.path);
           if (component.scheme !== void 0) {
             component.path = component.path.split("%3A").join(":");
           }
         } else {
-          component.path = unescape(component.path);
+          component.path = normalizePercentEncoding(component.path);
         }
       }
       if (options.reference !== "suffix" && component.scheme) {
@@ -3726,7 +3776,16 @@ var require_fast_uri = __commonJS({
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-    function parse3(uri, opts) {
+    function getParseError(parsed, matches) {
+      if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
+        return 'URI path must start with "/" when authority is present.';
+      }
+      if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) {
+        return "URI port is malformed.";
+      }
+      return void 0;
+    }
+    function parseWithStatus(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
         scheme: void 0,
@@ -3737,6 +3796,7 @@ var require_fast_uri = __commonJS({
         query: void 0,
         fragment: void 0
       };
+      let malformedAuthorityOrPort = false;
       let isIP = false;
       if (options.reference === "suffix") {
         if (options.scheme) {
@@ -3757,6 +3817,11 @@ var require_fast_uri = __commonJS({
         if (isNaN(parsed.port)) {
           parsed.port = matches[5];
         }
+        const parseError = getParseError(parsed, matches);
+        if (parseError !== void 0) {
+          parsed.error = parsed.error || parseError;
+          malformedAuthorityOrPort = true;
+        }
         if (parsed.host) {
           const ipv4result = isIPv4(parsed.host);
           if (ipv4result === false) {
@@ -3795,14 +3860,18 @@ var require_fast_uri = __commonJS({
               parsed.scheme = unescape(parsed.scheme);
             }
             if (parsed.host !== void 0) {
-              parsed.host = unescape(parsed.host);
+              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
             }
           }
           if (parsed.path) {
-            parsed.path = escape(unescape(parsed.path));
+            parsed.path = normalizePathEncoding(parsed.path);
           }
           if (parsed.fragment) {
-            parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            try {
+              parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            } catch {
+              parsed.error = parsed.error || "URI malformed";
+            }
           }
         }
         if (schemeHandler && schemeHandler.parse) {
@@ -3811,7 +3880,29 @@ var require_fast_uri = __commonJS({
       } else {
         parsed.error = parsed.error || "URI can not be parsed.";
       }
-      return parsed;
+      return { parsed, malformedAuthorityOrPort };
+    }
+    function parse3(uri, opts) {
+      return parseWithStatus(uri, opts).parsed;
+    }
+    function normalizeString(uri, opts) {
+      return normalizeStringWithStatus(uri, opts).normalized;
+    }
+    function normalizeStringWithStatus(uri, opts) {
+      const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+      return {
+        normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
+        malformedAuthorityOrPort
+      };
+    }
+    function normalizeComparableURI(uri, opts) {
+      if (typeof uri === "string") {
+        const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
+        return malformedAuthorityOrPort ? void 0 : normalized;
+      }
+      if (typeof uri === "object") {
+        return serialize(uri, opts);
+      }
     }
     var fastUri = {
       SCHEMES,
@@ -6878,7 +6969,7 @@ var require_main = __commonJS({
   "../node_modules/dotenv/lib/main.js"(exports, module) {
     var fs2 = __require("fs");
     var path2 = __require("path");
-    var os = __require("os");
+    var os2 = __require("os");
     var crypto = __require("crypto");
     var packageJson = require_package();
     var version2 = packageJson.version;
@@ -7001,7 +7092,7 @@ var require_main = __commonJS({
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path2.join(os.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path2.join(os2.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = Boolean(options && options.debug);
@@ -28144,7 +28235,9 @@ var StdioServerTransport = class {
 // src/index.ts
 var import_dotenv = __toESM(require_main(), 1);
 import { Telegraf } from "telegraf";
+import { createHash } from "node:crypto";
 import * as fs from "fs";
+import os from "node:os";
 import * as path from "path";
 
 // ../node_modules/zod/index.js
@@ -28496,6 +28589,13 @@ function applyPagination(items, params) {
 
 // src/index.ts
 import_dotenv.default.config();
+function getStatePath() {
+  if (process.env.TELEGRAM_STATE_PATH) {
+    return process.env.TELEGRAM_STATE_PATH;
+  }
+  const suffix = botToken && !IS_MOCK ? createHash("sha256").update(botToken).digest("hex").slice(0, 12) : "default";
+  return path.join(os.homedir(), ".fre4x", `telegram-mcp-${suffix}.json`);
+}
 var window = new JSDOM("").window;
 var DOMPurify = createDOMPurify(window);
 var IS_MOCK = process.env.MOCK === "true" || process.env.TELEGRAM_MOCK === "true";
@@ -28569,13 +28669,7 @@ function validateFilePath(filePath) {
   }
   return absolutePath;
 }
-function validateRecipient(targetId) {
-  const userPattern = /^\d+$/;
-  const groupPattern = /^-?\d+$/;
-  const usernamePattern = /^@[a-zA-Z0-9_]+$/;
-  if (!userPattern.test(targetId) && !groupPattern.test(targetId) && !usernamePattern.test(targetId)) {
-    throw new Error(`Invalid Telegram ID format: ${targetId}`);
-  }
+function assertRecipientAllowed(targetId) {
   if (enableRecipientWhitelist && allowedRecipients.length > 0) {
     if (!allowedRecipients.includes(targetId)) {
       throw new Error(
@@ -28584,6 +28678,18 @@ function validateRecipient(targetId) {
     }
   }
 }
+function validateSendRecipient(targetId) {
+  if (!/^\d+$/.test(targetId)) {
+    throw new Error(`Invalid Telegram user ID format: ${targetId}`);
+  }
+  assertRecipientAllowed(targetId);
+}
+function validateChatId(chatId) {
+  if (!/^-?\d+$/.test(chatId)) {
+    throw new Error(`Invalid Telegram chat ID format: ${chatId}`);
+  }
+  assertRecipientAllowed(chatId);
+}
 var SendMessageSchema = external_exports3.object({
   content: external_exports3.string().min(1).max(4096),
   recipientId: external_exports3.string().optional(),
@@ -28622,8 +28728,16 @@ var server = new Server(
   },
   {
     capabilities: {
-      tools: {}
-    }
+      tools: {},
+      logging: {},
+      // Required by SDK for notifications/message
+      experimental: {
+        "claude/channel": {
+          description: "Telegram events are delivered via channel notifications"
+        }
+      }
+    },
+    instructions: "Telegram MCP server. Delivers inbound Telegram messages as channel notifications via notifications/message."
   }
 );
 var isImage = (filePath) => {
@@ -28632,12 +28746,275 @@ var isImage = (filePath) => {
 };
 var messageHistory = [];
 var MAX_HISTORY = 100;
+var pollingOffset = 0;
+var knownChats = /* @__PURE__ */ new Map();
+function loadState() {
+  if (IS_MOCK) return;
+  try {
+    if (!fs.existsSync(getStatePath())) return;
+    const raw = fs.readFileSync(getStatePath(), "utf-8");
+    const state = JSON.parse(raw);
+    for (const chat of state.knownChats ?? []) {
+      if (chat?.id) {
+        knownChats.set(chat.id, chat);
+      }
+    }
+    if (typeof state.pollingOffset === "number") {
+      pollingOffset = state.pollingOffset;
+    }
+    console.error(
+      `[telegram:state] loaded ${knownChats.size} chat(s) from ${getStatePath()}`
+    );
+  } catch (error48) {
+    console.error(`[telegram:state] failed to load ${getStatePath()}:`, error48);
+  }
+}
+function persistState() {
+  if (IS_MOCK) return;
+  try {
+    const state = {
+      knownChats: Array.from(knownChats.values()),
+      pollingOffset
+    };
+    fs.mkdirSync(path.dirname(getStatePath()), { recursive: true });
+    fs.writeFileSync(getStatePath(), JSON.stringify(state, null, 2), "utf-8");
+  } catch (error48) {
+    console.error(`[telegram:state] failed to persist ${getStatePath()}:`, error48);
+  }
+}
+function reloadState() {
+  if (IS_MOCK) return;
+  try {
+    if (!fs.existsSync(getStatePath())) return;
+    const raw = fs.readFileSync(getStatePath(), "utf-8");
+    const state = JSON.parse(raw);
+    for (const chat of state.knownChats ?? []) {
+      if (chat?.id) {
+        knownChats.set(chat.id, chat);
+      }
+    }
+    if (typeof state.pollingOffset === "number" && state.pollingOffset > pollingOffset) {
+      pollingOffset = state.pollingOffset;
+    }
+  } catch (error48) {
+    console.error(`[telegram:state] failed to reload ${getStatePath()}:`, error48);
+  }
+}
+function chatTitleFromTelegramChat(chat) {
+  return chat.title || chat.username || chat.first_name || "Private Chat";
+}
+function recordKnownChat(chat) {
+  knownChats.set(chat.id, chat);
+  persistState();
+}
+function recordKnownChatFromTelegramMessage(message) {
+  recordKnownChat({
+    id: message.chat.id.toString(),
+    title: chatTitleFromTelegramChat(message.chat),
+    type: message.chat.type ?? "unknown"
+  });
+}
+function recordKnownChatFromUpdate(update) {
+  const chat = update.message?.chat ?? update.edited_message?.chat ?? update.channel_post?.chat ?? update.my_chat_member?.chat;
+  if (!chat) return;
+  recordKnownChat({
+    id: chat.id.toString(),
+    title: chatTitleFromTelegramChat(chat),
+    type: chat.type ?? "unknown"
+  });
+}
+function logActiveChatsDebug(stage) {
+  const active = getActiveChats();
+  console.error(
+    `[telegram:list_active_chats] ${stage}: knownChats=${knownChats.size} messageHistory=${messageHistory.length} active=${active.length} pollingOffset=${pollingOffset}`
+  );
+  if (knownChats.size > 0) {
+    console.error(
+      `[telegram:list_active_chats] knownChatIds: ${Array.from(knownChats.keys()).join(", ")}`
+    );
+  }
+  if (active.length > 0) {
+    console.error(
+      `[telegram:list_active_chats] activeChatIds: ${active.map((c) => c.id).join(", ")}`
+    );
+  }
+}
+async function recordChatInteraction(chatId) {
+  if (IS_MOCK || !bot) {
+    recordKnownChat({
+      id: chatId,
+      title: `Chat ${chatId}`,
+      type: "unknown"
+    });
+    console.error(
+      `[telegram:recordChatInteraction] mock recorded chatId=${chatId} knownChats=${knownChats.size}`
+    );
+    return;
+  }
+  try {
+    const chat = await bot.telegram.getChat(chatId);
+    recordKnownChat({
+      id: chat.id.toString(),
+      title: chatTitleFromTelegramChat(chat),
+      type: chat.type
+    });
+    console.error(
+      `[telegram:recordChatInteraction] getChat ok chatId=${chat.id} knownChats=${knownChats.size}`
+    );
+  } catch (error48) {
+    recordKnownChat({
+      id: chatId,
+      title: chatId,
+      type: "unknown"
+    });
+    console.error(
+      `[telegram:recordChatInteraction] getChat failed for ${chatId}, stored fallback:`,
+      error48
+    );
+  }
+}
+function getConfiguredChatCandidates() {
+  const candidates = /* @__PURE__ */ new Set();
+  if (allowedUserId) candidates.add(allowedUserId);
+  for (const id of allowedRecipients) {
+    if (id) candidates.add(id);
+  }
+  for (const chat of knownChats.values()) {
+    candidates.add(chat.id);
+  }
+  for (const msg of messageHistory) {
+    candidates.add(msg.chatId);
+  }
+  return candidates;
+}
+async function ensurePollingMode() {
+  if (!bot || IS_MOCK) return;
+  try {
+    const info = await bot.telegram.getWebhookInfo();
+    if (info.url) {
+      console.error(
+        `[telegram] active webhook detected (${info.url}); switching to getUpdates polling`
+      );
+      await bot.telegram.deleteWebhook({ drop_pending_updates: false });
+    }
+  } catch (error48) {
+    console.error("[telegram] ensurePollingMode failed:", error48);
+  }
+}
+async function discoverChatsFromApi() {
+  if (IS_MOCK || !bot) return;
+  const candidates = getConfiguredChatCandidates();
+  console.error(
+    `[telegram:list_active_chats] discoverChatsFromApi: probing ${candidates.size} candidate chat(s) from state=${getStatePath()}`
+  );
+  for (const chatId of candidates) {
+    await recordChatInteraction(chatId);
+  }
+  try {
+    await ensurePollingMode();
+    const updates = await bot.telegram.getUpdates(0, 100, pollingOffset, [
+      "message",
+      "edited_message",
+      "channel_post",
+      "my_chat_member",
+      "chat_member"
+    ]);
+    for (const update of updates) {
+      pollingOffset = update.update_id + 1;
+      const msgLike = update;
+      if (!msgLike.message && !msgLike.edited_message && !msgLike.channel_post && !msgLike.my_chat_member)
+        continue;
+      recordKnownChatFromUpdate(msgLike);
+    }
+    console.error(
+      `[telegram:list_active_chats] discoverChatsFromApi: processed ${updates.length} update(s)`
+    );
+    persistState();
+  } catch (error48) {
+    console.error(
+      "[telegram:list_active_chats] discoverChatsFromApi getUpdates failed:",
+      error48
+    );
+  }
+}
+function getActiveChats() {
+  const chats = /* @__PURE__ */ new Map();
+  for (const chat of knownChats.values()) {
+    chats.set(chat.id, chat);
+  }
+  for (const msg of messageHistory) {
+    if (chats.has(msg.chatId)) continue;
+    chats.set(msg.chatId, {
+      id: msg.chatId,
+      title: msg.chatTitle || "Unknown",
+      type: msg.metadata?.chatType || "unknown"
+    });
+  }
+  return Array.from(chats.values()).sort(
+    (a, b) => a.title.localeCompare(b.title)
+  );
+}
+async function fetchNewUpdates() {
+  if (!bot || IS_MOCK) return;
+  try {
+    await ensurePollingMode();
+    const updates = await bot.telegram.getUpdates(0, 100, pollingOffset, [
+      "message",
+      "edited_message",
+      "channel_post",
+      "my_chat_member"
+    ]);
+    for (const update of updates) {
+      pollingOffset = update.update_id + 1;
+      const msgLike = update;
+      if (!msgLike.message && !msgLike.edited_message && !msgLike.channel_post && !msgLike.my_chat_member)
+        continue;
+      recordKnownChatFromUpdate(msgLike);
+      const msg = msgLike.message;
+      if (!msg?.text) continue;
+      const senderId = msg.from?.id?.toString() ?? "unknown";
+      const chatId = msg.chat.id.toString();
+      const chatTitle = msg.chat.title || msg.chat.username || msg.chat.first_name || "Private Chat";
+      if (messageHistory.some(
+        (m) => m.metadata?.message_id === msg.message_id
+      ))
+        continue;
+      const currentAllowedUserId = process.env.ALLOWED_USER_ID;
+      if (currentAllowedUserId && msg.chat.type === "private") {
+        if (senderId !== currentAllowedUserId) continue;
+      }
+      let content = DOMPurify.sanitize(msg.text, {
+        ALLOWED_TAGS: [],
+        ALLOWED_ATTR: []
+      });
+      content = content.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/[*_~]/g, "\\$&");
+      messageHistory.push({
+        senderId,
+        chatId,
+        chatTitle,
+        content,
+        timestamp: new Date(msg.date * 1e3).toISOString(),
+        metadata: {
+          chatId,
+          chatType: msg.chat.type,
+          message_id: msg.message_id
+        }
+      });
+      if (messageHistory.length > MAX_HISTORY) {
+        messageHistory.shift();
+      }
+    }
+    persistState();
+  } catch (error48) {
+    console.error("fetchNewUpdates failed:", error48);
+  }
+}
 server.setRequestHandler(ListToolsRequestSchema, async () => {
   return {
     tools: [
       {
-        name: "send_telegram_message",
-        description: "Send a text message, photo, or document to a specific Telegram user, group, or channel.",
+        name: "send_message",
+        description: "Send text, photo, or document to a Telegram user by numeric ID.",
         inputSchema: {
           type: "object",
           properties: {
@@ -28647,7 +29024,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
             recipientId: {
               type: "string",
-              description: "Target ID or @username."
+              description: "Numeric Telegram user ID."
             },
             mediaPath: {
               type: "string",
@@ -28675,7 +29052,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: "list_active_chats",
-        description: "List all unique Telegram chats the bot has interacted with.",
+        description: "List chats the bot has sent to or received messages from.",
         inputSchema: {
           type: "object",
           properties: {
@@ -28689,16 +29066,26 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         description: "Get detailed information about a specific Telegram chat.",
         inputSchema: {
           type: "object",
-          properties: { chatId: { type: "string" } },
+          properties: {
+            chatId: {
+              type: "string",
+              description: "Numeric Telegram chat ID."
+            }
+          },
           required: ["chatId"]
         }
       },
       {
-        name: "leave_telegram_chat",
+        name: "leave_chat",
         description: "Request the bot to leave a specific group or channel.",
         inputSchema: {
           type: "object",
-          properties: { chatId: { type: "string" } },
+          properties: {
+            chatId: {
+              type: "string",
+              description: "Numeric Telegram chat ID."
+            }
+          },
           required: ["chatId"]
         }
       }
@@ -28709,7 +29096,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
   const currentAllowedUserId = process.env.ALLOWED_USER_ID;
   try {
-    if (name === "send_telegram_message") {
+    if (name === "send_message") {
+      reloadState();
       const { content, recipientId, mediaPath, mediaType } = SendMessageSchema.parse(args);
       const targetId = recipientId || currentAllowedUserId;
       if (!targetId) {
@@ -28724,7 +29112,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           429
         );
       }
-      validateRecipient(targetId);
+      validateSendRecipient(targetId);
       let safePath;
       if (mediaPath) {
         safePath = validateFilePath(mediaPath);
@@ -28734,19 +29122,24 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         if (mediaPath)
           mockResponse += `
 [Mock] Media: ${mediaPath} (${mediaType || "auto"})`;
+        await recordChatInteraction(targetId);
         return { content: [{ type: "text", text: mockResponse }] };
       }
       if (mediaPath && safePath) {
         const source = { source: safePath };
         const isPhoto = mediaType === "photo" || !mediaType && isImage(safePath);
         if (isPhoto) {
-          await bot.telegram.sendPhoto(targetId, source, {
+          const sent = await bot.telegram.sendPhoto(targetId, source, {
             caption: content
           });
+          recordKnownChatFromTelegramMessage(sent);
         } else {
-          await bot.telegram.sendDocument(targetId, source, {
-            caption: content
-          });
+          const sent = await bot.telegram.sendDocument(
+            targetId,
+            source,
+            { caption: content }
+          );
+          recordKnownChatFromTelegramMessage(sent);
         }
         return {
           content: [
@@ -28757,7 +29150,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           ]
         };
       } else {
-        await bot.telegram.sendMessage(targetId, content);
+        const sent = await bot.telegram.sendMessage(targetId, content);
+        recordKnownChatFromTelegramMessage(sent);
         return {
           content: [
             { type: "text", text: `Message sent successfully.` }
@@ -28767,6 +29161,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
     if (name === "get_recent_messages") {
       const { limit, offset } = GetRecentMessagesSchema.parse(args || {});
+      await fetchNewUpdates();
       const paginated = applyPagination(
         messageHistory.slice().reverse(),
         { limit, offset }
@@ -28795,18 +29190,12 @@ ${formatPaginationFooter(offset, limit, messageHistory.length)}`
     }
     if (name === "list_active_chats") {
       const { limit, offset } = GetRecentMessagesSchema.parse(args || {});
-      const uniqueChatIds = Array.from(
-        new Set(messageHistory.map((m) => m.chatId))
-      );
-      const chatDetails = uniqueChatIds.map((id) => {
-        const lastMsg = messageHistory.slice().reverse().find((m) => m.chatId === id);
-        return {
-          id,
-          title: lastMsg?.chatTitle || "Unknown",
-          type: lastMsg?.metadata?.chatType || "unknown"
-        };
-      });
-      const paginated = applyPagination(chatDetails, { limit, offset });
+      reloadState();
+      await fetchNewUpdates();
+      await discoverChatsFromApi();
+      logActiveChatsDebug("after fetch and discover");
+      const activeChats = getActiveChats();
+      const paginated = applyPagination(activeChats, { limit, offset });
       const formatted = paginated.items.map((c) => `- ${c.title} (ID: ${c.id}, Type: ${c.type})`).join("\n");
       return {
         content: [
@@ -28815,14 +29204,14 @@ ${formatPaginationFooter(offset, limit, messageHistory.length)}`
             text: formatted ? `Active chats:
 ${formatted}
 
-${formatPaginationFooter(offset, limit, uniqueChatIds.length)}` : "No active chats found."
+${formatPaginationFooter(offset, limit, activeChats.length)}` : "No active chats found."
           }
         ]
       };
     }
     if (name === "get_chat_info") {
       const { chatId } = GetChatInfoSchema.parse(args);
-      validateRecipient(chatId);
+      validateChatId(chatId);
       if (IS_MOCK || !bot) {
         return {
           content: [
@@ -28848,9 +29237,9 @@ ${formatPaginationFooter(offset, limit, uniqueChatIds.length)}` : "No active cha
         ]
       };
     }
-    if (name === "leave_telegram_chat") {
+    if (name === "leave_chat") {
       const { chatId } = LeaveChatSchema.parse(args);
-      validateRecipient(chatId);
+      validateChatId(chatId);
       if (IS_MOCK || !bot) {
         return {
           content: [
@@ -28892,108 +29281,29 @@ ${formatPaginationFooter(offset, limit, uniqueChatIds.length)}` : "No active cha
       if (msg.includes("limit exceeded")) {
         return createApiError("Rate limit exceeded.", 429);
       }
+      if (msg.includes("invalid telegram user id format")) {
+        return createValidationError(
+          "recipientId",
+          'Use a numeric user ID only (e.g., "123456789"). @username is not supported.'
+        );
+      }
+      if (msg.includes("invalid telegram chat id format")) {
+        return createValidationError(
+          "chatId",
+          'Use a numeric chat ID only (e.g., "123456789"). @username is not supported.'
+        );
+      }
     }
     return createInternalError(
       "An unexpected error occurred while processing the request."
     );
   }
 });
-if (bot) {
-  bot.on("text", async (ctx) => {
-    const senderId = ctx.from.id.toString();
-    const chatId = ctx.chat.id.toString();
-    const chatTitle = ctx.chat.title || ctx.chat.username || ctx.chat.first_name || "Private Chat";
-    const currentAllowedUserId = process.env.ALLOWED_USER_ID;
-    if (currentAllowedUserId) {
-      if (ctx.chat.type === "private") {
-        if (senderId !== currentAllowedUserId) {
-          console.warn(
-            `Unauthorized private message from ${senderId}`
-          );
-          await ctx.reply(
-            "\u274C Access denied. Only the authorized user can interact with this bot."
-          ).catch(() => {
-          });
-          return;
-        }
-      } else if (ctx.chat.type === "group" || ctx.chat.type === "supergroup") {
-        try {
-          const chatMember = await ctx.getChatMember(ctx.from.id);
-          const isAdmin = ["creator", "administrator"].includes(
-            chatMember.status
-          );
-          if (!isAdmin && senderId !== currentAllowedUserId) {
-            console.warn(
-              `Unauthorized group message from ${senderId} in ${chatTitle}`
-            );
-            return;
-          }
-        } catch (error48) {
-          console.error(
-            "Failed to check group member status:",
-            error48
-          );
-          return;
-        }
-      } else if (ctx.chat.type === "channel") {
-        return;
-      }
-    }
-    let messageContent = ctx.message.text;
-    messageContent = DOMPurify.sanitize(messageContent, {
-      ALLOWED_TAGS: [],
-      ALLOWED_ATTR: []
-    });
-    messageContent = messageContent.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/[*_~]/g, "\\$&");
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const metadata = {
-      chatId,
-      chatType: ctx.chat?.type,
-      message_id: ctx.message.message_id
-    };
-    messageHistory.push({
-      senderId,
-      chatId,
-      chatTitle,
-      content: messageContent,
-      timestamp,
-      metadata
-    });
-    if (messageHistory.length > MAX_HISTORY) {
-      messageHistory.shift();
-    }
-    try {
-      await server.notification({
-        method: "notifications/push_event",
-        params: {
-          type: "message",
-          senderId,
-          content: messageContent,
-          metadata
-        }
-      });
-    } catch (error48) {
-      console.error("Failed to push notification:", error48);
-    }
-  });
-}
 async function run() {
+  loadState();
   const transport = new StdioServerTransport();
   await server.connect(transport);
   console.error("Telegram MCP Server running on stdio");
-  if (bot) {
-    bot.launch().catch((err) => {
-      console.error("Failed to launch Telegram bot:", err);
-    });
-    process.once("SIGINT", () => {
-      bot.stop("SIGINT");
-      process.exit(0);
-    });
-    process.once("SIGTERM", () => {
-      bot.stop("SIGTERM");
-      process.exit(0);
-    });
-  }
 }
 if (process.env.NODE_ENV !== "test") {
   run().catch((error48) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fre4x/telegram",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Telegram MCP server implementing Claude Code Channels for bidirectional communication and remote permission relay.",
   "type": "module",
   "main": "dist/index.js",