feat: add message push function call

internal/sdk/messenger/README.md

@@ -0,0 +1,161 @@
+# Messenger SDK
+
+统一消息发送 SDK，可独立于 Message-Push-Nest 业务层使用。
+
+## 特点
+
+- **零业务依赖**：不依赖数据库、路由、认证等业务代码
+- **开箱即用**：直接传配置 + 消息即可发送
+- **支持 12 种渠道**：Email, 钉钉, 企业微信, 飞书, Telegram, Bark, Ntfy, Gotify, PushMe, 自定义Webhook, 微信公众号, 阿里云短信
+- **可扩展**：通过 `RegisterChannel` 注册自定义渠道
+
+## 快速使用
+
+```go
+import "message-nest/pkg/sdk/messenger"
+
+// 方式1: 直接发送
+result, err := messenger.Send("Telegram", messenger.ChannelConfig{
+    "bot_token": "your-bot-token",
+    "chat_id":   "123456",
+}, &messenger.Message{
+    Title:    "告警通知",
+    Text:     "服务器 CPU 超过 90%",
+    Markdown: "**服务器 CPU** 超过 `90%`",
+})
+
+if err != nil {
+    log.Fatal(err)
+}
+if !result.Success {
+    log.Printf("发送失败: %s", result.Error)
+}
+```
+
+### 使用 Client（预设默认配置）
+
+```go
+client := messenger.NewClient()
+
+// 预设 Telegram 配置
+client.SetDefaultConfig("Telegram", messenger.ChannelConfig{
+    "bot_token": "your-bot-token",
+    "chat_id":   "default-chat",
+})
+
+// 后续发送可以覆盖部分配置，也可以传 nil 使用全部默认值
+result, err := client.Send("Telegram", nil, &messenger.Message{
+    Title: "Hello",
+    Text:  "World",
+})
+```
+
+## 各渠道配置参数
+
+### Email
+| 参数 | 必填 | 说明 |
+|------|------|------|
+| `server` | ✅ | SMTP 服务地址 |
+| `port` | ✅ | SMTP 端口 |
+| `account` | ✅ | 邮箱账号 |
+| `passwd` | ✅ | 邮箱密码 |
+| `from_name` | ❌ | 发信人名称 |
+| `to_account` | ✅ | 收件邮箱 |
+
+### Dtalk（钉钉）
+| 参数 | 必填 | 说明 |
+|------|------|------|
+| `access_token` | ✅ | 钉钉 access_token |
+| `secret` | ❌ | 加签秘钥 |
+
+### QyWeiXin（企业微信）
+| 参数 | 必填 | 说明 |
+|------|------|------|
+| `access_token` | ✅ | 企业微信 access_token |
+
+### Feishu（飞书）
+| 参数 | 必填 | 说明 |
+|------|------|------|
+| `access_token` | ✅ | 飞书 access_token |
+| `secret` | ❌ | 加签秘钥 |
+
+### Telegram
+| 参数 | 必填 | 说明 |
+|------|------|------|
+| `bot_token` | ✅ | Bot Token |
+| `chat_id` | ✅ | Chat ID |
+| `api_host` | ❌ | 自定义 API 地址 |
+| `proxy_url` | ❌ | 代理地址 (http/https/socks5) |
+
+### Bark
+| 参数 | 必填 | 说明 |
+|------|------|------|
+| `push_key` | ✅ | Bark Push Key |
+| `archive` | ❌ | 是否存档 |
+| `group` | ❌ | 推送分组 |
+| `sound` | ❌ | 推送声音 |
+| `icon` | ❌ | 推送图标 |
+| `level` | ❌ | 时效性 |
+| `url` | ❌ | 跳转URL |
+| `key` | ❌ | 加密Key |
+| `iv` | ❌ | 加密IV |
+
+### Ntfy
+| 参数 | 必填 | 说明 |
+|------|------|------|
+| `topic` | ✅ | Topic |
+| `url` | ❌ | 自定义 API 地址 |
+| `priority` | ❌ | 优先级 |
+| `icon` | ❌ | 图标 URL |
+| `token` | ❌ | Token |
+| `username` | ❌ | 用户名 |
+| `password` | ❌ | 密码 |
+| `actions` | ❌ | Actions |
+
+### Gotify
+| 参数 | 必填 | 说明 |
+|------|------|------|
+| `url` | ✅ | Gotify 服务地址 |
+| `token` | ✅ | Token |
+| `priority` | ❌ | 优先级 |
+
+### PushMe
+| 参数 | 必填 | 说明 |
+|------|------|------|
+| `push_key` | ✅ | PushMe Push Key |
+| `url` | ❌ | 自定义 API 地址 |
+| `date` | ❌ | 日期 |
+| `type` | ❌ | 类型 |
+
+### Custom（自定义Webhook）
+| 参数 | 必填 | 说明 |
+|------|------|------|
+| `webhook` | ✅ | Webhook URL |
+| `body` | ❌ | 请求体模板（`TEXT` 占位符会被替换） |
+
+### WeChatOFAccount（微信公众号）
+| 参数 | 必填 | 说明 |
+|------|------|------|
+| `appID` | ✅ | 公众号 AppID |
+| `appsecret` | ✅ | 公众号 AppSecret |
+| `tempid` | ❌ | 模板消息 ID |
+| `to_account` | ✅ | 接收者 OpenID |
+
+### AliyunSMS（阿里云短信）
+| 参数 | 必填 | 说明 |
+|------|------|------|
+| `access_key_id` | ✅ | AccessKeyId |
+| `access_key_secret` | ✅ | AccessKeySecret |
+| `sign_name` | ✅ | 短信签名 |
+| `region_id` | ❌ | 区域ID（默认 cn-hangzhou） |
+| `phone_number` | ✅ | 手机号码 |
+| `template_code` | ✅ | 短信模板 CODE |
+
+## 自定义扩展
+
+```go
+// 注册自定义渠道
+messenger.RegisterChannel("MyChannel", func() messenger.Channel {
+    return &myCustomChannel{}
+})
+```

