@ebowwa/glm-daemon 0.4.5 → 0.4.7

package/dist/bin/discord-cli.js

@@ -92156,7 +92156,86 @@ var require_src2 = __commonJS((exports) => {
   __exportStar(require_dist3(), exports);
   __exportStar(require_dist11(), exports);
 });
-
+// ../channel-types/dist/plugins/registry.js
+class PluginRegistryImpl {
+  channels = new Map;
+  channelOrder = [];
+  registerChannel(registration) {
+    const id = registration.plugin.id;
+    if (typeof id !== "string") {
+      throw new Error("Channel plugin id must be a string");
+    }
+    const normalizedId = id.trim().toLowerCase();
+    if (this.channels.has(normalizedId)) {
+      console.warn(`[PluginRegistry] Channel "${normalizedId}" already registered, replacing`);
+    }
+    this.channels.set(normalizedId, registration);
+    if (!this.channelOrder.includes(normalizedId)) {
+      this.channelOrder.push(normalizedId);
+    }
+    console.log(`[PluginRegistry] Registered channel: ${normalizedId} (source: ${registration.source})`);
+  }
+  unregisterChannel(channelId) {
+    const normalizedId = channelId.trim().toLowerCase();
+    const existed = this.channels.delete(normalizedId);
+    if (existed) {
+      this.channelOrder = this.channelOrder.filter((id) => id !== normalizedId);
+    }
+    return existed;
+  }
+  getChannel(channelId) {
+    const normalizedId = this.normalizeChannelId(channelId);
+    const registration = this.channels.get(normalizedId);
+    return registration?.plugin;
+  }
+  getChannelRegistration(channelId) {
+    const normalizedId = this.normalizeChannelId(channelId);
+    return this.channels.get(normalizedId);
+  }
+  getChannels() {
+    return this.channelOrder.map((id) => this.channels.get(id)?.plugin).filter((p) => p !== undefined);
+  }
+  getChannelRegistrations() {
+    return this.channelOrder.map((id) => this.channels.get(id)).filter((r) => r !== undefined);
+  }
+  getChannelOrder() {
+    return [...this.channelOrder];
+  }
+  setChannelOrder(order) {
+    this.channelOrder = order.map((id) => id.toLowerCase().trim());
+  }
+  getChannelsByCapability(capability) {
+    return this.getChannels().filter((plugin) => plugin.capabilities.supports[capability] === true);
+  }
+  getChannelsByChatType(chatType) {
+    return this.getChannels().filter((plugin) => plugin.capabilities.chatTypes?.includes(chatType));
+  }
+  hasChannel(channelId) {
+    return this.channels.has(this.normalizeChannelId(channelId));
+  }
+  normalizeChannelId(channelId) {
+    const id = channelId.trim().toLowerCase();
+    const aliases = {
+      tg: "telegram",
+      imsg: "imessage",
+      wa: "whatsapp",
+      dc: "discord",
+      sl: "slack"
+    };
+    return aliases[id] || id;
+  }
+  clear() {
+    this.channels.clear();
+    this.channelOrder = [];
+  }
+  getStats() {
+    return {
+      channelCount: this.channels.size,
+      channels: this.getChannelOrder()
+    };
+  }
+}
+var pluginRegistry = new PluginRegistryImpl;
 // ../channel-types/dist/index.js
 function createChannelId(platform, accountId, instanceId) {
   return { platform, accountId, instanceId };
@@ -98838,6 +98917,266 @@ function registerAllCommands(bot, memory, tools) {
   registerInnerthoughtsCommand(bot, memory, tools);
   register(bot, tools);
 }
+
+// ../channel-telegram/dist/plugin.js
+var telegramMeta = {
+  label: "Telegram",
+  blurb: "Telegram Bot API for direct and group chats",
+  icon: "\uD83D\uDCF1",
+  docsPath: "/docs/channels/telegram",
+  quickstartAllowFrom: true
+};
+var telegramConfigAdapter = {
+  listAccountIds: async (config) => {
+    const botToken = config.botToken;
+    if (!botToken)
+      return [];
+    return ["default"];
+  },
+  resolveAccount: async (config, accountId) => {
+    return {
+      botToken: config.botToken,
+      allowedUsers: config.allowedUsers,
+      allowedChats: config.allowedChats,
+      pollingInterval: config.pollingInterval || 1000
+    };
+  },
+  validateAccount: async (account) => {
+    if (!account.botToken)
+      return false;
+    return true;
+  }
+};
+var createOutboundAdapter = (getBot) => ({
+  deliveryMode: "direct",
+  textChunkLimit: 4096,
+  chunker: (text, limit) => {
+    const chunks = [];
+    for (let i = 0;i < text.length; i += limit) {
+      chunks.push(text.slice(i, i + limit));
+    }
+    return { chunks, totalChunks: chunks.length };
+  },
+  sendText: async ({ to, text, accountId, account, replyToId, threadId }) => {
+    const bot = getBot();
+    if (!bot) {
+      return { success: false, error: "Bot not initialized", timestamp: new Date };
+    }
+    try {
+      const chatId = parseInt(to, 10);
+      const options = {
+        parse_mode: "Markdown"
+      };
+      if (replyToId) {
+        options.reply_to_message_id = parseInt(replyToId, 10);
+      }
+      if (threadId) {
+        options.message_thread_id = parseInt(threadId, 10);
+      }
+      const result = await bot.sendMessage(chatId, text, options);
+      return {
+        success: true,
+        messageId: result.message_id.toString(),
+        timestamp: new Date
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        timestamp: new Date
+      };
+    }
+  },
+  sendMedia: async ({ to, text, mediaUrl, mediaType, accountId, account }) => {
+    const bot = getBot();
+    if (!bot) {
+      return { success: false, error: "Bot not initialized", timestamp: new Date };
+    }
+    try {
+      const chatId = parseInt(to, 10);
+      let result;
+      if (mediaType === "image") {
+        result = await bot.sendPhoto(chatId, mediaUrl, { caption: text });
+      } else if (mediaType === "video") {
+        result = await bot.sendVideo(chatId, mediaUrl, { caption: text });
+      } else if (mediaType === "audio") {
+        result = await bot.sendAudio(chatId, mediaUrl, { caption: text });
+      } else {
+        result = await bot.sendDocument(chatId, mediaUrl, { caption: text });
+      }
+      return {
+        success: true,
+        messageId: result.message_id.toString(),
+        timestamp: new Date
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        timestamp: new Date
+      };
+    }
+  }
+});
+var telegramThreadingAdapter = {
+  replyModes: ["quote", "thread"],
+  defaultReplyMode: "quote"
+};
+var createGatewayAdapter = (createBot) => {
+  const activeBots = new Map;
+  const messageHandlers = new Map;
+  return {
+    startAccount: async ({ accountId, account, onMessage }) => {
+      const bot = createBot(account.botToken);
+      const handler = (msg) => {
+        if (account.allowedUsers?.length && !account.allowedUsers.includes(msg.from?.id || 0)) {
+          return;
+        }
+        if (account.allowedChats?.length && !account.allowedChats.includes(msg.chat.id)) {
+          return;
+        }
+        const channelId = {
+          platform: "telegram",
+          accountId: msg.chat.id.toString()
+        };
+        const channelMessage = {
+          messageId: msg.message_id.toString(),
+          channelId,
+          timestamp: new Date(msg.date * 1000),
+          sender: {
+            id: msg.from?.id.toString() || "unknown",
+            username: msg.from?.username,
+            displayName: msg.from?.first_name,
+            isBot: msg.from?.is_bot || false
+          },
+          text: msg.text || "",
+          context: {
+            isDM: msg.chat.type === "private",
+            groupName: msg.chat.title,
+            threadId: msg.message_thread_id?.toString()
+          },
+          replyTo: msg.reply_to_message ? {
+            messageId: msg.reply_to_message.message_id.toString(),
+            channelId
+          } : undefined
+        };
+        onMessage(channelMessage);
+      };
+      bot.on("message", handler);
+      activeBots.set(accountId, bot);
+      messageHandlers.set(accountId, handler);
+    },
+    stopAccount: async ({ accountId, account }) => {
+      const bot = activeBots.get(accountId);
+      const handler = messageHandlers.get(accountId);
+      if (bot && handler) {
+        bot.off("message", handler);
+        if (bot.isPolling()) {
+          await bot.stopPolling();
+        }
+        activeBots.delete(accountId);
+        messageHandlers.delete(accountId);
+      }
+    },
+    isAccountActive: (accountId) => {
+      return activeBots.has(accountId);
+    }
+  };
+};
+function createTelegramPlugin(config = {}, TelegramBotClass) {
+  let bot = null;
+  const createBot = (token) => {
+    if (!TelegramBotClass) {
+      throw new Error("TelegramBot class not provided");
+    }
+    return new TelegramBotClass(token, { polling: true });
+  };
+  return {
+    id: "telegram",
+    meta: telegramMeta,
+    capabilities: {
+      chatTypes: ["direct", "group", "channel", "thread"],
+      supports: {
+        text: true,
+        media: true,
+        replies: true,
+        threads: true,
+        reactions: true,
+        editing: true,
+        streaming: false,
+        buttons: true
+      },
+      nativeCommands: true,
+      rateLimits: {
+        messagesPerMinute: 30,
+        charactersPerMessage: 4096
+      },
+      media: {
+        maxFileSize: 50 * 1024 * 1024,
+        supportedMimeTypes: ["image/*", "video/*", "audio/*", "application/pdf"]
+      }
+    },
+    config: telegramConfigAdapter,
+    outbound: createOutboundAdapter(() => bot),
+    gateway: createGatewayAdapter((token) => {
+      bot = createBot(token);
+      return bot;
+    }),
+    threading: telegramThreadingAdapter
+  };
+}
+var telegramPlugin = createTelegramPlugin();
+if (process.env.TELEGRAM_BOT_TOKEN) {
+  pluginRegistry.registerChannel({
+    pluginId: "telegram",
+    plugin: telegramPlugin,
+    source: "core"
+  });
+}
+// ../channel-telegram/dist/utils/normalize.js
+function normalizeTelegramMessagingTarget(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return;
+  let normalized = trimmed;
+  if (normalized.startsWith("telegram:")) {
+    normalized = normalized.slice("telegram:".length).trim();
+  } else if (normalized.startsWith("tg:")) {
+    normalized = normalized.slice("tg:".length).trim();
+  }
+  if (!normalized)
+    return;
+  const tmeMatch = /^https?:\/\/t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized) ?? /^t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized);
+  if (tmeMatch?.[1]) {
+    normalized = `@${tmeMatch[1]}`;
+  }
+  if (!normalized)
+    return;
+  return `telegram:${normalized}`.toLowerCase();
+}
+function looksLikeTelegramTargetId(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return false;
+  if (/^(telegram|tg):/i.test(trimmed))
+    return true;
+  if (trimmed.startsWith("@"))
+    return true;
+  return /^-?\d{6,}$/.test(trimmed);
+}
+function extractRawTarget(normalized) {
+  const trimmed = normalized.trim();
+  if (!trimmed.startsWith("telegram:"))
+    return;
+  const raw = trimmed.slice("telegram:".length);
+  return raw || undefined;
+}
+function isNumericIdTarget(normalized) {
+  const raw = extractRawTarget(normalized);
+  if (!raw)
+    return false;
+  return /^-?\d+$/.test(raw);
+}
 // ../channel-telegram/dist/index.js
 class TelegramChannel {
   id;
@@ -99202,6 +99541,41 @@ class GLMTelegramChannel extends BaseChannel {
   isAllowed(userId, chatId) {
     return this.protocolAdapter.isAllowed(userId, chatId);
   }
+  normalizeTarget(raw) {
+    return normalizeTelegramMessagingTarget(raw);
+  }
+  isValidTarget(raw) {
+    return looksLikeTelegramTargetId(raw);
+  }
+  parseTargetFromInput(input) {
+    const words = input.split(/\s+/);
+    for (const word of words) {
+      if (looksLikeTelegramTargetId(word)) {
+        const normalized = normalizeTelegramMessagingTarget(word);
+        if (normalized) {
+          return extractRawTarget(normalized);
+        }
+      }
+    }
+    return;
+  }
+  async sendToTarget(target, text) {
+    const normalized = normalizeTelegramMessagingTarget(target);
+    if (!normalized) {
+      throw new Error(`Invalid Telegram target: ${target}`);
+    }
+    const rawTarget = extractRawTarget(normalized);
+    if (!rawTarget) {
+      throw new Error(`Failed to extract target from: ${normalized}`);
+    }
+    let chatId;
+    if (isNumericIdTarget(normalized)) {
+      chatId = parseInt(rawTarget, 10);
+    } else {
+      throw new Error(`Username targets require resolution. Use numeric chat ID instead, or implement username resolution. Target: ${rawTarget}`);
+    }
+    await this.sendMessage(chatId, text);
+  }
 }
 // src/channels/discord.ts
 var import_discord = __toESM(require_src2(), 1);

package/dist/bin/telegram-cli.js

@@ -92156,7 +92156,86 @@ var require_src2 = __commonJS((exports) => {
   __exportStar(require_dist3(), exports);
   __exportStar(require_dist11(), exports);
 });
-
+// ../channel-types/dist/plugins/registry.js
+class PluginRegistryImpl {
+  channels = new Map;
+  channelOrder = [];
+  registerChannel(registration) {
+    const id = registration.plugin.id;
+    if (typeof id !== "string") {
+      throw new Error("Channel plugin id must be a string");
+    }
+    const normalizedId = id.trim().toLowerCase();
+    if (this.channels.has(normalizedId)) {
+      console.warn(`[PluginRegistry] Channel "${normalizedId}" already registered, replacing`);
+    }
+    this.channels.set(normalizedId, registration);
+    if (!this.channelOrder.includes(normalizedId)) {
+      this.channelOrder.push(normalizedId);
+    }
+    console.log(`[PluginRegistry] Registered channel: ${normalizedId} (source: ${registration.source})`);
+  }
+  unregisterChannel(channelId) {
+    const normalizedId = channelId.trim().toLowerCase();
+    const existed = this.channels.delete(normalizedId);
+    if (existed) {
+      this.channelOrder = this.channelOrder.filter((id) => id !== normalizedId);
+    }
+    return existed;
+  }
+  getChannel(channelId) {
+    const normalizedId = this.normalizeChannelId(channelId);
+    const registration = this.channels.get(normalizedId);
+    return registration?.plugin;
+  }
+  getChannelRegistration(channelId) {
+    const normalizedId = this.normalizeChannelId(channelId);
+    return this.channels.get(normalizedId);
+  }
+  getChannels() {
+    return this.channelOrder.map((id) => this.channels.get(id)?.plugin).filter((p) => p !== undefined);
+  }
+  getChannelRegistrations() {
+    return this.channelOrder.map((id) => this.channels.get(id)).filter((r) => r !== undefined);
+  }
+  getChannelOrder() {
+    return [...this.channelOrder];
+  }
+  setChannelOrder(order) {
+    this.channelOrder = order.map((id) => id.toLowerCase().trim());
+  }
+  getChannelsByCapability(capability) {
+    return this.getChannels().filter((plugin) => plugin.capabilities.supports[capability] === true);
+  }
+  getChannelsByChatType(chatType) {
+    return this.getChannels().filter((plugin) => plugin.capabilities.chatTypes?.includes(chatType));
+  }
+  hasChannel(channelId) {
+    return this.channels.has(this.normalizeChannelId(channelId));
+  }
+  normalizeChannelId(channelId) {
+    const id = channelId.trim().toLowerCase();
+    const aliases = {
+      tg: "telegram",
+      imsg: "imessage",
+      wa: "whatsapp",
+      dc: "discord",
+      sl: "slack"
+    };
+    return aliases[id] || id;
+  }
+  clear() {
+    this.channels.clear();
+    this.channelOrder = [];
+  }
+  getStats() {
+    return {
+      channelCount: this.channels.size,
+      channels: this.getChannelOrder()
+    };
+  }
+}
+var pluginRegistry = new PluginRegistryImpl;
 // ../channel-types/dist/index.js
 function createChannelId(platform, accountId, instanceId) {
   return { platform, accountId, instanceId };
@@ -98838,6 +98917,266 @@ function registerAllCommands(bot, memory, tools) {
   registerInnerthoughtsCommand(bot, memory, tools);
   register(bot, tools);
 }
+
+// ../channel-telegram/dist/plugin.js
+var telegramMeta = {
+  label: "Telegram",
+  blurb: "Telegram Bot API for direct and group chats",
+  icon: "\uD83D\uDCF1",
+  docsPath: "/docs/channels/telegram",
+  quickstartAllowFrom: true
+};
+var telegramConfigAdapter = {
+  listAccountIds: async (config) => {
+    const botToken = config.botToken;
+    if (!botToken)
+      return [];
+    return ["default"];
+  },
+  resolveAccount: async (config, accountId) => {
+    return {
+      botToken: config.botToken,
+      allowedUsers: config.allowedUsers,
+      allowedChats: config.allowedChats,
+      pollingInterval: config.pollingInterval || 1000
+    };
+  },
+  validateAccount: async (account) => {
+    if (!account.botToken)
+      return false;
+    return true;
+  }
+};
+var createOutboundAdapter = (getBot) => ({
+  deliveryMode: "direct",
+  textChunkLimit: 4096,
+  chunker: (text, limit) => {
+    const chunks = [];
+    for (let i = 0;i < text.length; i += limit) {
+      chunks.push(text.slice(i, i + limit));
+    }
+    return { chunks, totalChunks: chunks.length };
+  },
+  sendText: async ({ to, text, accountId, account, replyToId, threadId }) => {
+    const bot = getBot();
+    if (!bot) {
+      return { success: false, error: "Bot not initialized", timestamp: new Date };
+    }
+    try {
+      const chatId = parseInt(to, 10);
+      const options = {
+        parse_mode: "Markdown"
+      };
+      if (replyToId) {
+        options.reply_to_message_id = parseInt(replyToId, 10);
+      }
+      if (threadId) {
+        options.message_thread_id = parseInt(threadId, 10);
+      }
+      const result = await bot.sendMessage(chatId, text, options);
+      return {
+        success: true,
+        messageId: result.message_id.toString(),
+        timestamp: new Date
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        timestamp: new Date
+      };
+    }
+  },
+  sendMedia: async ({ to, text, mediaUrl, mediaType, accountId, account }) => {
+    const bot = getBot();
+    if (!bot) {
+      return { success: false, error: "Bot not initialized", timestamp: new Date };
+    }
+    try {
+      const chatId = parseInt(to, 10);
+      let result;
+      if (mediaType === "image") {
+        result = await bot.sendPhoto(chatId, mediaUrl, { caption: text });
+      } else if (mediaType === "video") {
+        result = await bot.sendVideo(chatId, mediaUrl, { caption: text });
+      } else if (mediaType === "audio") {
+        result = await bot.sendAudio(chatId, mediaUrl, { caption: text });
+      } else {
+        result = await bot.sendDocument(chatId, mediaUrl, { caption: text });
+      }
+      return {
+        success: true,
+        messageId: result.message_id.toString(),
+        timestamp: new Date
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        timestamp: new Date
+      };
+    }
+  }
+});
+var telegramThreadingAdapter = {
+  replyModes: ["quote", "thread"],
+  defaultReplyMode: "quote"
+};
+var createGatewayAdapter = (createBot) => {
+  const activeBots = new Map;
+  const messageHandlers = new Map;
+  return {
+    startAccount: async ({ accountId, account, onMessage }) => {
+      const bot = createBot(account.botToken);
+      const handler = (msg) => {
+        if (account.allowedUsers?.length && !account.allowedUsers.includes(msg.from?.id || 0)) {
+          return;
+        }
+        if (account.allowedChats?.length && !account.allowedChats.includes(msg.chat.id)) {
+          return;
+        }
+        const channelId = {
+          platform: "telegram",
+          accountId: msg.chat.id.toString()
+        };
+        const channelMessage = {
+          messageId: msg.message_id.toString(),
+          channelId,
+          timestamp: new Date(msg.date * 1000),
+          sender: {
+            id: msg.from?.id.toString() || "unknown",
+            username: msg.from?.username,
+            displayName: msg.from?.first_name,
+            isBot: msg.from?.is_bot || false
+          },
+          text: msg.text || "",
+          context: {
+            isDM: msg.chat.type === "private",
+            groupName: msg.chat.title,
+            threadId: msg.message_thread_id?.toString()
+          },
+          replyTo: msg.reply_to_message ? {
+            messageId: msg.reply_to_message.message_id.toString(),
+            channelId
+          } : undefined
+        };
+        onMessage(channelMessage);
+      };
+      bot.on("message", handler);
+      activeBots.set(accountId, bot);
+      messageHandlers.set(accountId, handler);
+    },
+    stopAccount: async ({ accountId, account }) => {
+      const bot = activeBots.get(accountId);
+      const handler = messageHandlers.get(accountId);
+      if (bot && handler) {
+        bot.off("message", handler);
+        if (bot.isPolling()) {
+          await bot.stopPolling();
+        }
+        activeBots.delete(accountId);
+        messageHandlers.delete(accountId);
+      }
+    },
+    isAccountActive: (accountId) => {
+      return activeBots.has(accountId);
+    }
+  };
+};
+function createTelegramPlugin(config = {}, TelegramBotClass) {
+  let bot = null;
+  const createBot = (token) => {
+    if (!TelegramBotClass) {
+      throw new Error("TelegramBot class not provided");
+    }
+    return new TelegramBotClass(token, { polling: true });
+  };
+  return {
+    id: "telegram",
+    meta: telegramMeta,
+    capabilities: {
+      chatTypes: ["direct", "group", "channel", "thread"],
+      supports: {
+        text: true,
+        media: true,
+        replies: true,
+        threads: true,
+        reactions: true,
+        editing: true,
+        streaming: false,
+        buttons: true
+      },
+      nativeCommands: true,
+      rateLimits: {
+        messagesPerMinute: 30,
+        charactersPerMessage: 4096
+      },
+      media: {
+        maxFileSize: 50 * 1024 * 1024,
+        supportedMimeTypes: ["image/*", "video/*", "audio/*", "application/pdf"]
+      }
+    },
+    config: telegramConfigAdapter,
+    outbound: createOutboundAdapter(() => bot),
+    gateway: createGatewayAdapter((token) => {
+      bot = createBot(token);
+      return bot;
+    }),
+    threading: telegramThreadingAdapter
+  };
+}
+var telegramPlugin = createTelegramPlugin();
+if (process.env.TELEGRAM_BOT_TOKEN) {
+  pluginRegistry.registerChannel({
+    pluginId: "telegram",
+    plugin: telegramPlugin,
+    source: "core"
+  });
+}
+// ../channel-telegram/dist/utils/normalize.js
+function normalizeTelegramMessagingTarget(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return;
+  let normalized = trimmed;
+  if (normalized.startsWith("telegram:")) {
+    normalized = normalized.slice("telegram:".length).trim();
+  } else if (normalized.startsWith("tg:")) {
+    normalized = normalized.slice("tg:".length).trim();
+  }
+  if (!normalized)
+    return;
+  const tmeMatch = /^https?:\/\/t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized) ?? /^t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized);
+  if (tmeMatch?.[1]) {
+    normalized = `@${tmeMatch[1]}`;
+  }
+  if (!normalized)
+    return;
+  return `telegram:${normalized}`.toLowerCase();
+}
+function looksLikeTelegramTargetId(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return false;
+  if (/^(telegram|tg):/i.test(trimmed))
+    return true;
+  if (trimmed.startsWith("@"))
+    return true;
+  return /^-?\d{6,}$/.test(trimmed);
+}
+function extractRawTarget(normalized) {
+  const trimmed = normalized.trim();
+  if (!trimmed.startsWith("telegram:"))
+    return;
+  const raw = trimmed.slice("telegram:".length);
+  return raw || undefined;
+}
+function isNumericIdTarget(normalized) {
+  const raw = extractRawTarget(normalized);
+  if (!raw)
+    return false;
+  return /^-?\d+$/.test(raw);
+}
 // ../channel-telegram/dist/index.js
 class TelegramChannel {
   id;
@@ -99202,6 +99541,41 @@ class GLMTelegramChannel extends BaseChannel {
   isAllowed(userId, chatId) {
     return this.protocolAdapter.isAllowed(userId, chatId);
   }
+  normalizeTarget(raw) {
+    return normalizeTelegramMessagingTarget(raw);
+  }
+  isValidTarget(raw) {
+    return looksLikeTelegramTargetId(raw);
+  }
+  parseTargetFromInput(input) {
+    const words = input.split(/\s+/);
+    for (const word of words) {
+      if (looksLikeTelegramTargetId(word)) {
+        const normalized = normalizeTelegramMessagingTarget(word);
+        if (normalized) {
+          return extractRawTarget(normalized);
+        }
+      }
+    }
+    return;
+  }
+  async sendToTarget(target, text) {
+    const normalized = normalizeTelegramMessagingTarget(target);
+    if (!normalized) {
+      throw new Error(`Invalid Telegram target: ${target}`);
+    }
+    const rawTarget = extractRawTarget(normalized);
+    if (!rawTarget) {
+      throw new Error(`Failed to extract target from: ${normalized}`);
+    }
+    let chatId;
+    if (isNumericIdTarget(normalized)) {
+      chatId = parseInt(rawTarget, 10);
+    } else {
+      throw new Error(`Username targets require resolution. Use numeric chat ID instead, or implement username resolution. Target: ${rawTarget}`);
+    }
+    await this.sendMessage(chatId, text);
+  }
 }
 // src/channels/discord.ts
 var import_discord = __toESM(require_src2(), 1);

package/dist/index.js

@@ -97992,6 +97992,86 @@ class StringConversationMemory extends ConversationMemory {
     super(config);
   }
 }
