@nextclaw/channel-runtime 0.1.21 → 0.1.23

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NextClaw contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -175,14 +175,32 @@ declare class QQChannel extends BaseChannel<Config["channels"]["qq"]> {
     private bot;
     private processedIds;
     private processedSet;
+    private reconnectTimer;
+    private connectTask;
+    private reconnectAttempt;
+    private readonly reconnectBaseMs;
+    private readonly reconnectMaxMs;
     constructor(config: Config["channels"]["qq"], bus: MessageBus);
     start(): Promise<void>;
     stop(): Promise<void>;
     send(msg: OutboundMessage): Promise<void>;
     private handleIncoming;
+    private resolveSenderName;
+    private decorateSpeakerPrefix;
+    private sanitizeSpeakerToken;
     private isDuplicate;
     private sendWithTokenRetry;
     private isTokenExpiredError;
+    private tryConnect;
+    private connect;
+    private createBot;
+    private handleSessionDead;
+    private scheduleReconnect;
+    private clearReconnectTimer;
+    private teardownBot;
+    private safeStopBot;
+    private getBackoffDelayMs;
+    private formatError;
 }
 
 declare class SlackChannel extends BaseChannel<Config["channels"]["slack"]> {
@@ -219,6 +237,7 @@ declare class TelegramChannel extends BaseChannel<Config["channels"]["telegram"]
     private startTyping;
     private stopTyping;
     private resolveAccountId;
+    private maybeAddAckReaction;
     private isAllowedByPolicy;
     private resolveMentionState;
 }

package/dist/index.js