internal/sdk/messenger/channels/aliyun_sms.go

@@ -0,0 +1,40 @@
+package channels
+
+type AliyunSMSChannel struct{ *BaseChannel }
+
+func NewAliyunSMSChannel() Channel {
+	return &AliyunSMSChannel{NewBaseChannel(ChannelAliyunSMS, []string{FormatTypeText})}
+}
+
+func (c *AliyunSMSChannel) Send(config ChannelConfig, msg *Message) (*Result, error) {
+	accessKeyId := config.GetString("access_key_id")
+	accessKeySecret := config.GetString("access_key_secret")
+	signName := config.GetString("sign_name")
+	regionId := config.GetString("region_id")
+	phoneNumber := config.GetString("phone_number")
+	templateCode := config.GetString("template_code")
+
+	if accessKeyId == "" || accessKeySecret == "" || signName == "" {
+		return SendError("aliyun sms config missing: access_key_id, access_key_secret, sign_name are required"), nil
+	}
+	if phoneNumber == "" || templateCode == "" {
+		return SendError("aliyun sms config missing: phone_number, template_code are required"), nil
+	}
+
+	_, formattedContent := c.FormatContent(msg)
+
+	if regionId == "" {
+		regionId = "cn-hangzhou"
+	}
+
+	client, err := createAliyunSMSClient(accessKeyId, accessKeySecret, regionId)
+	if err != nil {
+		return SendError("创建阿里云短信客户端失败: %s", err.Error()), nil
+	}
+
+	result, err := sendAliyunSMS(client, phoneNumber, signName, templateCode, formattedContent, msg.Extra)
+	if err != nil {
+		return ErrorResult("", err), nil
+	}
+	return SuccessResult(result), nil
+}

internal/sdk/messenger/channels/bark.go

@@ -0,0 +1,34 @@
+package channels
+
+import "github.com/engigu/baihu-panel/internal/sdk/message"
+
+type BarkChannel struct{ *BaseChannel }
+
+func NewBarkChannel() Channel {
+	return &BarkChannel{NewBaseChannel(ChannelBark, []string{FormatTypeText})}
+}
+
+func (c *BarkChannel) Send(config ChannelConfig, msg *Message) (*Result, error) {
+	pushKey := config.GetString("push_key")
+	if pushKey == "" {
+		return SendError("bark config missing: push_key is required"), nil
+	}
+
+	cli := message.Bark{
+		PushKey: pushKey,
+		Archive: config.GetString("archive"),
+		Group:   config.GetString("group"),
+		Sound:   config.GetString("sound"),
+		Icon:    config.GetString("icon"),
+		Level:   config.GetString("level"),
+		URL:     config.GetString("url"),
+		Key:     config.GetString("key"),
+		IV:      config.GetString("iv"),
+	}
+
+	res, err := cli.Request(msg.Title, msg.Text)
+	if err != nil {
+		return ErrorResult(string(res), err), nil
+	}
+	return SuccessResult(string(res)), nil
+}

internal/sdk/messenger/channels/channel.go