+// ../channel-types/dist/plugins/registry.js
+class PluginRegistryImpl {
+  channels = new Map;
+  channelOrder = [];
+  registerChannel(registration) {
+    const id = registration.plugin.id;
+    if (typeof id !== "string") {
+      throw new Error("Channel plugin id must be a string");
+    }
+    const normalizedId = id.trim().toLowerCase();
+    if (this.channels.has(normalizedId)) {
+      console.warn(`[PluginRegistry] Channel "${normalizedId}" already registered, replacing`);
+    }
+    this.channels.set(normalizedId, registration);
+    if (!this.channelOrder.includes(normalizedId)) {
+      this.channelOrder.push(normalizedId);
+    }
+    console.log(`[PluginRegistry] Registered channel: ${normalizedId} (source: ${registration.source})`);
+  }
+  unregisterChannel(channelId) {
+    const normalizedId = channelId.trim().toLowerCase();
+    const existed = this.channels.delete(normalizedId);
+    if (existed) {
+      this.channelOrder = this.channelOrder.filter((id) => id !== normalizedId);
+    }
+    return existed;
+  }
+  getChannel(channelId) {
+    const normalizedId = this.normalizeChannelId(channelId);
+    const registration = this.channels.get(normalizedId);
+    return registration?.plugin;
+  }
+  getChannelRegistration(channelId) {
+    const normalizedId = this.normalizeChannelId(channelId);
+    return this.channels.get(normalizedId);
+  }
+  getChannels() {
+    return this.channelOrder.map((id) => this.channels.get(id)?.plugin).filter((p) => p !== undefined);
+  }
+  getChannelRegistrations() {
+    return this.channelOrder.map((id) => this.channels.get(id)).filter((r) => r !== undefined);
+  }
+  getChannelOrder() {
+    return [...this.channelOrder];
+  }
+  setChannelOrder(order) {
+    this.channelOrder = order.map((id) => id.toLowerCase().trim());
+  }
+  getChannelsByCapability(capability) {
+    return this.getChannels().filter((plugin) => plugin.capabilities.supports[capability] === true);
+  }
+  getChannelsByChatType(chatType) {
+    return this.getChannels().filter((plugin) => plugin.capabilities.chatTypes?.includes(chatType));
+  }
+  hasChannel(channelId) {
+    return this.channels.has(this.normalizeChannelId(channelId));
+  }
+  normalizeChannelId(channelId) {
+    const id = channelId.trim().toLowerCase();
+    const aliases = {
+      tg: "telegram",
+      imsg: "imessage",
+      wa: "whatsapp",
+      dc: "discord",
+      sl: "slack"
+    };
+    return aliases[id] || id;
+  }
+  clear() {
+    this.channels.clear();
+    this.channelOrder = [];
+  }
+  getStats() {
+    return {
+      channelCount: this.channels.size,
+      channels: this.getChannelOrder()
+    };
+  }
+}
+var pluginRegistry = new PluginRegistryImpl;
 // ../channel-types/dist/index.js
 function createChannelId(platform, accountId, instanceId) {
   return { platform, accountId, instanceId };
@@ -99032,6 +99112,266 @@ function registerAllCommands(bot, memory, tools) {
   registerInnerthoughtsCommand(bot, memory, tools);
   register(bot, tools);
 }
+
+// ../channel-telegram/dist/plugin.js
+var telegramMeta = {
+  label: "Telegram",
+  blurb: "Telegram Bot API for direct and group chats",
+  icon: "\uD83D\uDCF1",
+  docsPath: "/docs/channels/telegram",
+  quickstartAllowFrom: true
+};
+var telegramConfigAdapter = {
+  listAccountIds: async (config) => {
+    const botToken = config.botToken;
+    if (!botToken)
+      return [];
+    return ["default"];
+  },
+  resolveAccount: async (config, accountId) => {
+    return {
+      botToken: config.botToken,
+      allowedUsers: config.allowedUsers,
+      allowedChats: config.allowedChats,
+      pollingInterval: config.pollingInterval || 1000
+    };
+  },
+  validateAccount: async (account) => {
+    if (!account.botToken)
+      return false;
+    return true;
+  }
+};
+var createOutboundAdapter = (getBot) => ({
+  deliveryMode: "direct",
+  textChunkLimit: 4096,
+  chunker: (text, limit) => {
+    const chunks = [];
+    for (let i = 0;i < text.length; i += limit) {
+      chunks.push(text.slice(i, i + limit));
+    }
+    return { chunks, totalChunks: chunks.length };
+  },
+  sendText: async ({ to, text, accountId, account, replyToId, threadId }) => {
+    const bot = getBot();
+    if (!bot) {
+      return { success: false, error: "Bot not initialized", timestamp: new Date };
+    }
+    try {
+      const chatId = parseInt(to, 10);
+      const options = {
+        parse_mode: "Markdown"
+      };
+      if (replyToId) {
+        options.reply_to_message_id = parseInt(replyToId, 10);
+      }
+      if (threadId) {
+        options.message_thread_id = parseInt(threadId, 10);
+      }
+      const result = await bot.sendMessage(chatId, text, options);
+      return {
+        success: true,
+        messageId: result.message_id.toString(),
+        timestamp: new Date
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        timestamp: new Date
+      };
+    }
+  },
+  sendMedia: async ({ to, text, mediaUrl, mediaType, accountId, account }) => {
+    const bot = getBot();
+    if (!bot) {
+      return { success: false, error: "Bot not initialized", timestamp: new Date };
+    }
+    try {
+      const chatId = parseInt(to, 10);
+      let result;
+      if (mediaType === "image") {
+        result = await bot.sendPhoto(chatId, mediaUrl, { caption: text });
+      } else if (mediaType === "video") {
+        result = await bot.sendVideo(chatId, mediaUrl, { caption: text });
+      } else if (mediaType === "audio") {
+        result = await bot.sendAudio(chatId, mediaUrl, { caption: text });
+      } else {
+        result = await bot.sendDocument(chatId, mediaUrl, { caption: text });
+      }
+      return {
+        success: true,
+        messageId: result.message_id.toString(),
+        timestamp: new Date
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        timestamp: new Date
+      };
+    }
+  }
+});
+var telegramThreadingAdapter = {
+  replyModes: ["quote", "thread"],
+  defaultReplyMode: "quote"
+};
+var createGatewayAdapter = (createBot) => {
+  const activeBots = new Map;
+  const messageHandlers = new Map;
+  return {
+    startAccount: async ({ accountId, account, onMessage }) => {
+      const bot = createBot(account.botToken);
+      const handler = (msg) => {
+        if (account.allowedUsers?.length && !account.allowedUsers.includes(msg.from?.id || 0)) {
+          return;
+        }
+        if (account.allowedChats?.length && !account.allowedChats.includes(msg.chat.id)) {
+          return;
+        }
+        const channelId = {
+          platform: "telegram",
+          accountId: msg.chat.id.toString()
+        };
+        const channelMessage = {
+          messageId: msg.message_id.toString(),
+          channelId,
+          timestamp: new Date(msg.date * 1000),
+          sender: {
+            id: msg.from?.id.toString() || "unknown",
+            username: msg.from?.username,
+            displayName: msg.from?.first_name,
+            isBot: msg.from?.is_bot || false
+          },
+          text: msg.text || "",
+          context: {
+            isDM: msg.chat.type === "private",
+            groupName: msg.chat.title,
+            threadId: msg.message_thread_id?.toString()
+          },
+          replyTo: msg.reply_to_message ? {
+            messageId: msg.reply_to_message.message_id.toString(),
+            channelId
+          } : undefined
+        };
+        onMessage(channelMessage);
+      };
+      bot.on("message", handler);
+      activeBots.set(accountId, bot);
+      messageHandlers.set(accountId, handler);
+    },
+    stopAccount: async ({ accountId, account }) => {
+      const bot = activeBots.get(accountId);
+      const handler = messageHandlers.get(accountId);
+      if (bot && handler) {
+        bot.off("message", handler);
+        if (bot.isPolling()) {
+          await bot.stopPolling();
+        }
+        activeBots.delete(accountId);
+        messageHandlers.delete(accountId);
+      }
+    },
+    isAccountActive: (accountId) => {
+      return activeBots.has(accountId);
+    }
+  };
+};
+function createTelegramPlugin(config = {}, TelegramBotClass) {
+  let bot = null;
+  const createBot = (token) => {
+    if (!TelegramBotClass) {
+      throw new Error("TelegramBot class not provided");
+    }
+    return new TelegramBotClass(token, { polling: true });
+  };
+  return {
+    id: "telegram",
+    meta: telegramMeta,
+    capabilities: {
+      chatTypes: ["direct", "group", "channel", "thread"],
+      supports: {
+        text: true,
+        media: true,
+        replies: true,
+        threads: true,
+        reactions: true,
+        editing: true,
+        streaming: false,
+        buttons: true
+      },
+      nativeCommands: true,
+      rateLimits: {
+        messagesPerMinute: 30,
+        charactersPerMessage: 4096
+      },
+      media: {
+        maxFileSize: 50 * 1024 * 1024,
+        supportedMimeTypes: ["image/*", "video/*", "audio/*", "application/pdf"]
+      }
+    },
+    config: telegramConfigAdapter,
+    outbound: createOutboundAdapter(() => bot),
+    gateway: createGatewayAdapter((token) => {
+      bot = createBot(token);
+      return bot;
+    }),
+    threading: telegramThreadingAdapter
+  };
+}
+var telegramPlugin = createTelegramPlugin();
+if (process.env.TELEGRAM_BOT_TOKEN) {
+  pluginRegistry.registerChannel({
+    pluginId: "telegram",
+    plugin: telegramPlugin,
+    source: "core"
+  });
+}
+// ../channel-telegram/dist/utils/normalize.js
+function normalizeTelegramMessagingTarget(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return;
+  let normalized = trimmed;
+  if (normalized.startsWith("telegram:")) {
+    normalized = normalized.slice("telegram:".length).trim();
+  } else if (normalized.startsWith("tg:")) {
+    normalized = normalized.slice("tg:".length).trim();
+  }
+  if (!normalized)
+    return;
+  const tmeMatch = /^https?:\/\/t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized) ?? /^t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized);
+  if (tmeMatch?.[1]) {
+    normalized = `@${tmeMatch[1]}`;
+  }
+  if (!normalized)
+    return;
+  return `telegram:${normalized}`.toLowerCase();
+}
+function looksLikeTelegramTargetId(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return false;
+  if (/^(telegram|tg):/i.test(trimmed))
+    return true;
+  if (trimmed.startsWith("@"))
+    return true;
+  return /^-?\d{6,}$/.test(trimmed);
+}
+function extractRawTarget(normalized) {
+  const trimmed = normalized.trim();
+  if (!trimmed.startsWith("telegram:"))
+    return;
+  const raw = trimmed.slice("telegram:".length);
+  return raw || undefined;
+}
+function isNumericIdTarget(normalized) {
+  const raw = extractRawTarget(normalized);
+  if (!raw)
+    return false;
+  return /^-?\d+$/.test(raw);
+}
 // ../channel-telegram/dist/index.js
 class TelegramChannel {
   id;
@@ -99396,6 +99736,41 @@ class GLMTelegramChannel extends BaseChannel {
   isAllowed(userId, chatId) {
     return this.protocolAdapter.isAllowed(userId, chatId);
   }
+  normalizeTarget(raw) {
+    return normalizeTelegramMessagingTarget(raw);
+  }
+  isValidTarget(raw) {
+    return looksLikeTelegramTargetId(raw);
+  }
+  parseTargetFromInput(input) {
+    const words = input.split(/\s+/);
+    for (const word of words) {
+      if (looksLikeTelegramTargetId(word)) {
+        const normalized = normalizeTelegramMessagingTarget(word);
+        if (normalized) {
+          return extractRawTarget(normalized);
+        }
+      }
+    }
+    return;
+  }
+  async sendToTarget(target, text) {
+    const normalized = normalizeTelegramMessagingTarget(target);
+    if (!normalized) {
+      throw new Error(`Invalid Telegram target: ${target}`);
+    }
+    const rawTarget = extractRawTarget(normalized);
+    if (!rawTarget) {
+      throw new Error(`Failed to extract target from: ${normalized}`);
+    }
+    let chatId;
+    if (isNumericIdTarget(normalized)) {
+      chatId = parseInt(rawTarget, 10);
+    } else {
+      throw new Error(`Username targets require resolution. Use numeric chat ID instead, or implement username resolution. Target: ${rawTarget}`);
+    }
+    await this.sendMessage(chatId, text);
+  }
 }
 // src/channels/discord.ts
 var import_discord = __toESM(require_src2(), 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ebowwa/glm-daemon",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "Autonomous GLM 4.7 daemon with hooks, tools, teammates, and communication channels (Telegram, Discord)",
   "type": "module",
   "main": "./dist/index.js",
@@ -63,10 +63,10 @@
     "zod": "^4.3.5"
   },
   "devDependencies": {
-    "@types/bun": "catalog:dev",
-    "@types/node": "catalog:dev",
-    "typescript": "catalog:",
-    "bun-types": "catalog:dev"
+    "@types/bun": "latest",
+    "@types/node": "latest",
+    "typescript": "latest",
+    "bun-types": "latest"
   },
   "files": [
     "dist",

package/src/channels/telegram.ts

@@ -12,12 +12,27 @@ import {
 import {
   TelegramChannel as TelegramProtocolAdapter,
   type TelegramConfig as ProtocolConfig,
+  // Telegram target normalization utilities
+  normalizeTelegramMessagingTarget,
+  looksLikeTelegramTargetId,
+  extractRawTarget,
+  isUsernameTarget,
+  isNumericIdTarget,
 } from "@ebowwa/channel-telegram";
 import {
   BaseChannel,
   type GLMChannelConfig,
 } from "./base.js";
 
+// Re-export normalization utilities for consumers
+export {
+  normalizeTelegramMessagingTarget,
+  looksLikeTelegramTargetId,
+  extractRawTarget,
+  isUsernameTarget,
+  isNumericIdTarget,
+};
+
 // ============================================================
 // TELEGRAM CHANNEL CONFIG
 // ============================================================
@@ -163,6 +178,96 @@ export class GLMTelegramChannel extends BaseChannel {
   isAllowed(userId?: number, chatId?: number): boolean {
     return this.protocolAdapter.isAllowed(userId, chatId);
   }
+
+  // ============================================================
+  // Target Normalization Helpers
+  // ============================================================
+
+  /**
+   * Normalize a Telegram target (username, URL, or ID) to standard format.
+   *
+   * @param raw - Raw input (@username, t.me/user, 123456, etc.)
+   * @returns Normalized target or undefined if invalid
+   *
+   * @example
+   * channel.normalizeTarget("@durov")      // "telegram:@durov"
+   * channel.normalizeTarget("t.me/durov")  // "telegram:@durov"
+   * channel.normalizeTarget("123456")      // "telegram:123456"
+   */
+  normalizeTarget(raw: string): string | undefined {
+    return normalizeTelegramMessagingTarget(raw);
+  }
+
+  /**
+   * Check if a string looks like a Telegram target.
+   *
+   * @param raw - Raw input string
+   * @returns true if it looks like a Telegram target
+   */
+  isValidTarget(raw: string): boolean {
+    return looksLikeTelegramTargetId(raw);
+  }
+
+  /**
+   * Parse a target from user input and extract the usable form.
+   *
+   * @param input - User input like "send to @user" or "dm t.me/user"
+   * @returns Extracted raw target (@username or numeric ID) or undefined
+   *
+   * @example
+   * channel.parseTargetFromInput("send to @durov")  // "@durov"
+   * channel.parseTargetFromInput("dm 123456")       // "123456"
+   */
+  parseTargetFromInput(input: string): string | undefined {
+    const words = input.split(/\s+/);
+    for (const word of words) {
+      if (looksLikeTelegramTargetId(word)) {
+        const normalized = normalizeTelegramMessagingTarget(word);
+        if (normalized) {
+          return extractRawTarget(normalized);
+        }
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Send a message to a target (username or chat ID).
+   *
+   * @param target - Telegram target (@username, numeric ID, or normalized format)
+   * @param text - Message text
+   *
+   * @example
+   * await channel.sendToTarget("@durov", "Hello!")
+   * await channel.sendToTarget("123456", "Hello!")
+   */
+  async sendToTarget(target: string, text: string): Promise<void> {
+    const normalized = normalizeTelegramMessagingTarget(target);
+    if (!normalized) {
+      throw new Error(`Invalid Telegram target: ${target}`);
+    }
+
+    const rawTarget = extractRawTarget(normalized);
+    if (!rawTarget) {
+      throw new Error(`Failed to extract target from: ${normalized}`);
+    }
+
+    // Parse chat ID (numeric or resolve username)
+    let chatId: number;
+
+    if (isNumericIdTarget(normalized)) {
+      chatId = parseInt(rawTarget, 10);
+    } else {
+      // Username target - need to resolve via bot API
+      // Note: This requires the bot to have seen the user/channel before
+      // For now, we'll try direct message with username (may fail if not cached)
+      throw new Error(
+        `Username targets require resolution. Use numeric chat ID instead, or implement username resolution. Target: ${rawTarget}`
+      );
+    }
+
+    await this.sendMessage(chatId, text);
+  }
 }
 
 // ============================================================