botmsg 0.1.0

package/dist/index.js

@@ -0,0 +1,2617 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/config/loader.ts
+import { readFileSync, existsSync } from "fs";
+import { extname } from "path";
+import YAML from "yaml";
+
+// src/config/schema.ts
+import { z } from "zod";
+var PlatformEnum = z.enum([
+  "dingtalk",
+  "wecom",
+  "feishu",
+  "lark",
+  "slack",
+  "discord",
+  "telegram"
+]);
+var DingTalkBotSchema = z.object({
+  platform: z.literal("dingtalk"),
+  webhook: z.string().url(),
+  secret: z.string().optional(),
+  security: z.enum(["keyword", "ip", "sign"]).default("keyword")
+});
+var WeComBotSchema = z.object({
+  platform: z.literal("wecom"),
+  webhook: z.string().url()
+});
+var FeishuBotSchema = z.object({
+  platform: z.literal("feishu"),
+  webhook: z.string().url(),
+  secret: z.string().optional()
+});
+var LarkBotSchema = z.object({
+  platform: z.literal("lark"),
+  webhook: z.string().url(),
+  secret: z.string().optional()
+});
+var SlackBotSchema = z.object({
+  platform: z.literal("slack"),
+  webhook: z.string().url()
+});
+var DiscordBotSchema = z.object({
+  platform: z.literal("discord"),
+  webhook: z.string().url(),
+  username: z.string().optional(),
+  avatar_url: z.string().url().optional()
+});
+var TelegramBotSchema = z.object({
+  platform: z.literal("telegram"),
+  token: z.string(),
+  chat_id: z.string(),
+  parse_mode: z.enum(["MarkdownV2", "HTML", ""]).default("")
+});
+var BotConfigSchema = z.discriminatedUnion("platform", [
+  DingTalkBotSchema,
+  WeComBotSchema,
+  FeishuBotSchema,
+  LarkBotSchema,
+  SlackBotSchema,
+  DiscordBotSchema,
+  TelegramBotSchema
+]);
+var SettingsSchema = z.object({
+  log_level: z.enum(["debug", "info", "warn", "error"]).default("info"),
+  audit_log: z.string().optional(),
+  max_retries: z.number().int().min(0).max(10).default(3),
+  dry_run: z.boolean().default(false)
+});
+var FullConfigSchema = z.object({
+  bots: z.record(z.string(), BotConfigSchema),
+  settings: SettingsSchema.default({})
+});
+var MessageTypeEnum = z.enum([
+  "text",
+  "markdown",
+  "link",
+  "image",
+  "card",
+  "news",
+  "file"
+]);
+var AtSchema = z.object({
+  users: z.array(z.string()).optional(),
+  mobiles: z.array(z.string()).optional(),
+  all: z.boolean().default(false)
+});
+var LinkContentSchema = z.object({
+  title: z.string(),
+  text: z.string(),
+  url: z.string().url(),
+  pic_url: z.string().url().optional()
+});
+var CardButtonSchema = z.object({
+  title: z.string(),
+  url: z.string().url()
+});
+var CardContentSchema = z.object({
+  title: z.string(),
+  text: z.string(),
+  buttons: z.array(CardButtonSchema).optional(),
+  single_button_text: z.string().optional(),
+  single_button_url: z.string().url().optional()
+});
+var NewsItemSchema = z.object({
+  title: z.string(),
+  description: z.string().optional(),
+  url: z.string().url(),
+  pic_url: z.string().url().optional()
+});
+
+// src/errors.ts
+var BotMsgError = class extends Error {
+  constructor(message, code, platform, details) {
+    super(message);
+    this.code = code;
+    this.platform = platform;
+    this.details = details;
+    this.name = "BotMsgError";
+  }
+  code;
+  platform;
+  details;
+};
+var ConfigError = class extends BotMsgError {
+  constructor(message) {
+    super(message, "CONFIG_ERROR");
+    this.name = "ConfigError";
+  }
+};
+var PlatformError = class extends BotMsgError {
+  constructor(message, platform, details) {
+    super(message, "PLATFORM_ERROR", platform, details);
+    this.name = "PlatformError";
+  }
+};
+var BotNotFoundError = class extends BotMsgError {
+  constructor(botName) {
+    super(`Bot "${botName}" not found in configuration`, "BOT_NOT_FOUND");
+    this.name = "BotNotFoundError";
+  }
+};
+
+// src/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class {
+  level;
+  constructor(level = "info") {
+    this.level = LOG_LEVELS[level];
+  }
+  setLevel(level) {
+    this.level = LOG_LEVELS[level];
+  }
+  log(level, message, ctx) {
+    if (LOG_LEVELS[level] < this.level) return;
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level: level.toUpperCase(),
+      message,
+      ...ctx
+    };
+    console.error(JSON.stringify(entry));
+  }
+  debug(message, ctx) {
+    this.log("debug", message, ctx);
+  }
+  info(message, ctx) {
+    this.log("info", message, ctx);
+  }
+  warn(message, ctx) {
+    this.log("warn", message, ctx);
+  }
+  error(message, ctx) {
+    this.log("error", message, ctx);
+  }
+};
+var logger = new Logger(
+  process.env.BOTMSG_LOG_LEVEL || "info"
+);
+
+// src/config/loader.ts
+var PLATFORM_NAMES = [
+  "dingtalk",
+  "wecom",
+  "feishu",
+  "lark",
+  "slack",
+  "discord",
+  "telegram"
+];
+function parseEnvBots() {
+  const bots = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (!key.startsWith("BOTMSG_") || !value) continue;
+    const parts = key.slice("BOTMSG_".length).split("_");
+    if (parts.length < 3) continue;
+    const platform = parts[0].toLowerCase();
+    if (!PLATFORM_NAMES.includes(platform)) continue;
+    if (["LOG", "AUDIT", "CONFIG", "DRY", "MAX"].includes(parts[0])) continue;
+    const instance = parts[1].toLowerCase();
+    const field = parts.slice(2).join("_").toLowerCase();
+    const botName = `${platform}-${instance}`;
+    if (!bots[botName]) bots[botName] = {};
+    bots[botName].platform = platform;
+    bots[botName][field] = value;
+  }
+  const result = {};
+  for (const [name, raw] of Object.entries(bots)) {
+    try {
+      const parsed = BotConfigSchema.parse(raw);
+      result[name] = parsed;
+    } catch (err) {
+      logger.warn(`Skipping invalid bot config for "${name}"`, {
+        error: err instanceof Error ? err.message : String(err),
+        raw
+      });
+    }
+  }
+  return result;
+}
+function parseEnvSettings() {
+  const settings = {};
+  if (process.env.BOTMSG_LOG_LEVEL) {
+    settings.log_level = process.env.BOTMSG_LOG_LEVEL;
+  }
+  if (process.env.BOTMSG_AUDIT_LOG) {
+    settings.audit_log = process.env.BOTMSG_AUDIT_LOG;
+  }
+  if (process.env.BOTMSG_MAX_RETRIES) {
+    settings.max_retries = parseInt(process.env.BOTMSG_MAX_RETRIES, 10);
+  }
+  if (process.env.BOTMSG_DRY_RUN) {
+    settings.dry_run = process.env.BOTMSG_DRY_RUN === "true";
+  }
+  return settings;
+}
+function loadConfigFile(filePath) {
+  if (!existsSync(filePath)) {
+    throw new ConfigError(`Config file not found: ${filePath}`);
+  }
+  const content = readFileSync(filePath, "utf-8");
+  const ext = extname(filePath).toLowerCase();
+  let raw;
+  if (ext === ".yaml" || ext === ".yml") {
+    raw = YAML.parse(content);
+  } else if (ext === ".json") {
+    raw = JSON.parse(content);
+  } else {
+    throw new ConfigError(`Unsupported config file format: ${ext}`);
+  }
+  return FullConfigSchema.parse(raw);
+}
+function loadConfig() {
+  const configPath = process.env.BOTMSG_CONFIG;
+  if (configPath) {
+    try {
+      const fileConfig = loadConfigFile(configPath);
+      logger.info(`Loaded config from file: ${configPath}`, {
+        botCount: Object.keys(fileConfig.bots).length
+      });
+      const envBots = parseEnvBots();
+      const mergedBots = { ...envBots, ...fileConfig.bots };
+      const envSettings = parseEnvSettings();
+      const mergedSettings = SettingsSchema.parse({
+        ...envSettings,
+        ...fileConfig.settings
+      });
+      return { bots: mergedBots, settings: mergedSettings };
+    } catch (err) {
+      if (err instanceof ConfigError) throw err;
+      logger.warn(`Failed to parse config file, falling back to env vars`, {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const bots = parseEnvBots();
+  const settings = SettingsSchema.parse(parseEnvSettings());
+  logger.info(`Loaded config from environment variables`, {
+    botCount: Object.keys(bots).length
+  });
+  return { bots, settings };
+}
+
+// src/platforms/dingtalk.ts
+import { createHmac } from "crypto";
+
+// src/platforms/base.ts
+var PlatformAdapter = class {
+  config;
+  botName;
+  constructor(botName, config) {
+    this.botName = botName;
+    this.config = config;
+  }
+  /**
+   * Execute HTTP POST with error handling
+   */
+  async httpPost(url, body, headers) {
+    const startTime = Date.now();
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...headers
+        },
+        body: JSON.stringify(body)
+      });
+      const text = await response.text();
+      let data;
+      try {
+        data = JSON.parse(text);
+      } catch {
+        data = text;
+      }
+      return { status: response.status, data };
+    } catch (err) {
+      const latencyMs = Date.now() - startTime;
+      throw new PlatformError(
+        `HTTP request failed: ${err instanceof Error ? err.message : String(err)}`,
+        this.platformName,
+        { latencyMs }
+      );
+    }
+  }
+  /**
+   * Generate a unique message ID for audit tracking
+   */
+  generateMessageId() {
+    const ts = Date.now().toString(36);
+    const rand = Math.random().toString(36).slice(2, 8);
+    return `msg_${ts}_${rand}`;
+  }
+  /**
+   * Wrap send with timing and result normalization
+   */
+  async withTiming(sendFn) {
+    const startTime = Date.now();
+    try {
+      const result = await sendFn();
+      return {
+        ...result,
+        platform: this.platformName,
+        bot: this.botName,
+        latencyMs: Date.now() - startTime
+      };
+    } catch (err) {
+      return {
+        success: false,
+        platform: this.platformName,
+        bot: this.botName,
+        latencyMs: Date.now() - startTime,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+};
+
+// src/platforms/dingtalk.ts
+var DingTalkAdapter = class extends PlatformAdapter {
+  get platformName() {
+    return "dingtalk";
+  }
+  get cfg() {
+    return this.config;
+  }
+  /**
+   * Build signed webhook URL if HMAC-SHA256 security is enabled
+   */
+  getSignedUrl() {
+    const { webhook, secret, security } = this.cfg;
+    if (security === "sign" && secret) {
+      const timestamp = Date.now();
+      const stringToSign = `${timestamp}
+${secret}`;
+      const hmac = createHmac("sha256", secret).update(stringToSign).digest("base64");
+      const sign = encodeURIComponent(hmac);
+      return `${webhook}&timestamp=${timestamp}&sign=${sign}`;
+    }
+    return webhook;
+  }
+  buildPayload(options) {
+    const at = this.buildAt(options.at);
+    switch (options.type) {
+      case "text":
+        return {
+          msgtype: "text",
+          text: { content: options.content },
+          ...Object.keys(at).length > 0 ? { at } : {}
+        };
+      case "markdown":
+        return {
+          msgtype: "markdown",
+          markdown: {
+            title: options.title || "Message",
+            text: options.content
+          },
+          ...Object.keys(at).length > 0 ? { at } : {}
+        };
+      case "link":
+        return {
+          msgtype: "link",
+          link: {
+            title: options.title || "Link",
+            text: options.content,
+            messageUrl: options.linkUrl || "",
+            picUrl: options.picUrl || ""
+          }
+        };
+      case "card": {
+        const hasButtons = options.buttons && options.buttons.length > 0;
+        if (hasButtons) {
+          return {
+            msgtype: "actionCard",
+            actionCard: {
+              title: options.title || "Card",
+              text: options.content,
+              btnOrientation: "0",
+              btns: options.buttons.map((btn) => ({
+                title: btn.title,
+                actionURL: btn.url
+              }))
+            }
+          };
+        }
+        return {
+          msgtype: "actionCard",
+          actionCard: {
+            title: options.title || "Card",
+            text: options.content,
+            singleTitle: options.singleButtonText || "View",
+            singleURL: options.singleButtonUrl || ""
+          }
+        };
+      }
+      case "news":
+        return {
+          msgtype: "feedCard",
+          feedCard: {
+            links: (options.newsItems || []).map((item) => ({
+              title: item.title,
+              messageURL: item.url,
+              picURL: item.picUrl || ""
+            }))
+          }
+        };
+      case "image":
+        return {
+          msgtype: "markdown",
+          markdown: {
+            title: options.title || "Image",
+            text: `![image](${options.imageUrl || options.content})`
+          }
+        };
+      case "file":
+        return {
+          msgtype: "link",
+          link: {
+            title: options.title || "File",
+            text: options.content || "A file was shared",
+            messageUrl: options.linkUrl || "",
+            picUrl: ""
+          }
+        };
+      default:
+        return {
+          msgtype: "text",
+          text: { content: options.content }
+        };
+    }
+  }
+  async send(options) {
+    return this.withTiming(async () => {
+      const url = this.getSignedUrl();
+      const payload = this.buildPayload(options);
+      const { status, data } = await this.httpPost(url, payload);
+      const result = data;
+      if (status === 200 && result.errcode === 0) {
+        return { success: true, messageId: this.generateMessageId(), raw: result };
+      }
+      return {
+        success: false,
+        error: `DingTalk error [${result.errcode}]: ${result.errmsg}`,
+        raw: result
+      };
+    });
+  }
+  async sendFile(filePath, _caption) {
+    return {
+      success: false,
+      platform: "dingtalk",
+      bot: this.botName,
+      latencyMs: 0,
+      error: "DingTalk webhook does not support file uploads. Use link type instead."
+    };
+  }
+  buildAt(at) {
+    if (!at) return {};
+    const result = {};
+    if (at.all) result.isAtAll = true;
+    if (at.mobiles && at.mobiles.length > 0) result.atMobiles = at.mobiles;
+    if (at.users && at.users.length > 0) result.atUserIds = at.users;
+    return result;
+  }
+};
+
+// src/platforms/wecom.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { createHash } from "crypto";
+var WeComAdapter = class extends PlatformAdapter {
+  get platformName() {
+    return "wecom";
+  }
+  get cfg() {
+    return this.config;
+  }
+  /**
+   * Extract the webhook key from URL for file upload
+   */
+  getWebhookKey() {
+    const url = new URL(this.cfg.webhook);
+    return url.searchParams.get("key") || "";
+  }
+  /**
+   * Upload file to get media_id (for file messages)
+   */
+  async uploadFile(filePath) {
+    const key = this.getWebhookKey();
+    const uploadUrl = `https://qyapi.weixin.qq.com/cgi-bin/webhook/upload_media?key=${key}&type=file`;
+    const fileBuffer = readFileSync2(filePath);
+    const fileName = filePath.split(/[/\\]/).pop() || "file";
+    const formData = new FormData();
+    formData.append("media", new Blob([fileBuffer]), fileName);
+    const response = await fetch(uploadUrl, {
+      method: "POST",
+      body: formData
+    });
+    const data = await response.json();
+    if (data.errcode !== 0) {
+      throw new PlatformError(
+        `WeCom file upload failed: [${data.errcode}] ${data.errmsg}`,
+        "wecom"
+      );
+    }
+    return data.media_id;
+  }
+  buildPayload(options) {
+    switch (options.type) {
+      case "text":
+        return {
+          msgtype: "text",
+          text: {
+            content: options.content,
+            ...this.buildMention(options.at)
+          }
+        };
+      case "markdown":
+        return {
+          msgtype: "markdown",
+          markdown: {
+            content: options.content
+          }
+        };
+      case "image": {
+        if (options.imageBase64) {
+          const md5 = createHash("md5").update(Buffer.from(options.imageBase64, "base64")).digest("hex");
+          return {
+            msgtype: "image",
+            image: {
+              base64: options.imageBase64,
+              md5
+            }
+          };
+        }
+        return {
+          msgtype: "news",
+          news: {
+            articles: [
+              {
+                title: options.title || "Image",
+                description: options.content || "",
+                url: options.imageUrl || options.content,
+                picurl: options.imageUrl || options.content
+              }
+            ]
+          }
+        };
+      }
+      case "link":
+        return {
+          msgtype: "news",
+          news: {
+            articles: [
+              {
+                title: options.title || "Link",
+                description: options.content,
+                url: options.linkUrl || "",
+                picurl: options.picUrl || ""
+              }
+            ]
+          }
+        };
+      case "news":
+        return {
+          msgtype: "news",
+          news: {
+            articles: (options.newsItems || []).map((item) => ({
+              title: item.title,
+              description: item.description || "",
+              url: item.url,
+              picurl: item.picUrl || ""
+            }))
+          }
+        };
+      case "file":
+        return {
+          msgtype: "file",
+          file: {
+            media_id: options.fileMediaId || ""
+          }
+        };
+      case "card":
+        return {
+          msgtype: "template_card",
+          template_card: {
+            card_type: "text_notice",
+            main_title: {
+              title: options.title || "Card"
+            },
+            emphasis_content: {
+              title: options.content.split("\n")[0] || "",
+              desc: options.content
+            },
+            jump_list: (options.buttons || []).map((btn) => ({
+              type: 1,
+              url: btn.url,
+              title: btn.title
+            })),
+            card_action: options.singleButtonUrl ? { type: 1, url: options.singleButtonUrl } : options.buttons?.[0] ? { type: 1, url: options.buttons[0].url } : void 0
+          }
+        };
+      default:
+        return {
+          msgtype: "text",
+          text: { content: options.content }
+        };
+    }
+  }
+  async send(options) {
+    return this.withTiming(async () => {
+      const payload = this.buildPayload(options);
+      const { status, data } = await this.httpPost(this.cfg.webhook, payload);
+      const result = data;
+      if (status === 200 && result.errcode === 0) {
+        return { success: true, messageId: this.generateMessageId(), raw: result };
+      }
+      return {
+        success: false,
+        error: `WeCom error [${result.errcode}]: ${result.errmsg}`,
+        raw: result
+      };
+    });
+  }
+  async sendFile(filePath, _caption) {
+    return this.withTiming(async () => {
+      try {
+        const mediaId = await this.uploadFile(filePath);
+        const payload = {
+          msgtype: "file",
+          file: { media_id: mediaId }
+        };
+        const { status, data } = await this.httpPost(this.cfg.webhook, payload);
+        const result = data;
+        if (status === 200 && result.errcode === 0) {
+          return { success: true, messageId: this.generateMessageId(), raw: result };
+        }
+        return {
+          success: false,
+          error: `WeCom send file failed: [${result.errcode}] ${result.errmsg}`,
+          raw: result
+        };
+      } catch (err) {
+        return {
+          success: false,
+          error: err instanceof Error ? err.message : String(err)
+        };
+      }
+    });
+  }
+  buildMention(at) {
+    if (!at) return {};
+    const result = {};
+    if (at.users && at.users.length > 0) {
+      result.mentioned_list = at.all ? ["@all"] : at.users;
+    } else if (at.all) {
+      result.mentioned_list = ["@all"];
+    }
+    if (at.mobiles && at.mobiles.length > 0) {
+      result.mentioned_mobile_list = at.mobiles;
+    }
+    return result;
+  }
+};
+
+// src/platforms/feishu.ts
+import { createHmac as createHmac2 } from "crypto";
+var FeishuAdapter = class extends PlatformAdapter {
+  baseUrl = "https://open.feishu.cn";
+  get platformName() {
+    return "feishu";
+  }
+  get cfg() {
+    return this.config;
+  }
+  /**
+   * Generate HMAC-SHA256 signature for Feishu
+   * Note: Feishu uses string_to_sign as KEY and empty string as DATA
+   */
+  generateSign() {
+    const { secret } = this.cfg;
+    if (!secret) return null;
+    const timestamp = Math.floor(Date.now() / 1e3).toString();
+    const stringToSign = `${timestamp}
+${secret}`;
+    const sign = createHmac2("sha256", stringToSign).update("").digest("base64");
+    return { timestamp, sign };
+  }
+  /**
+   * Add signature fields to payload if security is enabled
+   */
+  addSignature(payload) {
+    const signData = this.generateSign();
+    if (signData) {
+      payload.timestamp = signData.timestamp;
+      payload.sign = signData.sign;
+    }
+    return payload;
+  }
+  buildPayload(options) {
+    let payload;
+    switch (options.type) {
+      case "text": {
+        let textContent = options.content;
+        if (options.at) {
+          if (options.at.all) {
+            textContent += '\n<at user_id="all">\u6240\u6709\u4EBA</at>';
+          }
+          if (options.at.users) {
+            for (const userId of options.at.users) {
+              textContent += `
+<at user_id="${userId}">${userId}</at>`;
+            }
+          }
+        }
+        payload = {
+          msg_type: "text",
+          content: { text: textContent }
+        };
+        break;
+      }
+      case "markdown": {
+        payload = {
+          msg_type: "interactive",
+          card: {
+            schema: "2.0",
+            header: {
+              title: {
+                tag: "plain_text",
+                content: options.title || "Message"
+              },
+              template: "blue"
+            },
+            body: {
+              elements: [
+                {
+                  tag: "markdown",
+                  content: options.content
+                }
+              ]
+            }
+          }
+        };
+        break;
+      }
+      case "link":
+        payload = {
+          msg_type: "post",
+          content: {
+            post: {
+              zh_cn: {
+                title: options.title || "Link",
+                content: [
+                  [
+                    { tag: "text", text: options.content + "\n" },
+                    {
+                      tag: "a",
+                      text: options.linkUrl || "Open Link",
+                      href: options.linkUrl || ""
+                    }
+                  ]
+                ]
+              }
+            }
+          }
+        };
+        break;
+      case "image":
+        payload = {
+          msg_type: "image",
+          content: {
+            image_key: options.content
+            // For Feishu, content should be image_key
+          }
+        };
+        break;
+      case "card": {
+        const elements = [
+          { tag: "markdown", content: options.content }
+        ];
+        if (options.buttons && options.buttons.length > 0) {
+          elements.push({
+            tag: "action",
+            actions: options.buttons.map((btn) => ({
+              tag: "button",
+              text: { tag: "plain_text", content: btn.title },
+              type: "primary",
+              behaviors: [
+                { type: "open_url", default_url: btn.url }
+              ]
+            }))
+          });
+        }
+        payload = {
+          msg_type: "interactive",
+          card: {
+            schema: "2.0",
+            header: {
+              title: {
+                tag: "plain_text",
+                content: options.title || "Card"
+              },
+              template: "blue"
+            },
+            body: { elements }
+          }
+        };
+        break;
+      }
+      case "news": {
+        const contentRows = (options.newsItems || []).map((item) => [
+          { tag: "a", text: item.title, href: item.url }
+        ]);
+        payload = {
+          msg_type: "post",
+          content: {
+            post: {
+              zh_cn: {
+                title: options.title || "News",
+                content: contentRows
+              }
+            }
+          }
+        };
+        break;
+      }
+      case "file":
+        payload = {
+          msg_type: "text",
+          content: {
+            text: options.content || `[File: ${options.filePath || "unknown"}]`
+          }
+        };
+        break;
+      default:
+        payload = {
+          msg_type: "text",
+          content: { text: options.content }
+        };
+    }
+    return this.addSignature(payload);
+  }
+  async send(options) {
+    return this.withTiming(async () => {
+      const payload = this.buildPayload(options);
+      const { status, data } = await this.httpPost(this.cfg.webhook, payload);
+      const result = data;
+      if (status === 200 && result.code === 0) {
+        return { success: true, messageId: this.generateMessageId(), raw: result };
+      }
+      return {
+        success: false,
+        error: `Feishu error [${result.code}]: ${result.msg}`,
+        raw: result
+      };
+    });
+  }
+  async sendFile(filePath, _caption) {
+    return {
+      success: false,
+      platform: "feishu",
+      bot: this.botName,
+      latencyMs: 0,
+      error: "Feishu webhook does not support file uploads. Use image_key or share_chat instead."
+    };
+  }
+};
+
+// src/platforms/lark.ts
+var LarkAdapter = class extends FeishuAdapter {
+  baseUrl = "https://open.larksuite.com";
+  get platformName() {
+    return "lark";
+  }
+};
+
+// src/platforms/slack.ts
+var SlackAdapter = class extends PlatformAdapter {
+  get platformName() {
+    return "slack";
+  }
+  get cfg() {
+    return this.config;
+  }
+  buildPayload(options) {
+    switch (options.type) {
+      case "text":
+        return { text: options.content };
+      case "markdown": {
+        const blocks = [];
+        if (options.title) {
+          blocks.push({
+            type: "header",
+            text: { type: "plain_text", text: options.title }
+          });
+        }
+        blocks.push({
+          type: "section",
+          text: { type: "mrkdwn", text: options.content }
+        });
+        return {
+          text: options.title || options.content.slice(0, 100),
+          blocks
+        };
+      }
+      case "link": {
+        const blocks = [
+          {
+            type: "section",
+            text: {
+              type: "mrkdwn",
+              text: `*${options.title || "Link"}*
+${options.content}`
+            },
+            accessory: options.picUrl ? {
+              type: "image",
+              image_url: options.picUrl,
+              alt_text: options.title || "image"
+            } : void 0
+          }
+        ];
+        if (options.linkUrl) {
+          blocks.push({
+            type: "actions",
+            elements: [
+              {
+                type: "button",
+                text: { type: "plain_text", text: "Open Link" },
+                url: options.linkUrl
+              }
+            ]
+          });
+        }
+        return {
+          text: `${options.title || "Link"}: ${options.linkUrl || ""}`,
+          blocks
+        };
+      }
+      case "image": {
+        const imageUrl = options.imageUrl || options.content;
+        return {
+          text: options.title || "Image",
+          blocks: [
+            {
+              type: "image",
+              image_url: imageUrl,
+              alt_text: options.title || "image"
+            }
+          ]
+        };
+      }
+      case "card": {
+        const blocks = [];
+        if (options.title) {
+          blocks.push({
+            type: "header",
+            text: { type: "plain_text", text: options.title }
+          });
+        }
+        blocks.push({
+          type: "section",
+          text: { type: "mrkdwn", text: options.content }
+        });
+        if (options.buttons && options.buttons.length > 0) {
+          blocks.push({
+            type: "actions",
+            elements: options.buttons.map((btn) => ({
+              type: "button",
+              text: { type: "plain_text", text: btn.title },
+              url: btn.url
+            }))
+          });
+        }
+        return {
+          text: options.title || options.content.slice(0, 100),
+          blocks
+        };
+      }
+      case "news": {
+        const blocks = [];
+        if (options.title) {
+          blocks.push({
+            type: "header",
+            text: { type: "plain_text", text: options.title }
+          });
+        }
+        for (const item of options.newsItems || []) {
+          blocks.push({
+            type: "section",
+            text: {
+              type: "mrkdwn",
+              text: `*<${item.url}|${item.title}>*
+${item.description || ""}`
+            },
+            accessory: item.picUrl ? {
+              type: "image",
+              image_url: item.picUrl,
+              alt_text: item.title
+            } : void 0
+          });
+          blocks.push({ type: "divider" });
+        }
+        return {
+          text: options.title || "News",
+          blocks
+        };
+      }
+      case "file":
+        return {
+          text: options.content || `[File: ${options.filePath || "unknown"}]`
+        };
+      default:
+        return { text: options.content };
+    }
+  }
+  async send(options) {
+    return this.withTiming(async () => {
+      const payload = this.buildPayload(options);
+      const { status, data } = await this.httpPost(this.cfg.webhook, payload);
+      if (status === 200) {
+        return { success: true, messageId: this.generateMessageId(), raw: data };
+      }
+      return {
+        success: false,
+        error: `Slack error [${status}]: ${typeof data === "string" ? data : JSON.stringify(data)}`,
+        raw: data
+      };
+    });
+  }
+  async sendFile(filePath, _caption) {
+    return {
+      success: false,
+      platform: "slack",
+      bot: this.botName,
+      latencyMs: 0,
+      error: "Slack incoming webhooks do not support file uploads."
+    };
+  }
+};
+
+// src/platforms/discord.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { basename } from "path";
+var DiscordAdapter = class extends PlatformAdapter {
+  get platformName() {
+    return "discord";
+  }
+  get cfg() {
+    return this.config;
+  }
+  /**
+   * Build common fields for all payloads
+   */
+  getBasePayload() {
+    const base = {};
+    if (this.cfg.username) base.username = this.cfg.username;
+    if (this.cfg.avatar_url) base.avatar_url = this.cfg.avatar_url;
+    return base;
+  }
+  buildPayload(options) {
+    const base = this.getBasePayload();
+    switch (options.type) {
+      case "text":
+        return { ...base, content: options.content };
+      case "markdown":
+      case "link": {
+        const embed = {
+          description: options.content,
+          color: 3447003
+          // Blue
+        };
+        if (options.title) embed.title = options.title;
+        if (options.linkUrl) embed.url = options.linkUrl;
+        if (options.picUrl) embed.thumbnail = { url: options.picUrl };
+        embed.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        return { ...base, embeds: [embed] };
+      }
+      case "image": {
+        const imageUrl = options.imageUrl || options.content;
+        return {
+          ...base,
+          embeds: [
+            {
+              title: options.title || "Image",
+              image: { url: imageUrl },
+              color: 3447003
+            }
+          ]
+        };
+      }
+      case "card": {
+        const embed = {
+          title: options.title || "Card",
+          description: options.content,
+          color: 3447003,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        if (options.buttons && options.buttons.length > 0) {
+          return {
+            ...base,
+            embeds: [embed],
+            components: [
+              {
+                type: 1,
+                components: options.buttons.map((btn) => ({
+                  type: 2,
+                  style: 5,
+                  label: btn.title,
+                  url: btn.url
+                }))
+              }
+            ]
+          };
+        }
+        return { ...base, embeds: [embed] };
+      }
+      case "news": {
+        const embeds = (options.newsItems || []).map((item) => ({
+          title: item.title,
+          description: item.description || "",
+          url: item.url,
+          thumbnail: item.picUrl ? { url: item.picUrl } : void 0,
+          color: 3447003
+        }));
+        return { ...base, embeds: embeds.slice(0, 10) };
+      }
+      case "file":
+        return {
+          ...base,
+          content: options.content || `[File: ${options.filePath || "unknown"}]`
+        };
+      default:
+        return { ...base, content: options.content };
+    }
+  }
+  async send(options) {
+    return this.withTiming(async () => {
+      const payload = this.buildPayload(options);
+      const { status, data } = await this.httpPost(this.cfg.webhook, payload);
+      if (status === 204 || status === 200) {
+        return { success: true, messageId: this.generateMessageId(), raw: data };
+      }
+      const result = data;
+      return {
+        success: false,
+        error: `Discord error [${result.code || status}]: ${result.message || JSON.stringify(data)}`,
+        raw: result
+      };
+    });
+  }
+  async sendFile(filePath, caption) {
+    return this.withTiming(async () => {
+      try {
+        const fileBuffer = readFileSync3(filePath);
+        const fileName = basename(filePath);
+        const formData = new FormData();
+        const payloadJson = {
+          ...this.getBasePayload(),
+          content: caption || ""
+        };
+        formData.append("payload_json", JSON.stringify(payloadJson));
+        formData.append("files[0]", new Blob([fileBuffer]), fileName);
+        const response = await fetch(this.cfg.webhook, {
+          method: "POST",
+          body: formData
+        });
+        if (response.status === 204 || response.status === 200) {
+          return {
+            success: true,
+            messageId: this.generateMessageId(),
+            raw: await response.text()
+          };
+        }
+        const errorData = await response.json().catch(() => response.statusText);
+        return {
+          success: false,
+          error: `Discord file upload failed [${response.status}]: ${JSON.stringify(errorData)}`
+        };
+      } catch (err) {
+        return {
+          success: false,
+          error: err instanceof Error ? err.message : String(err)
+        };
+      }
+    });
+  }
+};
+
+// src/platforms/telegram.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { basename as basename2 } from "path";
+var TelegramAdapter = class extends PlatformAdapter {
+  get platformName() {
+    return "telegram";
+  }
+  get cfg() {
+    return this.config;
+  }
+  get apiBase() {
+    return `https://api.telegram.org/bot${this.cfg.token}`;
+  }
+  /**
+   * Escape special characters for MarkdownV2
+   */
+  escapeMarkdownV2(text) {
+    if (this.cfg.parse_mode !== "MarkdownV2") return text;
+    return text.replace(/([_*\[\]()~`>#+\-=|{}.!\\])/g, "\\$1");
+  }
+  buildPayload(options) {
+    const basePayload = {
+      chat_id: this.cfg.chat_id
+    };
+    if (this.cfg.parse_mode) {
+      basePayload.parse_mode = this.cfg.parse_mode;
+    }
+    switch (options.type) {
+      case "text":
+        return {
+          ...basePayload,
+          text: options.content
+        };
+      case "markdown":
+        return {
+          ...basePayload,
+          parse_mode: this.cfg.parse_mode || "MarkdownV2",
+          text: options.content
+        };
+      case "link": {
+        const text = options.title ? `[${options.title}](${options.linkUrl})
+${options.content}` : `${options.content}
+${options.linkUrl}`;
+        return {
+          ...basePayload,
+          parse_mode: "MarkdownV2",
+          text: this.escapeMarkdownV2(options.content) + (options.linkUrl ? `
+[Open Link](${options.linkUrl})` : "")
+        };
+      }
+      case "image":
+        return {
+          chat_id: this.cfg.chat_id,
+          photo: options.imageUrl || options.content,
+          caption: options.title || "",
+          ...this.cfg.parse_mode ? { parse_mode: this.cfg.parse_mode } : {}
+        };
+      case "card": {
+        const inlineKeyboard = (options.buttons || []).map((btn) => [
+          { text: btn.title, url: btn.url }
+        ]);
+        const payload = {
+          ...basePayload,
+          text: options.title ? `*${options.title}*
+${options.content}` : options.content
+        };
+        if (inlineKeyboard.length > 0) {
+          payload.reply_markup = { inline_keyboard: inlineKeyboard };
+        }
+        return payload;
+      }
+      case "news": {
+        const lines = (options.newsItems || []).map(
+          (item, i) => `${i + 1}. [${item.title}](${item.url})${item.description ? `
+   ${item.description}` : ""}`
+        );
+        return {
+          ...basePayload,
+          parse_mode: "MarkdownV2",
+          text: (options.title ? `*${this.escapeMarkdownV2(options.title)}*
+` : "") + this.escapeMarkdownV2(lines.join("\n"))
+        };
+      }
+      case "file":
+        return {
+          chat_id: this.cfg.chat_id,
+          document: options.content || options.linkUrl || "",
+          caption: options.title || ""
+        };
+      default:
+        return { ...basePayload, text: options.content };
+    }
+  }
+  /**
+   * Determine the correct Telegram API method based on message type
+   */
+  getApiMethod(type) {
+    switch (type) {
+      case "image":
+        return "sendPhoto";
+      case "file":
+        return "sendDocument";
+      default:
+        return "sendMessage";
+    }
+  }
+  async send(options) {
+    return this.withTiming(async () => {
+      const method = this.getApiMethod(options.type);
+      const url = `${this.apiBase}/${method}`;
+      const payload = this.buildPayload(options);
+      const { status, data } = await this.httpPost(url, payload);
+      const result = data;
+      if (status === 200 && result.ok === true) {
+        const messageData = result.result;
+        return {
+          success: true,
+          messageId: messageData?.message_id ? String(messageData.message_id) : this.generateMessageId(),
+          raw: result
+        };
+      }
+      return {
+        success: false,
+        error: `Telegram error [${result.error_code}]: ${result.description}`,
+        raw: result
+      };
+    });
+  }
+  async sendFile(filePath, caption) {
+    return this.withTiming(async () => {
+      try {
+        const url = `${this.apiBase}/sendDocument`;
+        const fileBuffer = readFileSync4(filePath);
+        const fileName = basename2(filePath);
+        const formData = new FormData();
+        formData.append("chat_id", this.cfg.chat_id);
+        formData.append("document", new Blob([fileBuffer]), fileName);
+        if (caption) formData.append("caption", caption);
+        if (this.cfg.parse_mode) formData.append("parse_mode", this.cfg.parse_mode);
+        const response = await fetch(url, {
+          method: "POST",
+          body: formData
+        });
+        const data = await response.json();
+        if (response.status === 200 && data.ok === true) {
+          return {
+            success: true,
+            messageId: String(data.result?.message_id || ""),
+            raw: data
+          };
+        }
+        return {
+          success: false,
+          error: `Telegram file upload failed [${data.error_code}]: ${data.description}`,
+          raw: data
+        };
+      } catch (err) {
+        return {
+          success: false,
+          error: err instanceof Error ? err.message : String(err)
+        };
+      }
+    });
+  }
+};
+
+// src/platforms/registry.ts
+var PlatformRegistry = class {
+  bots = /* @__PURE__ */ new Map();
+  /**
+   * Initialize registry from full config
+   */
+  loadConfig(config) {
+    for (const [name, botConfig] of Object.entries(config.bots)) {
+      this.register(name, botConfig);
+    }
+    logger.info(`Registry loaded: ${this.bots.size} bot(s) registered`);
+  }
+  /**
+   * Register a single bot
+   */
+  register(name, config) {
+    const adapter = this.createAdapter(name, config);
+    this.bots.set(name, adapter);
+    logger.debug(`Registered bot: ${name} (${config.platform})`);
+  }
+  /**
+   * Get a bot adapter by name
+   */
+  get(name) {
+    const adapter = this.bots.get(name);
+    if (!adapter) throw new BotNotFoundError(name);
+    return adapter;
+  }
+  /**
+   * Check if a bot exists
+   */
+  has(name) {
+    return this.bots.has(name);
+  }
+  /**
+   * List all registered bots
+   */
+  list() {
+    return Array.from(this.bots.entries()).map(([name, adapter]) => ({
+      name,
+      platform: adapter.platformName,
+      enabled: true
+    }));
+  }
+  /**
+   * Get all adapter instances
+   */
+  getAll() {
+    return Array.from(this.bots.values());
+  }
+  /**
+   * Get adapters by bot names
+   */
+  getMany(names) {
+    return names.map((name) => this.get(name));
+  }
+  createAdapter(name, config) {
+    switch (config.platform) {
+      case "dingtalk":
+        return new DingTalkAdapter(name, config);
+      case "wecom":
+        return new WeComAdapter(name, config);
+      case "feishu":
+        return new FeishuAdapter(name, config);
+      case "lark":
+        return new LarkAdapter(name, config);
+      case "slack":
+        return new SlackAdapter(name, config);
+      case "discord":
+        return new DiscordAdapter(name, config);
+      case "telegram":
+        return new TelegramAdapter(name, config);
+      default:
+        throw new Error(`Unsupported platform: ${config.platform}`);
+    }
+  }
+};
+
+// src/queue/rate-limiter.ts
+import Bottleneck from "bottleneck";
+var PLATFORM_LIMITS = {
+  dingtalk: {
+    reservoir: 18,
+    // Leave margin below 20/min
+    reservoirRefreshAmount: 18,
+    reservoirRefreshInterval: 6e4,
+    // per minute
+    maxConcurrent: 3,
+    minTime: 3e3,
+    // ~20/min spacing
+    highWater: 50,
+    strategy: Bottleneck.strategy.LEAK
+  },
+  wecom: {
+    reservoir: 18,
+    reservoirRefreshAmount: 18,
+    reservoirRefreshInterval: 6e4,
+    maxConcurrent: 3,
+    minTime: 3e3,
+    highWater: 50,
+    strategy: Bottleneck.strategy.LEAK
+  },
+  feishu: {
+    reservoir: 90,
+    // Leave margin below 100/min
+    reservoirRefreshAmount: 90,
+    reservoirRefreshInterval: 6e4,
+    maxConcurrent: 4,
+    minTime: 250,
+    // ~5/sec = 200ms spacing + margin
+    highWater: 200,
+    strategy: Bottleneck.strategy.LEAK
+  },
+  lark: {
+    reservoir: 90,
+    reservoirRefreshAmount: 90,
+    reservoirRefreshInterval: 6e4,
+    maxConcurrent: 4,
+    minTime: 250,
+    highWater: 200,
+    strategy: Bottleneck.strategy.LEAK
+  },
+  slack: {
+    reservoir: 55,
+    // ~1/sec with margin
+    reservoirRefreshAmount: 55,
+    reservoirRefreshInterval: 6e4,
+    maxConcurrent: 1,
+    minTime: 1100,
+    // 1.1s between messages
+    highWater: 100,
+    strategy: Bottleneck.strategy.LEAK
+  },
+  discord: {
+    reservoir: 4,
+    // Leave margin below 5/2sec
+    reservoirRefreshAmount: 4,
+    reservoirRefreshInterval: 2e3,
+    maxConcurrent: 2,
+    minTime: 500,
+    highWater: 50,
+    strategy: Bottleneck.strategy.LEAK
+  },
+  telegram: {
+    reservoir: 25,
+    // Leave margin below 30/sec
+    reservoirRefreshAmount: 25,
+    reservoirRefreshInterval: 1e3,
+    maxConcurrent: 5,
+    minTime: 40,
+    // ~25/sec
+    highWater: 100,
+    strategy: Bottleneck.strategy.LEAK
+  }
+};
+var RETRYABLE_PATTERNS = [
+  "429",
+  "500",
+  "502",
+  "503",
+  "504",
+  "ECONNRESET",
+  "ETIMEDOUT",
+  "ENOTFOUND",
+  "RATE_LIMIT",
+  "Too Many Requests"
+];
+var RateLimiterManager = class {
+  limiters = /* @__PURE__ */ new Map();
+  maxRetries;
+  retryMultiplier;
+  maxRetryDelayMs;
+  constructor(options = {}) {
+    this.maxRetries = options.maxRetries ?? 3;
+    this.retryMultiplier = options.retryMultiplier ?? 2;
+    this.maxRetryDelayMs = options.maxRetryDelayMs ?? 3e4;
+  }
+  /**
+   * Get or create a Bottleneck limiter for a specific bot
+   */
+  getLimiter(botName, platform) {
+    if (this.limiters.has(botName)) {
+      return this.limiters.get(botName);
+    }
+    const platformConfig = PLATFORM_LIMITS[platform] || PLATFORM_LIMITS.telegram;
+    const limiter = new Bottleneck({
+      ...platformConfig,
+      maxExecutionTime: 3e4
+      // 30s timeout per request
+    });
+    limiter.on("failed", async (error, jobInfo) => {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const shouldRetry = RETRYABLE_PATTERNS.some(
+        (pattern) => errorMessage.includes(pattern)
+      );
+      if (shouldRetry && jobInfo.retryCount < this.maxRetries) {
+        const delay = Math.min(
+          Math.pow(this.retryMultiplier, jobInfo.retryCount) * 1e3,
+          this.maxRetryDelayMs
+        );
+        logger.warn(`Retry #${jobInfo.retryCount + 1} for ${botName} after ${delay}ms`, {
+          error: errorMessage
+        });
+        return delay;
+      }
+      logger.error(`Max retries exceeded for ${botName}`, {
+        attempts: jobInfo.retryCount + 1,
+        error: errorMessage
+      });
+    });
+    this.limiters.set(botName, limiter);
+    logger.debug(`Created rate limiter for bot: ${botName} (${platform})`);
+    return limiter;
+  }
+  /**
+   * Schedule a task through a bot's rate limiter
+   */
+  async schedule(botName, platform, fn) {
+    const limiter = this.getLimiter(botName, platform);
+    return limiter.schedule(fn);
+  }
+  /**
+   * Get queue stats for a specific bot
+   */
+  getStats(botName) {
+    const limiter = this.limiters.get(botName);
+    if (!limiter) return null;
+    const counts = limiter.counts();
+    return {
+      queued: counts.EXECUTING + counts.QUEUED,
+      running: counts.RUNNING
+    };
+  }
+  /**
+   * Disconnect all limiters (graceful shutdown)
+   */
+  async disconnect() {
+    const promises = Array.from(this.limiters.values()).map(
+      (limiter) => limiter.disconnect()
+    );
+    await Promise.all(promises);
+    this.limiters.clear();
+    logger.info("All rate limiters disconnected");
+  }
+};
+
+// src/audit/logger.ts
+import { appendFileSync, existsSync as existsSync2, mkdirSync } from "fs";
+import { dirname } from "path";
+var AuditLogger = class {
+  entries = [];
+  maxSize;
+  filePath;
+  constructor(options = {}) {
+    this.maxSize = options.maxSize ?? 1e3;
+    this.filePath = options.filePath;
+    if (this.filePath) {
+      const dir = dirname(this.filePath);
+      if (!existsSync2(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+    }
+  }
+  /**
+   * Record a message send event
+   */
+  log(entry) {
+    this.entries.push(entry);
+    if (this.entries.length > this.maxSize) {
+      this.entries.shift();
+    }
+    if (this.filePath) {
+      try {
+        appendFileSync(this.filePath, JSON.stringify(entry) + "\n", "utf-8");
+      } catch (err) {
+        logger.warn("Failed to write audit log", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    logger.debug("Audit log entry", {
+      id: entry.id,
+      bot: entry.bot,
+      platform: entry.platform,
+      status: entry.status
+    });
+  }
+  /**
+   * Query audit entries with filters
+   */
+  query(filters = {}) {
+    let results = [...this.entries];
+    if (filters.messageId) {
+      results = results.filter((e) => e.messageId === filters.messageId);
+    }
+    if (filters.bot) {
+      results = results.filter((e) => e.bot === filters.bot);
+    }
+    if (filters.platform) {
+      results = results.filter((e) => e.platform === filters.platform);
+    }
+    if (filters.status) {
+      results = results.filter((e) => e.status === filters.status);
+    }
+    if (filters.since) {
+      const sinceTime = new Date(filters.since).getTime();
+      results = results.filter(
+        (e) => new Date(e.timestamp).getTime() >= sinceTime
+      );
+    }
+    if (filters.until) {
+      const untilTime = new Date(filters.until).getTime();
+      results = results.filter(
+        (e) => new Date(e.timestamp).getTime() <= untilTime
+      );
+    }
+    const limit = filters.limit ?? 50;
+    return results.slice(-limit);
+  }
+  /**
+   * Get summary statistics
+   */
+  stats() {
+    const byPlatform = {};
+    const byBot = {};
+    let success = 0;
+    let failed = 0;
+    for (const entry of this.entries) {
+      if (entry.status === "success") success++;
+      else if (entry.status === "failed") failed++;
+      byPlatform[entry.platform] = (byPlatform[entry.platform] || 0) + 1;
+      byBot[entry.bot] = (byBot[entry.bot] || 0) + 1;
+    }
+    return {
+      total: this.entries.length,
+      success,
+      failed,
+      byPlatform,
+      byBot
+    };
+  }
+  /**
+   * Find entry by audit ID
+   */
+  findById(id) {
+    return this.entries.find((e) => e.id === id);
+  }
+  /**
+   * Find entry by message ID
+   */
+  findByMessageId(messageId) {
+    return this.entries.find((e) => e.messageId === messageId);
+  }
+  /**
+   * Clear all in-memory entries
+   */
+  clear() {
+    this.entries = [];
+  }
+};
+function hashContent(content, maxLen = 32) {
+  if (content.length <= maxLen) return content;
+  return content.slice(0, maxLen) + "...";
+}
+
+// src/templates/engine.ts
+import Handlebars from "handlebars";
+var TemplateEngine = class {
+  compiled = /* @__PURE__ */ new Map();
+  hb;
+  constructor() {
+    this.hb = Handlebars.create();
+    this.registerHelpers();
+  }
+  registerHelpers() {
+    this.hb.registerHelper("date", (dateStr, format) => {
+      const d = new Date(dateStr);
+      if (isNaN(d.getTime())) return dateStr;
+      if (format === "iso") return d.toISOString();
+      if (format === "locale") return d.toLocaleString("zh-CN");
+      const pad = (n) => n.toString().padStart(2, "0");
+      return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+    });
+    this.hb.registerHelper(
+      "uppercase",
+      (str) => typeof str === "string" ? str.toUpperCase() : str
+    );
+    this.hb.registerHelper(
+      "lowercase",
+      (str) => typeof str === "string" ? str.toLowerCase() : str
+    );
+    this.hb.registerHelper(
+      "capitalize",
+      (str) => typeof str === "string" ? str.charAt(0).toUpperCase() + str.slice(1) : str
+    );
+    this.hb.registerHelper(
+      "truncate",
+      (str, maxLen, suffix) => {
+        if (typeof str !== "string") return str;
+        const limit = typeof maxLen === "number" ? maxLen : 100;
+        const end = typeof suffix === "string" ? suffix : "...";
+        return str.length > limit ? str.slice(0, limit) + end : str;
+      }
+    );
+    this.hb.registerHelper(
+      "if_eq",
+      function(a, b, options) {
+        return a === b ? options.fn(this) : options.inverse(this);
+      }
+    );
+    this.hb.registerHelper("json", (obj, indent) => {
+      const spaces = typeof indent === "number" ? indent : 2;
+      return JSON.stringify(obj, null, spaces);
+    });
+    this.hb.registerHelper("now", (format) => {
+      const now = /* @__PURE__ */ new Date();
+      if (format === "iso") return now.toISOString();
+      if (format === "timestamp") return Math.floor(now.getTime() / 1e3).toString();
+      const pad = (n) => n.toString().padStart(2, "0");
+      return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+    });
+    this.hb.registerHelper(
+      "if_gt",
+      function(a, b, options) {
+        return a > b ? options.fn(this) : options.inverse(this);
+      }
+    );
+    this.hb.registerHelper("join", (arr, separator) => {
+      if (!Array.isArray(arr)) return String(arr || "");
+      const sep = typeof separator === "string" ? separator : ", ";
+      return arr.join(sep);
+    });
+  }
+  /**
+   * Register a partial template for reuse
+   */
+  registerPartial(name, template) {
+    this.hb.registerPartial(name, template);
+  }
+  /**
+   * Compile and cache a template string
+   */
+  compile(templateStr, name) {
+    if (name && this.compiled.has(name)) {
+      return this.compiled.get(name);
+    }
+    const compiled = this.hb.compile(templateStr, { noEscape: true });
+    if (name) this.compiled.set(name, compiled);
+    return compiled;
+  }
+  /**
+   * Render a template string with variables
+   */
+  render(templateStr, variables = {}) {
+    const template = this.compile(templateStr);
+    return template(variables);
+  }
+  /**
+   * Check if a string contains template expressions
+   */
+  hasExpressions(templateStr) {
+    return /\{\{[^}]+\}\}/.test(templateStr);
+  }
+  /**
+   * Extract variable names from a template string
+   */
+  extractVariables(templateStr) {
+    const matches = templateStr.match(/\{\{([^}]+)\}\}/g);
+    if (!matches) return [];
+    return [...new Set(matches.map((m) => m.replace(/\{\{|\}\}/g, "").trim()))];
+  }
+  /**
+   * Clear the compiled template cache
+   */
+  clearCache() {
+    this.compiled.clear();
+  }
+};
+var templateEngine = new TemplateEngine();
+
+// src/tools/send-message.ts
+function createSendMessageHandler(registry, rateLimiter, auditLogger, dryRun) {
+  return async (args) => {
+    const adapter = registry.get(args.bot);
+    let content = args.content;
+    if (args.variables && templateEngine.hasExpressions(content)) {
+      content = templateEngine.render(content, args.variables);
+    }
+    let title = args.title;
+    if (title && args.variables && templateEngine.hasExpressions(title)) {
+      title = templateEngine.render(title, args.variables);
+    }
+    const sendOptions = {
+      type: args.type,
+      content,
+      title,
+      at: args.at,
+      linkUrl: args.link_url,
+      picUrl: args.pic_url,
+      buttons: args.buttons,
+      singleButtonText: args.single_button_text,
+      singleButtonUrl: args.single_button_url,
+      newsItems: args.news_items,
+      imageUrl: args.image_url,
+      imageBase64: args.image_base64
+    };
+    if (dryRun) {
+      const payload = adapter.buildPayload(sendOptions);
+      const auditId2 = `dry_${Date.now().toString(36)}`;
+      auditLogger.log({
+        id: auditId2,
+        bot: args.bot,
+        platform: adapter.platformName,
+        type: args.type,
+        contentHash: hashContent(content),
+        status: "success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        latencyMs: 0
+      });
+      return {
+        dry_run: true,
+        bot: args.bot,
+        platform: adapter.platformName,
+        payload,
+        rendered_content: content,
+        audit_id: auditId2
+      };
+    }
+    const platform = adapter.platformName;
+    const result = await rateLimiter.schedule(
+      args.bot,
+      platform,
+      () => adapter.send(sendOptions)
+    );
+    const auditId = result.messageId || `msg_${Date.now().toString(36)}`;
+    auditLogger.log({
+      id: auditId,
+      messageId: result.messageId,
+      bot: args.bot,
+      platform: result.platform,
+      type: args.type,
+      contentHash: hashContent(content),
+      status: result.success ? "success" : "failed",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      latencyMs: result.latencyMs,
+      error: result.error
+    });
+    return {
+      success: result.success,
+      bot: args.bot,
+      platform: result.platform,
+      message_id: result.messageId,
+      latency_ms: result.latencyMs,
+      error: result.error,
+      audit_id: auditId
+    };
+  };
+}
+
+// src/tools/send-file.ts
+function createSendFileHandler(registry, rateLimiter, auditLogger, dryRun) {
+  return async (args) => {
+    const adapter = registry.get(args.bot);
+    if (dryRun) {
+      const auditId2 = `dry_${Date.now().toString(36)}`;
+      auditLogger.log({
+        id: auditId2,
+        bot: args.bot,
+        platform: adapter.platformName,
+        type: "file",
+        contentHash: hashContent(args.file_path),
+        status: "success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        latencyMs: 0
+      });
+      return {
+        dry_run: true,
+        bot: args.bot,
+        platform: adapter.platformName,
+        file_path: args.file_path,
+        audit_id: auditId2
+      };
+    }
+    const platform = adapter.platformName;
+    const result = await rateLimiter.schedule(
+      args.bot,
+      platform,
+      () => adapter.sendFile(args.file_path, args.caption)
+    );
+    const auditId = result.messageId || `msg_${Date.now().toString(36)}`;
+    auditLogger.log({
+      id: auditId,
+      messageId: result.messageId,
+      bot: args.bot,
+      platform: result.platform,
+      type: "file",
+      contentHash: hashContent(args.file_path),
+      status: result.success ? "success" : "failed",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      latencyMs: result.latencyMs,
+      error: result.error
+    });
+    return {
+      success: result.success,
+      bot: args.bot,
+      platform: result.platform,
+      message_id: result.messageId,
+      latency_ms: result.latencyMs,
+      error: result.error,
+      audit_id: auditId
+    };
+  };
+}
+
+// src/tools/send-broadcast.ts
+function createSendBroadcastHandler(registry, rateLimiter, auditLogger, dryRun) {
+  return async (args) => {
+    let content = args.content;
+    if (args.variables && templateEngine.hasExpressions(content)) {
+      content = templateEngine.render(content, args.variables);
+    }
+    let title = args.title;
+    if (title && args.variables && templateEngine.hasExpressions(title)) {
+      title = templateEngine.render(title, args.variables);
+    }
+    const sendOptions = {
+      type: args.type,
+      content,
+      title,
+      at: args.at,
+      linkUrl: args.link_url,
+      picUrl: args.pic_url,
+      buttons: args.buttons,
+      newsItems: args.news_items,
+      imageUrl: args.image_url
+    };
+    const results = await Promise.allSettled(
+      args.bots.map(async (botName) => {
+        const adapter = registry.get(botName);
+        const platform = adapter.platformName;
+        if (dryRun) {
+          return {
+            bot: botName,
+            platform: adapter.platformName,
+            dry_run: true,
+            payload: adapter.buildPayload(sendOptions)
+          };
+        }
+        const result = await rateLimiter.schedule(
+          botName,
+          platform,
+          () => adapter.send(sendOptions)
+        );
+        const auditId = result.messageId || `msg_${Date.now().toString(36)}`;
+        auditLogger.log({
+          id: auditId,
+          messageId: result.messageId,
+          bot: botName,
+          platform: result.platform,
+          type: args.type,
+          contentHash: hashContent(content),
+          status: result.success ? "success" : "failed",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          latencyMs: result.latencyMs,
+          error: result.error
+        });
+        return {
+          bot: botName,
+          success: result.success,
+          platform: result.platform,
+          message_id: result.messageId,
+          latency_ms: result.latencyMs,
+          error: result.error,
+          audit_id: auditId
+        };
+      })
+    );
+    const outcomes = results.map((r, i) => {
+      if (r.status === "fulfilled") return r.value;
+      return {
+        bot: args.bots[i],
+        success: false,
+        error: r.reason instanceof Error ? r.reason.message : String(r.reason)
+      };
+    });
+    const successCount = outcomes.filter((o) => o.success || o.dry_run).length;
+    const failCount = outcomes.length - successCount;
+    return {
+      total: outcomes.length,
+      success: successCount,
+      failed: failCount,
+      results: outcomes
+    };
+  };
+}
+
+// src/tools/send-batch.ts
+function createSendBatchHandler(registry, rateLimiter, auditLogger, dryRun) {
+  return async (args) => {
+    const adapter = registry.get(args.bot);
+    let content = args.content;
+    if (args.variables && templateEngine.hasExpressions(content)) {
+      content = templateEngine.render(content, args.variables);
+    }
+    const sendOptions = {
+      type: args.type,
+      content,
+      title: args.title,
+      at: args.at,
+      linkUrl: args.link_url,
+      picUrl: args.pic_url,
+      buttons: args.buttons,
+      newsItems: args.news_items,
+      imageUrl: args.image_url
+    };
+    const results = await Promise.allSettled(
+      args.targets.map(async (target) => {
+        if (dryRun) {
+          return {
+            target,
+            dry_run: true,
+            platform: adapter.platformName
+          };
+        }
+        const platform = adapter.platformName;
+        const result = await rateLimiter.schedule(
+          args.bot,
+          platform,
+          () => adapter.send(sendOptions)
+        );
+        const auditId = result.messageId || `msg_${Date.now().toString(36)}`;
+        auditLogger.log({
+          id: auditId,
+          messageId: result.messageId,
+          bot: args.bot,
+          platform: result.platform,
+          type: args.type,
+          contentHash: hashContent(content),
+          status: result.success ? "success" : "failed",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          latencyMs: result.latencyMs,
+          target,
+          error: result.error
+        });
+        return {
+          target,
+          success: result.success,
+          message_id: result.messageId,
+          latency_ms: result.latencyMs,
+          error: result.error,
+          audit_id: auditId
+        };
+      })
+    );
+    const outcomes = results.map((r, i) => {
+      if (r.status === "fulfilled") return r.value;
+      return {
+        target: args.targets[i],
+        success: false,
+        error: r.reason instanceof Error ? r.reason.message : String(r.reason)
+      };
+    });
+    const successCount = outcomes.filter((o) => o.success || o.dry_run).length;
+    return {
+      bot: args.bot,
+      total: outcomes.length,
+      success: successCount,
+      failed: outcomes.length - successCount,
+      results: outcomes
+    };
+  };
+}
+
+// src/tools/list-bots.ts
+function createListBotsHandler(registry, rateLimiter) {
+  return async () => {
+    const bots = registry.list();
+    const detailed = bots.map((bot) => {
+      const queueStats = rateLimiter.getStats(bot.name);
+      return {
+        name: bot.name,
+        platform: bot.platform,
+        enabled: bot.enabled,
+        queue: queueStats || { queued: 0, running: 0 }
+      };
+    });
+    return {
+      total: detailed.length,
+      bots: detailed,
+      platforms: [...new Set(detailed.map((b) => b.platform))]
+    };
+  };
+}
+
+// src/tools/message-status.ts
+function createMessageStatusHandler(auditLogger) {
+  return async (args) => {
+    if (args.audit_id) {
+      const entry = auditLogger.findById(args.audit_id);
+      if (!entry) {
+        return { found: false, message: `Audit entry "${args.audit_id}" not found` };
+      }
+      return { found: true, entry };
+    }
+    if (args.message_id) {
+      const entry = auditLogger.findByMessageId(args.message_id);
+      if (!entry) {
+        return { found: false, message: `Message "${args.message_id}" not found in audit log` };
+      }
+      return { found: true, entry };
+    }
+    const entries = auditLogger.query({
+      bot: args.bot,
+      platform: args.platform,
+      status: args.status,
+      since: args.since,
+      limit: args.limit ?? 20
+    });
+    const stats = auditLogger.stats();
+    return {
+      total_found: entries.length,
+      entries,
+      stats: {
+        total_tracked: stats.total,
+        success: stats.success,
+        failed: stats.failed,
+        by_platform: stats.byPlatform
+      }
+    };
+  };
+}
+
+// src/tools/render-template.ts
+function createRenderTemplateHandler() {
+  return async (args) => {
+    const hasVars = templateEngine.hasExpressions(args.template);
+    const variables = templateEngine.extractVariables(args.template);
+    const rendered = templateEngine.render(args.template, args.variables || {});
+    return {
+      template: args.template,
+      variables_detected: variables,
+      variables_provided: Object.keys(args.variables || {}),
+      rendered,
+      has_expressions: hasVars
+    };
+  };
+}
+
+// src/tools/index.ts
+var toolDefinitions = [
+  {
+    name: "send_message",
+    description: "Send a message to a configured bot. Supports text, markdown, link, image, card, news, and file types. Content can include Handlebars template variables like {{name}}.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        bot: {
+          type: "string",
+          description: "Bot instance name (as configured, e.g. 'dingtalk-ops', 'telegram-bot')"
+        },
+        type: {
+          type: "string",
+          enum: ["text", "markdown", "link", "image", "card", "news", "file"],
+          description: "Message type"
+        },
+        content: {
+          type: "string",
+          description: "Message content. Supports Handlebars templates: {{variable_name}}"
+        },
+        title: {
+          type: "string",
+          description: "Message title (for markdown, link, card types)"
+        },
+        variables: {
+          type: "object",
+          additionalProperties: { type: "string" },
+          description: "Template variables as key-value pairs"
+        },
+        at: {
+          type: "object",
+          properties: {
+            users: { type: "array", items: { type: "string" }, description: "User IDs to mention" },
+            mobiles: { type: "array", items: { type: "string" }, description: "Phone numbers to mention" },
+            all: { type: "boolean", description: "Mention everyone" }
+          },
+          description: "@mention configuration"
+        },
+        link_url: { type: "string", description: "URL for link type messages" },
+        pic_url: { type: "string", description: "Picture/thumbnail URL" },
+        buttons: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              title: { type: "string" },
+              url: { type: "string" }
+            },
+            required: ["title", "url"]
+          },
+          description: "Buttons for card type messages"
+        },
+        single_button_text: { type: "string", description: "Single button text (for actionCard)" },
+        single_button_url: { type: "string", description: "Single button URL" },
+        news_items: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              title: { type: "string" },
+              description: { type: "string" },
+              url: { type: "string" },
+              pic_url: { type: "string" }
+            },
+            required: ["title", "url"]
+          },
+          description: "News/feed items for news type messages"
+        },
+        image_url: { type: "string", description: "Image URL for image type messages" },
+        image_base64: { type: "string", description: "Base64-encoded image data" }
+      },
+      required: ["bot", "type", "content"]
+    }
+  },
+  {
+    name: "send_file",
+    description: "Send a file or image through a configured bot. Supported platforms: WeCom (files via media_id), Discord (multipart upload), Telegram (sendDocument).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        bot: { type: "string", description: "Bot instance name" },
+        file_path: { type: "string", description: "Absolute path to the file to send" },
+        caption: { type: "string", description: "Optional caption for the file" }
+      },
+      required: ["bot", "file_path"]
+    }
+  },
+  {
+    name: "send_broadcast",
+    description: "Send the same message to multiple bots simultaneously (cross-platform broadcast). Useful for sending alerts to DingTalk + WeCom + Slack at the same time.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        bots: {
+          type: "array",
+          items: { type: "string" },
+          description: "List of bot instance names to broadcast to"
+        },
+        type: {
+          type: "string",
+          enum: ["text", "markdown", "link", "image", "card", "news", "file"],
+          description: "Message type"
+        },
+        content: { type: "string", description: "Message content (supports Handlebars templates)" },
+        title: { type: "string", description: "Message title" },
+        variables: {
+          type: "object",
+          additionalProperties: { type: "string" },
+          description: "Template variables"
+        },
+        at: {
+          type: "object",
+          properties: {
+            users: { type: "array", items: { type: "string" } },
+            mobiles: { type: "array", items: { type: "string" } },
+            all: { type: "boolean" }
+          }
+        },
+        link_url: { type: "string" },
+        pic_url: { type: "string" },
+        buttons: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: { title: { type: "string" }, url: { type: "string" } },
+            required: ["title", "url"]
+          }
+        },
+        news_items: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              title: { type: "string" },
+              description: { type: "string" },
+              url: { type: "string" },
+              pic_url: { type: "string" }
+            },
+            required: ["title", "url"]
+          }
+        },
+        image_url: { type: "string" }
+      },
+      required: ["bots", "type", "content"]
+    }
+  },
+  {
+    name: "send_batch",
+    description: "Send the same message to multiple targets through the same bot. Useful for Telegram (multiple chat_ids) or broadcasting within one platform.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        bot: { type: "string", description: "Bot instance name" },
+        targets: {
+          type: "array",
+          items: { type: "string" },
+          description: "List of target IDs (e.g. Telegram chat_ids)"
+        },
+        type: {
+          type: "string",
+          enum: ["text", "markdown", "link", "image", "card", "news", "file"],
+          description: "Message type"
+        },
+        content: { type: "string", description: "Message content" },
+        title: { type: "string" },
+        variables: {
+          type: "object",
+          additionalProperties: { type: "string" }
+        },
+        at: {
+          type: "object",
+          properties: {
+            users: { type: "array", items: { type: "string" } },
+            mobiles: { type: "array", items: { type: "string" } },
+            all: { type: "boolean" }
+          }
+        },
+        link_url: { type: "string" },
+        pic_url: { type: "string" },
+        buttons: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: { title: { type: "string" }, url: { type: "string" } },
+            required: ["title", "url"]
+          }
+        },
+        news_items: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              title: { type: "string" },
+              description: { type: "string" },
+              url: { type: "string" },
+              pic_url: { type: "string" }
+            },
+            required: ["title", "url"]
+          }
+        },
+        image_url: { type: "string" }
+      },
+      required: ["bot", "targets", "type", "content"]
+    }
+  },
+  {
+    name: "list_bots",
+    description: "List all configured bot instances with their platform, status, and queue information.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "message_status",
+    description: "Query the audit log for message delivery status. Look up by message_id, audit_id, or filter by bot/platform/status/time range.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        message_id: { type: "string", description: "Message ID to look up" },
+        audit_id: { type: "string", description: "Audit log entry ID" },
+        bot: { type: "string", description: "Filter by bot name" },
+        platform: { type: "string", description: "Filter by platform" },
+        status: { type: "string", enum: ["success", "failed"], description: "Filter by status" },
+        since: { type: "string", description: "ISO timestamp to filter entries after" },
+        limit: { type: "number", description: "Maximum entries to return (default: 20)" }
+      }
+    }
+  },
+  {
+    name: "render_template",
+    description: "Preview a Handlebars template rendering without sending. Shows detected variables and rendered output.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        template: {
+          type: "string",
+          description: "Handlebars template string (e.g. 'Hello {{name}}, status: {{status}}')"
+        },
+        variables: {
+          type: "object",
+          additionalProperties: { type: "string" },
+          description: "Variables to substitute"
+        }
+      },
+      required: ["template"]
+    }
+  }
+];
+function createToolHandlers(registry, rateLimiter, auditLogger, dryRun) {
+  return {
+    send_message: createSendMessageHandler(registry, rateLimiter, auditLogger, dryRun),
+    send_file: createSendFileHandler(registry, rateLimiter, auditLogger, dryRun),
+    send_broadcast: createSendBroadcastHandler(registry, rateLimiter, auditLogger, dryRun),
+    send_batch: createSendBatchHandler(registry, rateLimiter, auditLogger, dryRun),
+    list_bots: createListBotsHandler(registry, rateLimiter),
+    message_status: createMessageStatusHandler(auditLogger),
+    render_template: createRenderTemplateHandler()
+  };
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+async function main() {
+  logger.info("botmsg starting...", { version: VERSION });
+  const config = loadConfig();
+  logger.setLevel(config.settings.log_level);
+  if (Object.keys(config.bots).length === 0) {
+    logger.warn("No bots configured. Use env vars or a config file. See README for details.");
+  }
+  const registry = new PlatformRegistry();
+  registry.loadConfig(config);
+  const rateLimiter = new RateLimiterManager({
+    maxRetries: config.settings.max_retries
+  });
+  const auditLogger = new AuditLogger({
+    filePath: config.settings.audit_log
+  });
+  const dryRun = config.settings.dry_run;
+  if (dryRun) {
+    logger.info("DRY RUN mode enabled - no messages will be sent");
+  }
+  const handlers = createToolHandlers(registry, rateLimiter, auditLogger, dryRun);
+  const server = new Server(
+    { name: "botmsg", version: VERSION },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: toolDefinitions.map((td) => ({
+      name: td.name,
+      description: td.description,
+      inputSchema: td.inputSchema
+    }))
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const startTime = Date.now();
+    try {
+      logger.debug(`Tool call: ${name}`, { args: JSON.stringify(args).slice(0, 200) });
+      const handler = handlers[name];
+      if (!handler) {
+        return {
+          content: [{ type: "text", text: `Error: Unknown tool "${name}"` }],
+          isError: true
+        };
+      }
+      const result = await handler(args || {});
+      const latencyMs = Date.now() - startTime;
+      logger.info(`Tool ${name} completed`, { latencyMs });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (error) {
+      const latencyMs = Date.now() - startTime;
+      let message;
+      if (error instanceof BotMsgError) {
+        message = `[${error.code}] ${error.message}`;
+        if (error.platform) message = `[${error.platform}] ${message}`;
+      } else if (error instanceof Error) {
+        message = error.message;
+      } else {
+        message = "An unexpected error occurred";
+      }
+      logger.error(`Tool ${name} failed`, { latencyMs, error: message });
+      return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true
+      };
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logger.info("botmsg MCP server running on stdio", {
+    bots: Object.keys(config.bots).length,
+    dryRun
+  });
+  const shutdown = async (signal) => {
+    logger.info(`Received ${signal}, shutting down...`);
+    await rateLimiter.disconnect();
+    await server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("uncaughtException", (error) => {
+    logger.error("Uncaught exception", { error: error.message, stack: error.stack });
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    logger.error("Unhandled rejection", {
+      reason: reason instanceof Error ? reason.message : String(reason)
+    });
+    process.exit(1);
+  });
+}
+main().catch((error) => {
+  logger.error("Fatal error during startup", {
+    error: error instanceof Error ? error.message : String(error)
+  });
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map