@@ -0,0 +1,74 @@
+package channels
+
+import "fmt"
+
+// Channel 渠道接口 - SDK 版本，零业务依赖
+type Channel interface {
+	// GetType 返回渠道类型标识
+	GetType() string
+	// GetSupportedFormats 返回支持的消息格式
+	GetSupportedFormats() []string
+	// Send 发送消息
+	Send(config ChannelConfig, msg *Message) (*Result, error)
+}
+
+// BaseChannel 渠道基础实现
+type BaseChannel struct {
+	channelType      string
+	supportedFormats []string
+}
+
+func NewBaseChannel(channelType string, supportedFormats []string) *BaseChannel {
+	return &BaseChannel{channelType: channelType, supportedFormats: supportedFormats}
+}
+
+func (c *BaseChannel) GetType() string              { return c.channelType }
+func (c *BaseChannel) GetSupportedFormats() []string { return c.supportedFormats }
+
+// FormatContent 根据渠道支持的格式选择最佳内容
+func (c *BaseChannel) FormatContent(msg *Message) (formatType string, content string) {
+	for _, ft := range c.supportedFormats {
+		switch ft {
+		case FormatTypeMarkdown:
+			if msg.HasMarkdown() {
+				return FormatTypeMarkdown, msg.Markdown
+			}
+		case FormatTypeHTML:
+			if msg.HasHTML() {
+				return FormatTypeHTML, msg.HTML
+			}
+		case FormatTypeText:
+			if msg.HasText() {
+				return FormatTypeText, msg.Text
+			}
+		}
+	}
+	if msg.HasText() {
+		return FormatTypeText, msg.Text
+	}
+	return FormatTypeText, ""
+}
+
+// SuccessResult 创建成功结果
+func SuccessResult(response string) *Result {
+	return &Result{Success: true, Response: response}
+}
+
+// ErrorResult 创建失败结果
+func ErrorResult(response string, err error) *Result {
+	errMsg := ""
+	if err != nil {
+		errMsg = err.Error()
+	}
+	return &Result{Success: false, Response: response, Error: errMsg}
+}
+
+// ErrorResultStr 创建失败结果（字符串错误）
+func ErrorResultStr(response string, errMsg string) *Result {
+	return &Result{Success: false, Response: response, Error: errMsg}
+}
+
+// SendError 发送失败时的格式化错误
+func SendError(format string, args ...any) *Result {
+	return &Result{Success: false, Error: fmt.Sprintf(format, args...)}
+}

internal/sdk/messenger/channels/custom.go

@@ -0,0 +1,35 @@
+package channels
+
+import "github.com/engigu/baihu-panel/internal/sdk/message"
+
+type CustomChannel struct{ *BaseChannel }
+
+func NewCustomChannel() Channel {
+	return &CustomChannel{NewBaseChannel(ChannelCustom, []string{FormatTypeText})}
+}
+
+func (c *CustomChannel) Send(config ChannelConfig, msg *Message) (*Result, error) {
+	webhook := config.GetString("webhook")
+	body := config.GetString("body")
+
+	if webhook == "" {
+		return SendError("custom config missing: webhook is required"), nil
+	}
+
+	_, formattedContent := c.FormatContent(msg)
+	cli := message.CustomWebhook{}
+
+	// 替换 body 模板中的 TEXT 占位符
+	bodyStr := body
+	if bodyStr != "" {
+		bodyStr = replaceBodyPlaceholder(bodyStr, formattedContent)
+	} else {
+		bodyStr = formattedContent
+	}
+
+	res, err := cli.Request(webhook, bodyStr)
+	if err != nil {
+		return ErrorResult(string(res), err), nil
+	}
+	return SuccessResult(string(res)), nil
+}

internal/sdk/messenger/channels/dtalk.go

@@ -0,0 +1,41 @@
+package channels
+
+import "github.com/engigu/baihu-panel/internal/sdk/message"
+
+type DtalkChannel struct{ *BaseChannel }
+
+func NewDtalkChannel() Channel {
+	return &DtalkChannel{NewBaseChannel(ChannelDtalk, []string{FormatTypeMarkdown, FormatTypeText})}
+}
+
+func (c *DtalkChannel) Send(config ChannelConfig, msg *Message) (*Result, error) {
+	accessToken := config.GetString("access_token")
+	secret := config.GetString("secret")
+
+	if accessToken == "" {
+		return SendError("dtalk config missing: access_token is required"), nil
+	}
+
+	contentType, formattedContent := c.FormatContent(msg)
+	atMobiles := msg.GetAtMobiles()
+	if msg.AtAll {
+		atMobiles = append(atMobiles, "all")
+	}
+
+	cli := message.Dtalk{AccessToken: accessToken, Secret: secret}
+	var res []byte
+	var err error
+
+	if contentType == FormatTypeText {
+		res, err = cli.SendMessageText(formattedContent, atMobiles...)
+	} else if contentType == FormatTypeMarkdown {
+		res, err = cli.SendMessageMarkdown(msg.Title, formattedContent, atMobiles...)
+	} else {
+		return SendError("未知的钉钉发送内容类型：%s", contentType), nil
+	}
+
+	if err != nil {
+		return ErrorResult(string(res), err), nil
+	}
+	return SuccessResult(string(res)), nil
+}

