From 40e3663dc880ec450133049244f56d9adfbd7c4a Mon Sep 17 00:00:00 2001 From: NanamiAdmin Date: Sat, 10 Oct 2026 11:34:22 +0800 Subject: [PATCH] style(qq_onebot): rename all NapCat related to OneBot --- config/config.go | 8 +- config/variables.go | 20 ++--- frontend/package-lock.json | 3 - internal/controller/controller.go | 10 +-- internal/controller/controller_test.go | 2 +- .../pipes/{qq_napcat => qq_onebot}/napcat.go | 74 +++++++++--------- .../pipes/{qq_napcat => qq_onebot}/qq.go | 78 +++++++++---------- main.go | 8 +- 8 files changed, 100 insertions(+), 103 deletions(-) rename internal/controller/pipes/{qq_napcat => qq_onebot}/napcat.go (77%) rename internal/controller/pipes/{qq_napcat => qq_onebot}/qq.go (81%) diff --git a/config/config.go b/config/config.go index 84fbe91..24573a1 100644 --- a/config/config.go +++ b/config/config.go @@ -69,11 +69,11 @@ func LoadGlobalConfig(configPath string) (*Config, error) { if cfg.ControllerMethod.QQ.ListenMethod == "" { cfg.ControllerMethod.QQ.ListenMethod = "global" } - if cfg.ControllerMethod.QQ.NapcatAddr == "" { - cfg.ControllerMethod.QQ.NapcatAddr = "127.0.0.1" + if cfg.ControllerMethod.QQ.OneBotAddr == "" { + cfg.ControllerMethod.QQ.OneBotAddr = "127.0.0.1" } - if cfg.ControllerMethod.QQ.NapcatPort == "" { - cfg.ControllerMethod.QQ.NapcatPort = "3000" + if cfg.ControllerMethod.QQ.OneBotPort == "" { + cfg.ControllerMethod.QQ.OneBotPort = "3000" } // Apply defaults for Telegram controller. diff --git a/config/variables.go b/config/variables.go index 5105788..82ee759 100644 --- a/config/variables.go +++ b/config/variables.go @@ -15,12 +15,12 @@ type SystemConfig struct { // DebugConfig holds debug-level configuration. type DebugConfig struct { - ShowNapcatMsg bool `json:"showNapcatMsg"` - ShowNapcatAction bool `json:"showNapcatAction"` + ShowOneBotMsg bool `json:"showOneBotMsg"` + ShowOneBotAction bool `json:"showOneBotAction"` ShowTelegramMsg bool `json:"showTelegramMsg"` ShowTriggerCmdEcho bool `json:"showTriggerCmdEcho"` ShowKomariTaskEcho bool `json:"showKomariTaskEcho"` - NapcatIgnoreSelfMsg bool `json:"napcatIgnoreSelfMsg"` + OneBotIgnoreSelfMsg bool `json:"oneBotIgnoreSelfMsg"` } // KomariAccount holds Komari login credentials. @@ -35,14 +35,14 @@ type KomariConfig struct { Account KomariAccount `json:"account"` } -// QQConfig holds QQ (Napcat) Bot controller configuration. +// QQConfig holds QQ (OneBot) Bot controller configuration. type QQConfig struct { Markdown bool `json:"markdown"` Enabled bool `json:"enabled"` NetworkUseProxy bool `json:"networkUseProxy"` - NapcatAddr string `json:"napcatAddr"` - NapcatPort string `json:"napcatPort"` - NapcatToken string `json:"napcatToken"` + OneBotAddr string `json:"oneBotAddr"` + OneBotPort string `json:"oneBotPort"` + OneBotToken string `json:"oneBotToken"` BotQQID int64 `json:"botQQID"` ListenMethod string `json:"listenMethod"` } @@ -119,7 +119,7 @@ type WebhookEndpointConfig struct { Token string `json:"token"` // NotifyPipes lists the notification channels the alert is delivered to, by - // controller name (e.g. "qq(napcat)", "telegram", "email", "ntfy", + // controller name (e.g. "qq(onebot)", "telegram", "email", "ntfy", // "webhook"). NotifyPipes []string `json:"notifyPipes"` } @@ -216,7 +216,7 @@ func (m BotUserMembers) IDs() []string { return ids } -// BotUser_QQConfig holds the admins and trusted groups for the QQ (Napcat) bot. +// BotUser_QQConfig holds the admins and trusted groups for the QQ (OneBot) bot. type BotUser_QQConfig struct { Admins BotUserMembers `json:"admins"` TrustedGroups BotUserMembers `json:"trustedGroups"` @@ -232,7 +232,7 @@ type BotUser_TelegramConfig struct { // and trusted groups (chat targets) for each bot channel separately from the // main config.json. type BotUserConfig struct { - QQ BotUser_QQConfig `json:"qq(napcat)"` + QQ BotUser_QQConfig `json:"qq(onebot)"` Telegram BotUser_TelegramConfig `json:"telegram"` } diff --git a/frontend/package-lock.json b/frontend/package-lock.json index 45adb41..1727ef9 100644 --- a/frontend/package-lock.json +++ b/frontend/package-lock.json @@ -1473,7 +1473,6 @@ "integrity": "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==", "dev": true, "license": "MIT", - "peer": true, "engines": { "node": ">=12" }, @@ -1596,7 +1595,6 @@ "integrity": "sha512-NTKlcQjlAK7MlQoyb6LgaqHc8sso/pVyUJYWMws3jg21uTJw/LddqIFPcPqP6PzpgbIcZyKI85sFE4HBrQDA8A==", "dev": true, "license": "MIT", - "peer": true, "dependencies": { "esbuild": "^0.25.0", "fdir": "^6.4.4", @@ -1671,7 +1669,6 @@ "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.42.tgz", "integrity": "sha512-4RyHQTbQvOPs3MfvUO1Sg0YRrKNnA0mAVtvpd12Tg1fKDN7OHBUl1IqSn8zGJjK9nI3NkNp8cgTpVrSZC5TTcA==", "license": "MIT", - "peer": true, "dependencies": { "@vue/compiler-dom": "3.5.42", "@vue/compiler-sfc": "3.5.42", diff --git a/internal/controller/controller.go b/internal/controller/controller.go index e2156c6..7144533 100644 --- a/internal/controller/controller.go +++ b/internal/controller/controller.go @@ -27,7 +27,7 @@ type Command struct { // Message represents a message to be sent by a controller. type Message struct { - Source string // The source pipe (e.g., "telegram", "qq", "napcat") + Source string // The source pipe (e.g., "telegram", "qq", "onebot") Content string // The message content ChatID int64 // Chat/group ID where the message should be sent Type string // Message type (see MessageType*), used for per-member opt-outs @@ -100,7 +100,7 @@ type Controller interface { // BotController is implemented by controllers that act as chat bots and can // deliver arbitrary messages, such as the bot initialization message on startup. -// Only bot-type pipes (QQ/NapCat, Telegram) implement it; notification-only +// Only bot-type pipes (QQ_OneBot, Telegram) implement it; notification-only // pipes (email, ntfy, webhook) do not. type BotController interface { Controller @@ -140,7 +140,7 @@ func GetManager() *Manager { // // Controllers are rebuilt wholesale rather than reconfigured in place: each one // reads its settings into fields at construction, and two of them own -// connections that cannot be re-pointed (the NapCat WebSocket listener is +// connections that cannot be re-pointed (the OneBot WebSocket listener is // stopped through a sync.Once, the Telegram polling context is created with the // controller). Replacing the set keeps every channel on the same footing. func (m *Manager) NeedsRebuild(next config.ControllerMethodConfig) bool { @@ -183,7 +183,7 @@ func (m *Manager) ReplaceAll(next []Controller, method config.ControllerMethodCo } // Start off the calling goroutine, the way startup does: Telegram's getMe - // and the NapCat WebSocket handshake would otherwise hold the settings + // and the OneBot WebSocket handshake would otherwise hold the settings // request open for as long as they take. The new controllers are already // routable, and each one can send before Start returns. for _, ctrl := range next { @@ -201,7 +201,7 @@ func (m *Manager) ReplaceAll(next []Controller, method config.ControllerMethodCo } // ShowBotInitMessage sends the bot initialization message to all enabled -// bot controllers (QQ/NapCat and Telegram). Notification-only pipes that do +// bot controllers (QQ_OneBot and Telegram). Notification-only pipes that do // not implement BotController are skipped. The message is typed // MessageTypeBotStarted so each controller can honor its members' per-recipient // EventBotStarted opt-out. It is rendered once per controller because the diff --git a/internal/controller/controller_test.go b/internal/controller/controller_test.go index 1585f54..a500d69 100644 --- a/internal/controller/controller_test.go +++ b/internal/controller/controller_test.go @@ -97,7 +97,7 @@ func TestReplaceAllInstallsAndStarts(t *testing.T) { } // TestReplaceAllStopsTheOutgoingSet is the invariant the rebuild relies on: the -// old controllers must be shut down, or a rebuilt NapCat or Telegram controller +// old controllers must be shut down, or a rebuilt onebot or Telegram controller // would leave its previous connection running. func TestReplaceAllStopsTheOutgoingSet(t *testing.T) { m := newTestManager() diff --git a/internal/controller/pipes/qq_napcat/napcat.go b/internal/controller/pipes/qq_onebot/napcat.go similarity index 77% rename from internal/controller/pipes/qq_napcat/napcat.go rename to internal/controller/pipes/qq_onebot/napcat.go index ddf86f1..2a9ddc2 100644 --- a/internal/controller/pipes/qq_napcat/napcat.go +++ b/internal/controller/pipes/qq_onebot/napcat.go @@ -1,4 +1,4 @@ -package qq_napcat +package qq_onebot import ( "bytes" @@ -17,16 +17,16 @@ import ( "nukumizu-backend/postLog" ) -// actionLogEnabled reports whether the NapCat HTTP API methods echo each action -// they send, per the showNapcatAction toggle. Unlike the WebSocket message path +// actionLogEnabled reports whether the OneBot HTTP API methods echo each action +// they send, per the showOneBotAction toggle. Unlike the WebSocket message path // in qq.go it deliberately does not also require debugMode: these methods have // always logged on this toggle alone, and preserving that is intentional. func actionLogEnabled() bool { cfg := config.Current() - return cfg != nil && cfg.Debug.ShowNapcatAction + return cfg != nil && cfg.Debug.ShowOneBotAction } -// APIResponse mirrors NapCat's HTTP API response envelope. +// APIResponse mirrors OneBot's HTTP API response envelope. type APIResponse struct { Status string `json:"status"` RetCode int `json:"retcode"` @@ -34,9 +34,9 @@ type APIResponse struct { Data json.RawMessage `json:"data"` } -// Client is the HTTP + WebSocket client for a single NapCat instance. +// Client is the HTTP + WebSocket client for a single OneBot instance. // It both listens for incoming OneBot events over WebSocket and issues -// outbound NapCat API calls over HTTP. +// outbound OneBot API calls over HTTP. type Client struct { addr string port string @@ -50,7 +50,7 @@ type Client struct { stopOnce sync.Once } -// NewClient creates a NapCat client for the given host/port/token. When +// NewClient creates a OneBot client for the given host/port/token. When // useProxy is set, HTTP API calls and the WebSocket connection are routed // through the system-wide network proxy. func NewClient(addr, port, token string, useProxy bool) *Client { @@ -68,9 +68,9 @@ func (c *Client) baseURL() string { return fmt.Sprintf("http://%s:%s", c.addr, c.port) } -// sendRequest performs an HTTP call to NapCat, injecting access_token into POST +// sendRequest performs an HTTP call to OneBot, injecting access_token into POST // bodies AND setting Authorization: Bearer (compatible with HTTP Server adapters -// created in the NapCat Web UI). +// created in the OneBot Web UI). func (c *Client) sendRequest(method, endpoint string, body []byte) ([]byte, error) { url := c.baseURL() + endpoint @@ -105,28 +105,28 @@ func (c *Client) sendRequest(method, endpoint string, body []byte) ([]byte, erro resp, err := c.httpClient.Do(req) if err != nil { - return nil, fmt.Errorf("failed to send request to napcat: %w", err) + return nil, fmt.Errorf("failed to send request to onebot: %w", err) } defer resp.Body.Close() respBody, err := io.ReadAll(resp.Body) if err != nil { - return nil, fmt.Errorf("failed to read napcat response: %w", err) + return nil, fmt.Errorf("failed to read onebot response: %w", err) } return respBody, nil } -// parseResponse unmarshals NapCat's raw response body into an APIResponse. +// parseResponse unmarshals OneBot's raw response body into an APIResponse. func (c *Client) parseResponse(respBody []byte, caller string) (*APIResponse, error) { - var napcatResp APIResponse - if err := json.Unmarshal(respBody, &napcatResp); err != nil { - return nil, fmt.Errorf("failed to unmarshal napcat response (%s): %w\n%s", caller, err, string(respBody)) + var onebotResp APIResponse + if err := json.Unmarshal(respBody, &onebotResp); err != nil { + return nil, fmt.Errorf("failed to unmarshal onebot response (%s): %w\n%s", caller, err, string(respBody)) } - return &napcatResp, nil + return &onebotResp, nil } -// SendMsg sends a message via NapCat. +// SendMsg sends a message via OneBot. // targetType: "group" or "private" // targetID: QQ group ID or user ID // msg: message content @@ -140,18 +140,18 @@ func (c *Client) SendMsg(targetType string, targetID int64, msg string, hasAt bo } var endpoint string - var napcatReq map[string]interface{} + var onebotReq map[string]interface{} switch targetType { case "group": endpoint = "/send_group_msg" - napcatReq = map[string]interface{}{ + onebotReq = map[string]interface{}{ "group_id": targetID, "message": message, } case "private": endpoint = "/send_private_msg" - napcatReq = map[string]interface{}{ + onebotReq = map[string]interface{}{ "user_id": targetID, "message": message, } @@ -159,13 +159,13 @@ func (c *Client) SendMsg(targetType string, targetID int64, msg string, hasAt bo return nil, fmt.Errorf("invalid targetType: %s, must be 'group' or 'private'", targetType) } - reqBody, err := json.Marshal(napcatReq) + reqBody, err := json.Marshal(onebotReq) if err != nil { return nil, fmt.Errorf("failed to marshal request: %w", err) } if actionLogEnabled() { - postLog.Debug(fmt.Sprintf("[Napcat] SendMsg -> %s (%s): %s", endpoint, targetType, message)) + postLog.Debug(fmt.Sprintf("[OneBot] SendMsg -> %s (%s): %s", endpoint, targetType, message)) } respBody, err := c.sendRequest(http.MethodPost, endpoint, reqBody) @@ -176,7 +176,7 @@ func (c *Client) SendMsg(targetType string, targetID int64, msg string, hasAt bo return c.parseResponse(respBody, "SendMsg") } -// RecallMsg recalls (deletes) a sent message via NapCat. +// RecallMsg recalls (deletes) a sent message via OneBot. func (c *Client) RecallMsg(msgID int64) (*APIResponse, error) { reqBody, err := json.Marshal(map[string]interface{}{ "message_id": msgID, @@ -186,7 +186,7 @@ func (c *Client) RecallMsg(msgID int64) (*APIResponse, error) { } if actionLogEnabled() { - postLog.Debug(fmt.Sprintf("[Napcat] RecallMsg -> /delete_msg: %d", msgID)) + postLog.Debug(fmt.Sprintf("[OneBot] RecallMsg -> /delete_msg: %d", msgID)) } respBody, err := c.sendRequest(http.MethodPost, "/delete_msg", reqBody) @@ -197,10 +197,10 @@ func (c *Client) RecallMsg(msgID int64) (*APIResponse, error) { return c.parseResponse(respBody, "RecallMsg") } -// GetGroupList retrieves the list of joined groups from NapCat. +// GetGroupList retrieves the list of joined groups from OneBot. func (c *Client) GetGroupList() (*APIResponse, error) { if actionLogEnabled() { - postLog.Debug("[Napcat] GetGroupList -> /get_group_list") + postLog.Debug("[OneBot] GetGroupList -> /get_group_list") } respBody, err := c.sendRequest(http.MethodGet, "/get_group_list", nil) @@ -211,7 +211,7 @@ func (c *Client) GetGroupList() (*APIResponse, error) { return c.parseResponse(respBody, "GetGroupList") } -// GetGroupInfo retrieves detailed information about a specific group from NapCat. +// GetGroupInfo retrieves detailed information about a specific group from OneBot. func (c *Client) GetGroupInfo(groupID int64) (*APIResponse, error) { reqBody, err := json.Marshal(map[string]interface{}{ "group_id": groupID, @@ -221,7 +221,7 @@ func (c *Client) GetGroupInfo(groupID int64) (*APIResponse, error) { } if actionLogEnabled() { - postLog.Debug(fmt.Sprintf("[Napcat] GetGroupInfo -> /get_group_info: %d", groupID)) + postLog.Debug(fmt.Sprintf("[OneBot] GetGroupInfo -> /get_group_info: %d", groupID)) } respBody, err := c.sendRequest(http.MethodPost, "/get_group_info", reqBody) @@ -232,10 +232,10 @@ func (c *Client) GetGroupInfo(groupID int64) (*APIResponse, error) { return c.parseResponse(respBody, "GetGroupInfo") } -// GetFriendsList retrieves the friends list from NapCat. +// GetFriendsList retrieves the friends list from OneBot. func (c *Client) GetFriendsList() (*APIResponse, error) { if actionLogEnabled() { - postLog.Debug("[Napcat] GetFriendsList -> /get_friend_list") + postLog.Debug("[OneBot] GetFriendsList -> /get_friend_list") } respBody, err := c.sendRequest(http.MethodGet, "/get_friend_list", nil) @@ -246,7 +246,7 @@ func (c *Client) GetFriendsList() (*APIResponse, error) { return c.parseResponse(respBody, "GetFriendsList") } -// Listen connects to the NapCat WebSocket server and calls onEvent for every raw +// Listen connects to the OneBot WebSocket server and calls onEvent for every raw // message. It blocks forever, reconnecting every 5s after a disconnect, until // Stop is called. Run it in a goroutine. func (c *Client) Listen(onEvent func(raw []byte)) { @@ -259,7 +259,7 @@ func (c *Client) Listen(onEvent func(raw []byte)) { c.listenOnce(onEvent) - postLog.Warning("[Napcat] WebSocket disconnected, reconnecting in 5s...") + postLog.Warning("[OneBot] WebSocket disconnected, reconnecting in 5s...") select { case <-c.stopCh: return @@ -268,7 +268,7 @@ func (c *Client) Listen(onEvent func(raw []byte)) { } } -// listenOnce connects to the NapCat WebSocket and reads events until the +// listenOnce connects to the OneBot WebSocket and reads events until the // connection drops or Stop is called. func (c *Client) listenOnce(onEvent func(raw []byte)) { wsURL := fmt.Sprintf("ws://%s:%s/", c.addr, c.port) @@ -282,7 +282,7 @@ func (c *Client) listenOnce(onEvent func(raw []byte)) { dialer.Proxy = netproxy.ProxyFunc(c.useProxy) conn, _, err := dialer.Dial(wsURL, header) if err != nil { - postLog.Error(fmt.Sprintf("[Napcat] Failed to connect to NapCat WebSocket: %v", err)) + postLog.Error(fmt.Sprintf("[OneBot] Failed to connect to OneBot WebSocket: %v", err)) return } @@ -298,7 +298,7 @@ func (c *Client) listenOnce(onEvent func(raw []byte)) { conn.Close() }() - postLog.Info(fmt.Sprintf("[Napcat] Connected to NapCat WebSocket at %s", wsURL)) + postLog.Info(fmt.Sprintf("[OneBot] Connected to OneBot WebSocket at %s", wsURL)) for { select { @@ -309,7 +309,7 @@ func (c *Client) listenOnce(onEvent func(raw []byte)) { _, msgBytes, err := conn.ReadMessage() if err != nil { - postLog.Error(fmt.Sprintf("[Napcat] WebSocket read error: %v", err)) + postLog.Error(fmt.Sprintf("[OneBot] WebSocket read error: %v", err)) return } diff --git a/internal/controller/pipes/qq_napcat/qq.go b/internal/controller/pipes/qq_onebot/qq.go similarity index 81% rename from internal/controller/pipes/qq_napcat/qq.go rename to internal/controller/pipes/qq_onebot/qq.go index 21da416..2cc03db 100644 --- a/internal/controller/pipes/qq_napcat/qq.go +++ b/internal/controller/pipes/qq_onebot/qq.go @@ -1,4 +1,4 @@ -package qq_napcat +package qq_onebot import ( "encoding/json" @@ -12,7 +12,7 @@ import ( "nukumizu-backend/postLog" ) -// oneBotEvent mirrors a OneBot 11 event pushed over the NapCat WebSocket. +// oneBotEvent mirrors a OneBot 11 event pushed over the OneBot WebSocket. // Only "message" events are handled; notice/request/meta_event are ignored. type oneBotEvent struct { PostType string `json:"post_type"` // Identifies "message", "notice", "request", or "meta_event" @@ -29,24 +29,24 @@ type oneBotEvent struct { SubType string `json:"sub_type"` // The subtype of the message, e.g., "normal", "anonymous", etc. } -// QQController handles QQ Bot interactions by connecting directly to NapCat. +// QQController handles QQ Bot interactions by connecting directly to OneBot. type QQController struct { cfg config.QQConfig - napcatClient *Client + onebotClient *Client } -// NewQQController creates a new QQ (Napcat) controller. +// NewQQController creates a new QQ (OneBot) controller. func NewQQController(cfg config.QQConfig) *QQController { q := &QQController{cfg: cfg} if cfg.Enabled { - q.napcatClient = NewClient(cfg.NapcatAddr, cfg.NapcatPort, cfg.NapcatToken, cfg.NetworkUseProxy) + q.onebotClient = NewClient(cfg.OneBotAddr, cfg.OneBotPort, cfg.OneBotToken, cfg.NetworkUseProxy) } return q } // Name returns the controller name. func (q *QQController) Name() string { - return "qq(napcat)" + return "qq(onebot)" } // Start initializes the QQ controller and starts the NapCat WebSocket listener. @@ -55,19 +55,19 @@ func (q *QQController) Start() error { // postLog.Info("QQ (Napcat) controller is disabled") return nil } - if q.napcatClient == nil { - postLog.Warning("QQ (Napcat) controller enabled but NapCat client is nil") + if q.onebotClient == nil { + postLog.Warning("QQ (OneBot) controller enabled but OneBot client is nil") return nil } - postLog.Info("QQ (Napcat) controller started, connecting to NapCat WebSocket...") + postLog.Info("QQ (OneBot) controller started, connecting to OneBot WebSocket...") go func() { defer func() { if r := recover(); r != nil { - postLog.Error(fmt.Sprintf("Napcat WS listener panic recovered: %v", r)) + postLog.Error(fmt.Sprintf("OneBot WS listener panic recovered: %v", r)) } }() - q.napcatClient.Listen(q.handleNapcatEvent) + q.onebotClient.Listen(q.handleOneBotEvent) }() return nil @@ -75,10 +75,10 @@ func (q *QQController) Start() error { // Stop shuts down the QQ controller and its WebSocket listener. func (q *QQController) Stop() { - if q.napcatClient != nil { - q.napcatClient.Stop() + if q.onebotClient != nil { + q.onebotClient.Stop() } - postLog.Info("QQ (Napcat) controller stopped") + postLog.Info("QQ (OneBot) controller stopped") } // IsEnabled returns whether the controller is enabled. @@ -92,11 +92,11 @@ func (q *QQController) IsMarkdown() bool { return q.cfg.Markdown } -// handleNapcatEvent processes a raw OneBot event received from the NapCat WebSocket. -func (q *QQController) handleNapcatEvent(raw []byte) { +// handleOneBotEvent processes a raw OneBot event received from the OneBot WebSocket. +func (q *QQController) handleOneBotEvent(raw []byte) { var ev oneBotEvent if err := json.Unmarshal(raw, &ev); err != nil { - postLog.Debug("Failed to parse NapCat WS event: " + err.Error()) + postLog.Debug("Failed to parse OneBot WS event: " + err.Error()) return } @@ -108,16 +108,16 @@ func (q *QQController) handleNapcatEvent(raw []byte) { return } debugMode := cfg.System.DebugMode - showAction := debugMode && cfg.Debug.ShowNapcatAction + showAction := debugMode && cfg.Debug.ShowOneBotAction - if debugMode && cfg.Debug.ShowNapcatMsg { - postLog.Debug("Napcat WS event received: " + string(raw)) + if debugMode && cfg.Debug.ShowOneBotMsg { + postLog.Debug("OneBot WS event received: " + string(raw)) } // Only handle message events; ignore notice/request/meta_event. if ev.PostType != "message" { if showAction { - postLog.Debug("Ignoring Napcat WS event: " + string(raw)) + postLog.Debug("Ignoring OneBot WS event: " + string(raw)) } return } @@ -126,9 +126,9 @@ func (q *QQController) handleNapcatEvent(raw []byte) { if q.isSelfMessage(ev) && !debugMode { return } - if q.isSelfMessage(ev) && debugMode && cfg.Debug.NapcatIgnoreSelfMsg { + if q.isSelfMessage(ev) && debugMode && cfg.Debug.OneBotIgnoreSelfMsg { if showAction { - postLog.Debug("Ignoring Napcat WS self message: " + string(raw)) + postLog.Debug("Ignoring OneBot WS self message: " + string(raw)) } return } @@ -149,19 +149,19 @@ func (q *QQController) handleNapcatEvent(raw []byte) { response := q.processCommand(cmd) if response == "" { if showAction { - postLog.Debug("Napcat WS command discarded: " + string(raw)) + postLog.Debug("OneBot WS command discarded: " + string(raw)) } return } // Reply in the same chat. if ev.MessageType == "private" { - if _, err := q.napcatClient.SendMsg("private", ev.UserID, response, false, 0); err != nil { - postLog.Warning("Failed to send NapCat private reply: " + err.Error()) + if _, err := q.onebotClient.SendMsg("private", ev.UserID, response, false, 0); err != nil { + postLog.Warning("Failed to send OneBot private reply: " + err.Error()) } } else { - if _, err := q.napcatClient.SendMsg("group", ev.GroupID, response, false, 0); err != nil { - postLog.Warning("Failed to send NapCat group reply: " + err.Error()) + if _, err := q.onebotClient.SendMsg("group", ev.GroupID, response, false, 0); err != nil { + postLog.Warning("Failed to send OneBot group reply: " + err.Error()) } } } @@ -179,8 +179,8 @@ func (q *QQController) processCommand(cmd controller.Command) string { if q.cfg.ListenMethod == "at" { atMention := fmt.Sprintf("[CQ:at,qq=%d]", q.cfg.BotQQID) if !strings.Contains(text, atMention) { - if cfg != nil && cfg.System.DebugMode && cfg.Debug.ShowNapcatAction { - postLog.Debug("Napcat WS message ignored (no @mention): " + text) + if cfg != nil && cfg.System.DebugMode && cfg.Debug.ShowOneBotAction { + postLog.Debug("OneBot WS message ignored (no @mention): " + text) } return "" // Not mentioned, ignore. } @@ -202,10 +202,10 @@ func (q *QQController) processCommand(cmd controller.Command) string { // vs private, trusted groups, admin permissions, and executes it. response, err := controller.GetManager().Trigger(parsed, q.trustedGroupIDs(), q.adminIDs(), q.cfg.ListenMethod) if cfg != nil && cfg.System.DebugMode && cfg.Debug.ShowTriggerCmdEcho { - postLog.Debug(fmt.Sprintf("[qq_napcat] triggered command: \"/%s\" with args: \"%s\" from chatID: %d and senderID: %d", parsed.Command, strings.Join(parsed.Args, ", "), cmd.ChatID, cmd.SenderID)) + postLog.Debug(fmt.Sprintf("[qq_onebot] triggered command: \"/%s\" with args: \"%s\" from chatID: %d and senderID: %d", parsed.Command, strings.Join(parsed.Args, ", "), cmd.ChatID, cmd.SenderID)) } if err != nil { - postLog.Error("Napcat command processing failed: " + err.Error()) + postLog.Error("OneBot command processing failed: " + err.Error()) return "" } return response @@ -341,8 +341,8 @@ func (q *QQController) SendAlert(alert controller.Alert) error { } func (q *QQController) sendGroupMessage(groupID string, message string) { - if q.napcatClient == nil { - postLog.Warning("Cannot send QQ group message: NapCat client not initialized") + if q.onebotClient == nil { + postLog.Warning("Cannot send QQ group message: OneBot client not initialized") return } @@ -352,14 +352,14 @@ func (q *QQController) sendGroupMessage(groupID string, message string) { return } - if _, err := q.napcatClient.SendMsg("group", groupIDInt, message, false, 0); err != nil { + if _, err := q.onebotClient.SendMsg("group", groupIDInt, message, false, 0); err != nil { postLog.Warning(fmt.Sprintf("Failed to send QQ group message to %s: %v", groupID, err)) } } func (q *QQController) sendPrivateMessage(userID string, message string) { - if q.napcatClient == nil { - postLog.Warning("Cannot send QQ private message: NapCat client not initialized") + if q.onebotClient == nil { + postLog.Warning("Cannot send QQ private message: OneBot client not initialized") return } @@ -369,7 +369,7 @@ func (q *QQController) sendPrivateMessage(userID string, message string) { return } - if _, err := q.napcatClient.SendMsg("private", userIDInt, message, false, 0); err != nil { + if _, err := q.onebotClient.SendMsg("private", userIDInt, message, false, 0); err != nil { postLog.Warning(fmt.Sprintf("Failed to send QQ private message to %s: %v", userID, err)) } } diff --git a/main.go b/main.go index f9295fd..706f307 100644 --- a/main.go +++ b/main.go @@ -14,7 +14,7 @@ import ( "nukumizu-backend/global" "nukumizu-backend/internal/controller" "nukumizu-backend/internal/controller/pipes" - "nukumizu-backend/internal/controller/pipes/qq_napcat" + "nukumizu-backend/internal/controller/pipes/qq_onebot" "nukumizu-backend/internal/controller/pipes/telegram" "nukumizu-backend/internal/komari" "nukumizu-backend/internal/node" @@ -72,7 +72,7 @@ func main() { } // Controller settings changed. Each controller reads its settings into - // fields when it is built, and the NapCat and Telegram ones own + // fields when it is built, and the OneBot and Telegram ones own // connections that cannot be re-pointed, so the change is applied by // replacing the whole set rather than reconfiguring it in place. postLog.Info("Controller settings changed; rebuilding every channel") @@ -131,7 +131,7 @@ func main() { initControllers() // Send the bot initialization message to all enabled bot controllers - // (QQ_NapCat, Telegram), then the server list right after it once the + // (QQ_OneBot, Telegram), then the server list right after it once the // initial status refresh has completed so the list reflects the real // online/offline state. if mgr := controller.GetManager(); mgr != nil { @@ -226,7 +226,7 @@ func startWebhookServer(cfg *config.Config) { // own connections that cannot be re-pointed. func buildControllers(cfg *config.Config) []controller.Controller { return []controller.Controller{ - qq_napcat.NewQQController(cfg.ControllerMethod.QQ), + qq_onebot.NewQQController(cfg.ControllerMethod.QQ), telegram.NewTelegramController(cfg.ControllerMethod.Telegram), pipes.NewEmailController(cfg.ControllerMethod.Email), pipes.NewNtfyController(cfg.ControllerMethod.Ntfy),