@@ -2414,6 +2414,7 @@ function sleep3(ms) {
 import {
   Bot,
   ReceiverMode,
+  SessionEvents,
   segment
 } from "qq-official-bot";
 var QQChannel = class extends BaseChannel {
@@ -2421,38 +2422,31 @@ var QQChannel = class extends BaseChannel {
   bot = null;
   processedIds = [];
   processedSet = /* @__PURE__ */ new Set();
+  reconnectTimer = null;
+  connectTask = null;
+  reconnectAttempt = 0;
+  reconnectBaseMs = 1e3;
+  reconnectMaxMs = 6e4;
   constructor(config, bus) {
     super(config, bus);
   }
   async start() {
-    this.running = true;
     if (!this.config.appId || !this.config.secret) {
+      this.running = false;
       throw new Error("QQ appId/appSecret not configured");
     }
-    this.bot = new Bot({
-      appid: this.config.appId,
-      secret: this.config.secret,
-      mode: ReceiverMode.WEBSOCKET,
-      intents: ["C2C_MESSAGE_CREATE", "GROUP_AT_MESSAGE_CREATE"],
-      removeAt: true,
-      logLevel: "info"
-    });
-    this.bot.on("message.private", async (event) => {
-      await this.handleIncoming(event);
-    });
-    this.bot.on("message.group", async (event) => {
-      await this.handleIncoming(event);
-    });
-    await this.bot.start();
-    console.log("QQ bot connected");
+    this.running = true;
+    this.reconnectAttempt = 0;
+    this.clearReconnectTimer();
+    this.tryConnect("startup");
   }
   async stop() {
     this.running = false;
-    if (this.bot) {
-      this.bot.removeAllListeners("message.private");
-      this.bot.removeAllListeners("message.group");
-      await this.bot.stop();
-      this.bot = null;
+    this.clearReconnectTimer();
+    this.reconnectAttempt = 0;
+    await this.teardownBot();
+    if (this.connectTask) {
+      await this.connectTask;
     }
   }
   async send(msg) {
@@ -2497,7 +2491,8 @@ var QQChannel = class extends BaseChannel {
       return;
     }
     const content = event.raw_message?.trim() ?? "";
-    const safeContent = content || "[empty message]";
+    const normalizedContent = content || "[empty message]";
+    const senderName = this.resolveSenderName(rawEvent);
     let chatId = senderId;
     let messageType = "private";
     const qqMeta = {};
@@ -2507,21 +2502,36 @@ var QQChannel = class extends BaseChannel {
       chatId = groupId;
       qqMeta.groupId = groupId;
       qqMeta.userId = senderId;
+      if (senderName) {
+        qqMeta.userName = senderName;
+      }
     } else if (event.message_type === "guild") {
       messageType = "guild";
       chatId = event.channel_id ?? "";
       qqMeta.guildId = event.guild_id;
       qqMeta.channelId = event.channel_id;
       qqMeta.userId = senderId;
+      if (senderName) {
+        qqMeta.userName = senderName;
+      }
     } else if (event.sub_type === "direct") {
       messageType = "direct";
       chatId = event.guild_id ?? "";
       qqMeta.guildId = event.guild_id;
       qqMeta.userId = senderId;
+      if (senderName) {
+        qqMeta.userName = senderName;
+      }
     } else {
       qqMeta.userId = senderId;
     }
     qqMeta.messageType = messageType;
+    const safeContent = this.decorateSpeakerPrefix({
+      content: normalizedContent,
+      messageType,
+      senderId,
+      senderName
+    });
     if (!chatId) {
       return;
     }
@@ -2539,6 +2549,42 @@ var QQChannel = class extends BaseChannel {
       }
     });
   }
+  resolveSenderName(rawEvent) {
+    const candidates = [
+      rawEvent.sender?.card,
+      rawEvent.sender?.nickname,
+      rawEvent.sender?.nick,
+      rawEvent.sender?.username
+    ];
+    for (const value of candidates) {
+      if (typeof value !== "string") {
+        continue;
+      }
+      const normalized = value.trim();
+      if (normalized) {
+        return normalized;
+      }
+    }
+    return null;
+  }
+  decorateSpeakerPrefix(params) {
+    if (params.messageType !== "group" && params.messageType !== "guild") {
+      return params.content;
+    }
+    const userId = this.sanitizeSpeakerToken(params.senderId);
+    if (!userId) {
+      return params.content;
+    }
+    const name = this.sanitizeSpeakerToken(params.senderName ?? "");
+    const speakerFields = [`user_id=${userId}`];
+    if (name) {
+      speakerFields.push(`name=${name}`);
+    }
+    return `[speaker:${speakerFields.join(";")}] ${params.content}`;
+  }
+  sanitizeSpeakerToken(value) {
+    return value.replace(/[\r\n;\]]/g, " ").trim();
+  }
   isDuplicate(messageId) {
     if (this.processedSet.has(messageId)) {
       return true;
@@ -2568,6 +2614,117 @@ var QQChannel = class extends BaseChannel {
     const message = error instanceof Error ? error.message : String(error);
     return message.includes("code(11244)") || message.toLowerCase().includes("token not exist or expire");
   }
+  tryConnect(trigger) {
+    if (!this.running || this.bot || this.connectTask) {
+      return;
+    }
+    this.connectTask = this.connect(trigger).finally(() => {
+      this.connectTask = null;
+    });
+  }
+  async connect(trigger) {
+    let candidate = null;
+    try {
+      candidate = this.createBot();
+      await candidate.start();
+      if (!this.running) {
+        await this.safeStopBot(candidate);
+        return;
+      }
+      this.bot = candidate;
+      this.reconnectAttempt = 0;
+      console.log("QQ bot connected");
+    } catch (error) {
+      if (candidate) {
+        await this.safeStopBot(candidate);
+      }
+      if (!this.running) {
+        return;
+      }
+      this.reconnectAttempt += 1;
+      const delayMs = this.getBackoffDelayMs(this.reconnectAttempt);
+      console.error(
+        `[qq] start failed (${trigger}, attempt ${this.reconnectAttempt}), retry in ${delayMs}ms: ${this.formatError(error)}`
+      );
+      this.scheduleReconnect(delayMs, `${trigger}-retry`);
+    }
+  }
+  createBot() {
+    const bot = new Bot({
+      appid: this.config.appId,
+      secret: this.config.secret,
+      mode: ReceiverMode.WEBSOCKET,
+      intents: ["C2C_MESSAGE_CREATE", "GROUP_AT_MESSAGE_CREATE"],
+      removeAt: true,
+      logLevel: "info"
+    });
+    bot.on("message.private", async (event) => {
+      await this.handleIncoming(event);
+    });
+    bot.on("message.group", async (event) => {
+      await this.handleIncoming(event);
+    });
+    bot.sessionManager.on(SessionEvents.DEAD, () => {
+      void this.handleSessionDead(bot);
+    });
+    return bot;
+  }
+  async handleSessionDead(bot) {
+    if (!this.running || this.bot !== bot) {
+      return;
+    }
+    this.bot = null;
+    await this.safeStopBot(bot);
+    this.reconnectAttempt += 1;
+    const delayMs = this.getBackoffDelayMs(this.reconnectAttempt);
+    console.error(`[qq] session dead, reconnect in ${delayMs}ms`);
+    this.scheduleReconnect(delayMs, "session-dead");
+  }
+  scheduleReconnect(delayMs, trigger) {
+    if (!this.running) {
+      return;
+    }
+    this.clearReconnectTimer();
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.tryConnect(trigger);
+    }, delayMs);
+  }
+  clearReconnectTimer() {
+    if (!this.reconnectTimer) {
+      return;
+    }
+    clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = null;
+  }
+  async teardownBot() {
+    if (!this.bot) {
+      return;
+    }
+    const bot = this.bot;
+    this.bot = null;
+    await this.safeStopBot(bot);
+  }
+  async safeStopBot(bot) {
+    bot.removeAllListeners("message.private");
+    bot.removeAllListeners("message.group");
+    bot.sessionManager.removeAllListeners(SessionEvents.DEAD);
+    try {
+      await bot.stop();
+    } catch {
+    }
+  }
+  getBackoffDelayMs(attempt) {
+    const jitter = Math.floor(Math.random() * 500);
+    const exp = Math.min(this.reconnectMaxMs, this.reconnectBaseMs * 2 ** Math.max(0, attempt - 1));
+    return Math.min(this.reconnectMaxMs, exp + jitter);
+  }
+  formatError(error) {
+    if (error instanceof Error) {
+      return error.stack ?? error.message;
+    }
+    return String(error);
+  }
 };
 
 // src/channels/slack.ts