internal/sdk/messenger/channels/email.go

@@ -0,0 +1,49 @@
+package channels
+
+import (
+	"fmt"
+	"github.com/engigu/baihu-panel/internal/sdk/message"
+	"strconv"
+)
+
+type EmailChannel struct{ *BaseChannel }
+
+func NewEmailChannel() Channel {
+	return &EmailChannel{NewBaseChannel(ChannelEmail, []string{FormatTypeHTML, FormatTypeText})}
+}
+
+func (c *EmailChannel) Send(config ChannelConfig, msg *Message) (*Result, error) {
+	server := config.GetString("server")
+	portStr := config.GetString("port")
+	account := config.GetString("account")
+	passwd := config.GetString("passwd")
+	fromName := config.GetString("from_name")
+	toAccount := config.GetString("to_account")
+
+	if server == "" || account == "" || passwd == "" {
+		return SendError("email config missing: server, account, passwd are required"), nil
+	}
+	if toAccount == "" {
+		return SendError("email config missing: to_account is required"), nil
+	}
+
+	port, _ := strconv.Atoi(portStr)
+	contentType, formattedContent := c.FormatContent(msg)
+
+	var emailer message.EmailMessage
+	emailer.Init(server, port, account, passwd, fromName)
+
+	var errMsg string
+	if contentType == FormatTypeText {
+		errMsg = emailer.SendTextMessage(toAccount, msg.Title, formattedContent)
+	} else if contentType == FormatTypeHTML {
+		errMsg = emailer.SendHtmlMessage(toAccount, msg.Title, formattedContent)
+	} else {
+		errMsg = fmt.Sprintf("未知的邮件发送内容类型：%s", contentType)
+	}
+
+	if errMsg != "" {
+		return ErrorResultStr("", errMsg), nil
+	}
+	return SuccessResult(""), nil
+}

internal/sdk/messenger/channels/feishu.go

@@ -0,0 +1,43 @@
+package channels
+
+import "github.com/engigu/baihu-panel/internal/sdk/message"
+
+type FeishuChannel struct{ *BaseChannel }
+
+func NewFeishuChannel() Channel {
+	return &FeishuChannel{NewBaseChannel(ChannelFeishu, []string{FormatTypeMarkdown, FormatTypeText})}
+}
+
+func (c *FeishuChannel) Send(config ChannelConfig, msg *Message) (*Result, error) {
+	accessToken := config.GetString("access_token")
+	secret := config.GetString("secret")
+
+	if accessToken == "" {
+		return SendError("feishu config missing: access_token is required"), nil
+	}
+
+	contentType, formattedContent := c.FormatContent(msg)
+	atMobiles := msg.GetAtMobiles()
+	atUserIds := msg.GetAtUserIds()
+	atList := append(atMobiles, atUserIds...)
+	if msg.AtAll {
+		atList = append(atList, "all")
+	}
+
+	cli := message.Feishu{AccessToken: accessToken, Secret: secret}
+	var res []byte
+	var err error
+
+	if contentType == FormatTypeText {
+		res, err = cli.SendMessageText(formattedContent, atList...)
+	} else if contentType == FormatTypeMarkdown {
+		res, err = cli.SendMessageMarkdown(msg.Title, formattedContent, atList...)
+	} else {
+		return SendError("未知的飞书发送内容类型：%s", contentType), nil
+	}
+
+	if err != nil {
+		return ErrorResult(string(res), err), nil
+	}
+	return SuccessResult(string(res)), nil
+}

internal/sdk/messenger/channels/gotify.go

@@ -0,0 +1,34 @@
+package channels
+
+import (
+	"github.com/engigu/baihu-panel/internal/sdk/message"
+	"strconv"
+)
+
+type GotifyChannel struct{ *BaseChannel }
+
+func NewGotifyChannel() Channel {
+	return &GotifyChannel{NewBaseChannel(ChannelGotify, []string{FormatTypeText})}
+}
+
+func (c *GotifyChannel) Send(config ChannelConfig, msg *Message) (*Result, error) {
+	url := config.GetString("url")
+	token := config.GetString("token")
+
+	if url == "" || token == "" {
+		return SendError("gotify config missing: url and token are required"), nil
+	}
+
+	priority, _ := strconv.Atoi(config.GetString("priority"))
+	cli := message.Gotify{
+		Url:      url,
+		Token:    token,
+		Priority: priority,
+	}
+
+	res, err := cli.Request(msg.Title, msg.Text)
+	if err != nil {
+		return ErrorResult(string(res), err), nil
+	}
+	return SuccessResult(string(res)), nil
+}

