@ebowwa/glm-daemon 0.4.6 → 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,222 @@ 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();

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,222 @@ 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();

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,222 @@ 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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ebowwa/glm-daemon",
-  "version": "0.4.6",
+  "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",