@@ -2988,6 +3145,12 @@ Just send me a text message to chat!`;
         contentParts.push(`[${mediaType}: ${finalPath}]`);
       }
     }
+    await this.maybeAddAckReaction({
+      message,
+      chatId,
+      isGroup,
+      mentionState
+    });
     const content = contentParts.length ? contentParts.join("\n") : "[empty message]";
     this.startTyping(chatId);
     try {
@@ -3024,6 +3187,35 @@ Just send me a text message to chat!`;
     const accountId = this.config.accountId?.trim();
     return accountId || "default";
   }
+  async maybeAddAckReaction(params) {
+    if (!this.bot) {
+      return;
+    }
+    if (typeof params.message.message_id !== "number") {
+      return;
+    }
+    const emoji = (this.config.ackReaction ?? "\u{1F440}").trim();
+    if (!emoji) {
+      return;
+    }
+    const shouldAck = shouldSendAckReaction({
+      scope: this.config.ackReactionScope,
+      isDirect: !params.isGroup,
+      isGroup: params.isGroup,
+      requireMention: params.mentionState.requireMention,
+      wasMentioned: params.mentionState.wasMentioned
+    });
+    if (!shouldAck) {
+      return;
+    }
+    const reaction = [{ type: "emoji", emoji }];
+    try {
+      await this.bot.setMessageReaction(Number(params.chatId), params.message.message_id, {
+        reaction
+      });
+    } catch {
+    }
+  }
   isAllowedByPolicy(params) {
     if (!params.isGroup) {
       if (this.config.dmPolicy === "disabled") {
@@ -3150,6 +3342,25 @@ function inferMediaMimeType(mediaType) {
   }
   return void 0;
 }
+function shouldSendAckReaction(params) {
+  const scope = params.scope ?? "all";
+  if (scope === "off") {
+    return false;
+  }
+  if (scope === "all") {
+    return true;
+  }
+  if (scope === "direct") {
+    return params.isDirect;
+  }
+  if (scope === "group-all") {
+    return params.isGroup;
+  }
+  if (scope === "group-mentions") {
+    return params.isGroup && params.requireMention && params.wasMentioned;
+  }
+  return false;
+}
 function markdownToTelegramHtml(text) {
   if (!text) {
     return "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/channel-runtime",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "private": false,
   "description": "Runtime implementations for NextClaw builtin channel plugins.",
   "type": "module",
@@ -15,7 +15,7 @@
   ],
   "dependencies": {
     "@larksuiteoapi/node-sdk": "^1.58.0",
-    "@nextclaw/core": "^0.6.38",
+    "@nextclaw/core": "^0.6.40",
     "@slack/socket-mode": "^1.3.3",
     "@slack/web-api": "^7.6.0",
     "dingtalk-stream": "^2.1.4",