internal/sdk/messenger/channels/helpers.go

@@ -0,0 +1,52 @@
+package channels
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/aliyun/alibaba-cloud-sdk-go/services/dysmsapi"
+)
+
+// replaceBodyPlaceholder 替换自定义 webhook body 中的 TEXT 占位符
+func replaceBodyPlaceholder(body string, content string) string {
+	data, _ := json.Marshal(content)
+	dataStr := strings.Trim(string(data), "\"")
+	return strings.Replace(body, "TEXT", dataStr, -1)
+}
+
+// createAliyunSMSClient 创建阿里云短信客户端
+func createAliyunSMSClient(accessKeyId, accessKeySecret, regionId string) (*dysmsapi.Client, error) {
+	return dysmsapi.NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret)
+}
+
+// sendAliyunSMS 发送短信
+func sendAliyunSMS(client *dysmsapi.Client, phoneNumber, signName, templateCode, content string, extra map[string]any) (string, error) {
+	templateParam := map[string]interface{}{
+		"content": content,
+	}
+	if extra != nil {
+		for k, v := range extra {
+			templateParam[k] = v
+		}
+	}
+	templateParamJSON, _ := json.Marshal(templateParam)
+
+	request := dysmsapi.CreateSendSmsRequest()
+	request.Scheme = "https"
+	request.PhoneNumbers = phoneNumber
+	request.SignName = signName
+	request.TemplateCode = templateCode
+	request.TemplateParam = string(templateParamJSON)
+
+	response, err := client.SendSms(request)
+	if err != nil {
+		return "", fmt.Errorf("发送短信失败: %s", err.Error())
+	}
+
+	if response.Code != "OK" {
+		return "", fmt.Errorf("发送失败: %s - %s", response.Code, response.Message)
+	}
+
+	return fmt.Sprintf("RequestId: %s, BizId: %s", response.RequestId, response.BizId), nil
+}

internal/sdk/messenger/channels/ntfy.go

@@ -0,0 +1,33 @@
+package channels
+
+import "github.com/engigu/baihu-panel/internal/sdk/message"
+
+type NtfyChannel struct{ *BaseChannel }
+
+func NewNtfyChannel() Channel {
+	return &NtfyChannel{NewBaseChannel(ChannelNtfy, []string{FormatTypeText})}
+}
+
+func (c *NtfyChannel) Send(config ChannelConfig, msg *Message) (*Result, error) {
+	topic := config.GetString("topic")
+	if topic == "" {
+		return SendError("ntfy config missing: topic is required"), nil
+	}
+
+	cli := message.Ntfy{
+		Url:      config.GetString("url"),
+		Topic:    topic,
+		Priority: config.GetString("priority"),
+		Icon:     config.GetString("icon"),
+		Token:    config.GetString("token"),
+		Username: config.GetString("username"),
+		Password: config.GetString("password"),
+		Actions:  config.GetString("actions"),
+	}
+
+	res, err := cli.Request(msg.Title, msg.Text)
+	if err != nil {
+		return ErrorResult(string(res), err), nil
+	}
+	return SuccessResult(string(res)), nil
+}

internal/sdk/messenger/channels/pushme.go

@@ -0,0 +1,29 @@
+package channels
+
+import "github.com/engigu/baihu-panel/internal/sdk/message"
+
+type PushMeChannel struct{ *BaseChannel }
+
+func NewPushMeChannel() Channel {
+	return &PushMeChannel{NewBaseChannel(ChannelPushMe, []string{FormatTypeText})}
+}
+
+func (c *PushMeChannel) Send(config ChannelConfig, msg *Message) (*Result, error) {
+	pushKey := config.GetString("push_key")
+	if pushKey == "" {
+		return SendError("pushme config missing: push_key is required"), nil
+	}
+
+	cli := message.PushMe{
+		PushKey: pushKey,
+		URL:     config.GetString("url"),
+		Date:    config.GetString("date"),
+		Type:    config.GetString("type"),
+	}
+
+	res, err := cli.Request(msg.Title, msg.Text)
+	if err != nil {
+		return ErrorResult(res, err), nil
+	}
+	return SuccessResult(res), nil
+}

internal/sdk/messenger/channels/qyweixin.go

@@ -0,0 +1,42 @@
+package channels
+
+import "github.com/engigu/baihu-panel/internal/sdk/message"
+
+type QyWeiXinChannel struct{ *BaseChannel }
+
+func NewQyWeiXinChannel() Channel {
+	return &QyWeiXinChannel{NewBaseChannel(ChannelQyWeiXin, []string{FormatTypeMarkdown, FormatTypeText})}
+}
+
+func (c *QyWeiXinChannel) Send(config ChannelConfig, msg *Message) (*Result, error) {
+	accessToken := config.GetString("access_token")
+
+	if accessToken == "" {
+		return SendError("qyweixin config missing: access_token is required"), nil
+	}
+
+	contentType, formattedContent := c.FormatContent(msg)
+	atList := []string{}
+	atList = append(atList, msg.GetAtUserIds()...)
+	atList = append(atList, msg.GetAtMobiles()...)
+	if msg.AtAll {
+		atList = append(atList, "@all")
+	}
+
+	cli := message.QyWeiXin{AccessToken: accessToken}
+	var res []byte
+	var err error
+
+	if contentType == FormatTypeText {
+		res, err = cli.SendMessageText(formattedContent, atList...)
+	} else if contentType == FormatTypeMarkdown {
+		res, err = cli.SendMessageMarkdown(msg.Title, formattedContent, atList...)
+	} else {
+		return SendError("未知的企业微信发送内容类型：%s", contentType), nil
+	}
+
+	if err != nil {
+		return ErrorResult(string(res), err), nil
+	}
+	return SuccessResult(string(res)), nil
+}

internal/sdk/messenger/channels/telegram.go

@@ -0,0 +1,47 @@
+package channels
+
+import "github.com/engigu/baihu-panel/internal/sdk/message"
+
+type TelegramChannel struct{ *BaseChannel }
+
+func NewTelegramChannel() Channel {
+	return &TelegramChannel{NewBaseChannel(ChannelTelegram, []string{FormatTypeMarkdown, FormatTypeHTML, FormatTypeText})}
+}
+
+func (c *TelegramChannel) Send(config ChannelConfig, msg *Message) (*Result, error) {
+	botToken := config.GetString("bot_token")
+	chatID := config.GetString("chat_id")
+	apiHost := config.GetString("api_host")
+	proxyURL := config.GetString("proxy_url")
+
+	if botToken == "" || chatID == "" {
+		return SendError("telegram config missing: bot_token, chat_id are required"), nil
+	}
+
+	contentType, formattedContent := c.FormatContent(msg)
+	cli := message.Telegram{
+		BotToken: botToken,
+		ChatID:   chatID,
+		ApiHost:  apiHost,
+		ProxyURL: proxyURL,
+	}
+
+	var res []byte
+	var err error
+
+	switch contentType {
+	case FormatTypeText:
+		res, err = cli.SendMessageText(formattedContent)
+	case FormatTypeMarkdown:
+		res, err = cli.SendMessageMarkdown(formattedContent)
+	case FormatTypeHTML:
+		res, err = cli.SendMessageHTML(formattedContent)
+	default:
+		return SendError("未知的Telegram发送内容类型：%s", contentType), nil
+	}
+
+	if err != nil {
+		return ErrorResult(string(res), err), nil
+	}
+	return SuccessResult(string(res)), nil
+}

internal/sdk/messenger/channels/types.go

@@ -0,0 +1,75 @@
+package channels
+
+// Message 统一消息内容
+type Message struct {
+	Title     string         `json:"title"`
+	Text      string         `json:"text"`
+	HTML      string         `json:"html"`
+	Markdown  string         `json:"markdown"`
+	URL       string         `json:"url"`
+	ImageURL  string         `json:"image_url"`
+	Summary   string         `json:"summary"`
+	AtMobiles []string       `json:"at_mobiles"`
+	AtUserIds []string       `json:"at_user_ids"`
+	AtAll     bool           `json:"at_all"`
+	Extra     map[string]any `json:"extra"`
+}
+
+func (m *Message) HasText() bool     { return m.Text != "" }
+func (m *Message) HasHTML() bool     { return m.HTML != "" }
+func (m *Message) HasMarkdown() bool { return m.Markdown != "" }
+
+func (m *Message) GetAtMobiles() []string {
+	if m.AtMobiles == nil {
+		return []string{}
+	}
+	return m.AtMobiles
+}
+
+func (m *Message) GetAtUserIds() []string {
+	if m.AtUserIds == nil {
+		return []string{}
+	}
+	return m.AtUserIds
+}
+
+// ChannelConfig 渠道认证配置（Key-Value 形式，各渠道自行定义字段）
+type ChannelConfig map[string]string
+
+// GetString 安全获取配置值
+func (c ChannelConfig) GetString(key string) string {
+	if v, ok := c[key]; ok {
+		return v
+	}
+	return ""
+}
+
+// Result 发送结果
+type Result struct {
+	Success  bool   `json:"success"`
+	Response string `json:"response"` // 原始响应
+	Error    string `json:"error"`    // 错误信息
+}
+
+// 消息格式类型常量
+const (
+	FormatTypeText     = "text"
+	FormatTypeHTML     = "html"
+	FormatTypeMarkdown = "markdown"
+)
+
+// 渠道类型常量
+const (
+	ChannelEmail           = "Email"
+	ChannelDtalk           = "Dtalk"
+	ChannelQyWeiXin        = "QyWeiXin"
+	ChannelFeishu          = "Feishu"
+	ChannelCustom          = "Custom"
+	ChannelWeChatOFAccount = "WeChatOFAccount"
+	ChannelAliyunSMS       = "AliyunSMS"
+	ChannelTelegram        = "Telegram"
+	ChannelBark            = "Bark"
+	ChannelPushMe          = "PushMe"
+	ChannelNtfy            = "Ntfy"
+	ChannelGotify          = "Gotify"
+)

internal/sdk/messenger/channels/wechat.go

@@ -0,0 +1,38 @@
+package channels
+
+import "github.com/engigu/baihu-panel/internal/sdk/message"
+
+type WeChatOFAccountChannel struct{ *BaseChannel }
+
+func NewWeChatOFAccountChannel() Channel {
+	return &WeChatOFAccountChannel{NewBaseChannel(ChannelWeChatOFAccount, []string{FormatTypeText})}
+}
+
+func (c *WeChatOFAccountChannel) Send(config ChannelConfig, msg *Message) (*Result, error) {
+	appID := config.GetString("appID")
+	appSecret := config.GetString("appsecret")
+	tempID := config.GetString("tempid")
+	toAccount := config.GetString("to_account")
+
+	if appID == "" || appSecret == "" {
+		return SendError("wechat config missing: appID, appsecret are required"), nil
+	}
+	if toAccount == "" {
+		return SendError("wechat config missing: to_account is required"), nil
+	}
+
+	_, formattedContent := c.FormatContent(msg)
+	cli := message.WeChatOFAccount{
+		AppID:      appID,
+		AppSecret:  appSecret,
+		TemplateID: tempID,
+		ToUser:     toAccount,
+		URL:        msg.URL,
+	}
+
+	res, err := cli.Send(msg.Title, formattedContent)
+	if err != nil {
+		return ErrorResult(res, err), nil
+	}
+	return SuccessResult(res), nil
+}

internal/sdk/messenger/messenger.go

@@ -0,0 +1,195 @@
+// Package messenger 提供统一的消息发送SDK
+//
+// 此包可独立于 Message-Push-Nest 的业务层（数据库、HTTP路由等）使用
+// 适合在其他服务中直接引入来发送消息
+//
+// 快速使用：
+//
+//	result, err := messenger.Send("Telegram", messenger.ChannelConfig{
+//	    "bot_token": "your-bot-token",
+//	    "chat_id":   "your-chat-id",
+//	}, &messenger.Message{
+//	    Title: "Hello",
+//	    Text:  "World",
+//	})
+package messenger
+
+import (
+	"fmt"
+	"github.com/engigu/baihu-panel/internal/sdk/messenger/channels"
+	"sync"
+)
+
+// 重导出 channels 包的类型，方便外部使用
+type (
+	Channel       = channels.Channel
+	Message       = channels.Message
+	ChannelConfig = channels.ChannelConfig
+	Result        = channels.Result
+	BaseChannel   = channels.BaseChannel
+)
+
+// 重导出常量
+const (
+	FormatTypeText     = channels.FormatTypeText
+	FormatTypeHTML     = channels.FormatTypeHTML
+	FormatTypeMarkdown = channels.FormatTypeMarkdown
+
+	ChannelEmail           = channels.ChannelEmail
+	ChannelDtalk           = channels.ChannelDtalk
+	ChannelQyWeiXin        = channels.ChannelQyWeiXin
+	ChannelFeishu          = channels.ChannelFeishu
+	ChannelCustom          = channels.ChannelCustom
+	ChannelWeChatOFAccount = channels.ChannelWeChatOFAccount
+	ChannelAliyunSMS       = channels.ChannelAliyunSMS
+	ChannelTelegram        = channels.ChannelTelegram
+	ChannelBark            = channels.ChannelBark
+	ChannelPushMe          = channels.ChannelPushMe
+	ChannelNtfy            = channels.ChannelNtfy
+	ChannelGotify          = channels.ChannelGotify
+)
+
+// 重导出辅助函数
+var (
+	SuccessResult  = channels.SuccessResult
+	ErrorResult    = channels.ErrorResult
+	ErrorResultStr = channels.ErrorResultStr
+	SendError      = channels.SendError
+	NewBaseChannel = channels.NewBaseChannel
+)
+
+// channelFactory 渠道工厂注册表
+var (
+	channelFactories = map[string]func() Channel{}
+	factoryMu        sync.RWMutex
+)
+
+func init() {
+	// 注册所有内置渠道
+	RegisterChannel(ChannelEmail, func() Channel { return channels.NewEmailChannel() })
+	RegisterChannel(ChannelDtalk, func() Channel { return channels.NewDtalkChannel() })
+	RegisterChannel(ChannelQyWeiXin, func() Channel { return channels.NewQyWeiXinChannel() })
+	RegisterChannel(ChannelFeishu, func() Channel { return channels.NewFeishuChannel() })
+	RegisterChannel(ChannelTelegram, func() Channel { return channels.NewTelegramChannel() })
+	RegisterChannel(ChannelBark, func() Channel { return channels.NewBarkChannel() })
+	RegisterChannel(ChannelNtfy, func() Channel { return channels.NewNtfyChannel() })
+	RegisterChannel(ChannelGotify, func() Channel { return channels.NewGotifyChannel() })
+	RegisterChannel(ChannelPushMe, func() Channel { return channels.NewPushMeChannel() })
+	RegisterChannel(ChannelCustom, func() Channel { return channels.NewCustomChannel() })
+	RegisterChannel(ChannelWeChatOFAccount, func() Channel { return channels.NewWeChatOFAccountChannel() })
+	RegisterChannel(ChannelAliyunSMS, func() Channel { return channels.NewAliyunSMSChannel() })
+}
+
+// RegisterChannel 注册自定义渠道（可用于扩展）
+func RegisterChannel(channelType string, factory func() Channel) {
+	factoryMu.Lock()
+	defer factoryMu.Unlock()
+	channelFactories[channelType] = factory
+}
+
+// GetChannel 获取渠道实例
+func GetChannel(channelType string) (Channel, error) {
+	factoryMu.RLock()
+	defer factoryMu.RUnlock()
+	factory, ok := channelFactories[channelType]
+	if !ok {
+		return nil, fmt.Errorf("未知的渠道类型: %s", channelType)
+	}
+	return factory(), nil
+}
+
+// ListChannels 列出所有已注册的渠道类型
+func ListChannels() []string {
+	factoryMu.RLock()
+	defer factoryMu.RUnlock()
+	types := make([]string, 0, len(channelFactories))
+	for t := range channelFactories {
+		types = append(types, t)
+	}
+	return types
+}
+
+// Send 发送消息的便捷函数
+//
+// 参数：
+//   - channelType: 渠道类型（如 "Telegram", "Dtalk" 等）
+//   - config: 渠道必要的认证配置
+//   - msg: 消息内容
+//
+// 使用示例：
+//
+//	result, err := messenger.Send("Ntfy", messenger.ChannelConfig{
+//	    "topic": "my-topic",
+//	}, &messenger.Message{
+//	    Title: "Alert",
+//	    Text:  "Something happened!",
+//	})
+func Send(channelType string, config ChannelConfig, msg *Message) (*Result, error) {
+	ch, err := GetChannel(channelType)
+	if err != nil {
+		return nil, err
+	}
+	return ch.Send(config, msg)
+}
+
+// Client 消息发送客户端（支持预设默认配置）
+type Client struct {
+	defaultConfigs map[string]ChannelConfig
+	mu             sync.RWMutex
+}
+
+// NewClient 创建消息发送客户端
+func NewClient() *Client {
+	return &Client{
+		defaultConfigs: make(map[string]ChannelConfig),
+	}
+}
+
+// SetDefaultConfig 为指定渠道设置默认配置
+//
+// 使用示例：
+//
+//	client := messenger.NewClient()
+//	client.SetDefaultConfig("Telegram", messenger.ChannelConfig{
+//	    "bot_token": "default-token",
+//	    "chat_id":   "default-chat",
+//	})
+//	// 后续发送时不需要再传 config 的相关字段
+//	result, err := client.Send("Telegram", nil, &messenger.Message{...})
+func (c *Client) SetDefaultConfig(channelType string, config ChannelConfig) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.defaultConfigs[channelType] = config
+}
+
+// Send 使用客户端发送消息（会合并默认配置）
+func (c *Client) Send(channelType string, config ChannelConfig, msg *Message) (*Result, error) {
+	mergedConfig := c.mergeConfig(channelType, config)
+	return Send(channelType, mergedConfig, msg)
+}
+
+func (c *Client) mergeConfig(channelType string, config ChannelConfig) ChannelConfig {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	defaultConfig, hasDefault := c.defaultConfigs[channelType]
+	if !hasDefault && config == nil {
+		return ChannelConfig{}
+	}
+	if !hasDefault {
+		return config
+	}
+	if config == nil {
+		return defaultConfig
+	}
+
+	// 合并：config 覆盖 defaultConfig
+	merged := make(ChannelConfig, len(defaultConfig)+len(config))
+	for k, v := range defaultConfig {
+		merged[k] = v
+	}
+	for k, v := range config {
+		merged[k] = v
+	}
+	return merged
+}