@nextclaw/channel-runtime 0.1.1 → 0.1.2

package/dist/index.d.ts

@@ -57,7 +57,7 @@ declare class DingTalkChannel extends BaseChannel<Config["channels"]["dingtalk"]
 declare class DiscordChannel extends BaseChannel<Config["channels"]["discord"]> {
     name: string;
     private client;
-    private typingTasks;
+    private readonly typingController;
     constructor(config: Config["channels"]["discord"], bus: MessageBus);
     start(): Promise<void>;
     stop(): Promise<void>;
@@ -192,7 +192,7 @@ declare class TelegramChannel extends BaseChannel<Config["channels"]["telegram"]
     private sessionManager?;
     name: string;
     private bot;
-    private typingTasks;
+    private readonly typingController;
     private transcriber;
     constructor(config: Config["channels"]["telegram"], bus: MessageBus, groqApiKey?: string, sessionManager?: SessionManager | undefined);
     start(): Promise<void>;

package/dist/index.js

@@ -182,15 +182,73 @@ import { mkdirSync, writeFileSync } from "fs";
 // src/utils/helpers.ts
 import { getDataPath } from "@nextclaw/core";
 
+// src/channels/typing-controller.ts
+var ChannelTypingController = class {
+  heartbeatMs;
+  autoStopMs;
+  sendTyping;
+  tasks = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.heartbeatMs = Math.max(1e3, Math.floor(options.heartbeatMs));
+    this.autoStopMs = Math.max(this.heartbeatMs, Math.floor(options.autoStopMs));
+    this.sendTyping = options.sendTyping;
+  }
+  start(targetId) {
+    this.stop(targetId);
+    void this.sendTyping(targetId);
+    const heartbeat = setInterval(() => {
+      void this.sendTyping(targetId);
+    }, this.heartbeatMs);
+    const autoStop = setTimeout(() => {
+      this.stop(targetId);
+    }, this.autoStopMs);
+    this.tasks.set(targetId, {
+      heartbeat,
+      autoStop
+    });
+  }
+  stop(targetId) {
+    const task = this.tasks.get(targetId);
+    if (!task) {
+      return;
+    }
+    clearInterval(task.heartbeat);
+    clearTimeout(task.autoStop);
+    this.tasks.delete(targetId);
+  }
+  stopAll() {
+    for (const targetId of this.tasks.keys()) {
+      this.stop(targetId);
+    }
+  }
+};
+
 // src/channels/discord.ts
 var DEFAULT_MEDIA_MAX_MB = 8;
 var MEDIA_FETCH_TIMEOUT_MS = 15e3;
+var TYPING_HEARTBEAT_MS = 8e3;
+var TYPING_AUTO_STOP_MS = 45e3;
 var DiscordChannel = class extends BaseChannel {
   name = "discord";
   client = null;
-  typingTasks = /* @__PURE__ */ new Map();
+  typingController;
   constructor(config, bus) {
     super(config, bus);
+    this.typingController = new ChannelTypingController({
+      heartbeatMs: TYPING_HEARTBEAT_MS,
+      autoStopMs: TYPING_AUTO_STOP_MS,
+      sendTyping: async (channelId) => {
+        if (!this.client) {
+          return;
+        }
+        const channel = this.client.channels.cache.get(channelId);
+        if (!channel || !channel.isTextBased()) {
+          return;
+        }
+        const textChannel = channel;
+        await textChannel.sendTyping();
+      }
+    });
   }
   async start() {
     if (!this.config.token) {
@@ -211,10 +269,7 @@ var DiscordChannel = class extends BaseChannel {
   }
   async stop() {
     this.running = false;
-    for (const task of this.typingTasks.values()) {
-      clearInterval(task);
-    }
-    this.typingTasks.clear();
+    this.typingController.stopAll();
     if (this.client) {
       await this.client.destroy();
       this.client = null;
@@ -285,18 +340,23 @@ var DiscordChannel = class extends BaseChannel {
     }
     const replyTo = message.reference?.messageId ?? null;
     this.startTyping(channelId);
-    await this.handleMessage({
-      senderId,
-      chatId: channelId,
-      content: contentParts.length ? contentParts.join("\n") : "[empty message]",
-      attachments,
-      metadata: {
-        message_id: message.id,
-        guild_id: message.guildId,
-        reply_to: replyTo,
-        ...attachmentIssues.length ? { attachment_issues: attachmentIssues } : {}
-      }
-    });
+    try {
+      await this.handleMessage({
+        senderId,
+        chatId: channelId,
+        content: contentParts.length ? contentParts.join("\n") : "[empty message]",
+        attachments,
+        metadata: {
+          message_id: message.id,
+          guild_id: message.guildId,
+          reply_to: replyTo,
+          ...attachmentIssues.length ? { attachment_issues: attachmentIssues } : {}
+        }
+      });
+    } catch (err) {
+      this.stopTyping(channelId);
+      throw err;
+    }
   }
   resolveProxyAgent() {
     const proxy = this.config.proxy?.trim();
@@ -437,26 +497,10 @@ var DiscordChannel = class extends BaseChannel {
     }
   }
   startTyping(channelId) {
-    this.stopTyping(channelId);
-    if (!this.client) {
-      return;
-    }
-    const channel = this.client.channels.cache.get(channelId);
-    if (!channel || !channel.isTextBased()) {
-      return;
-    }
-    const textChannel = channel;
-    const task = setInterval(() => {
-      void textChannel.sendTyping();
-    }, 8e3);
-    this.typingTasks.set(channelId, task);
+    this.typingController.start(channelId);
   }
   stopTyping(channelId) {
-    const task = this.typingTasks.get(channelId);
-    if (task) {
-      clearInterval(task);
-      this.typingTasks.delete(channelId);
-    }
+    this.typingController.stop(channelId);
   }
 };
 function sanitizeAttachmentName(name) {
@@ -2167,6 +2211,8 @@ var GroqTranscriptionProvider = class {
 // src/channels/telegram.ts
 import { join as join3 } from "path";
 import { mkdirSync as mkdirSync3 } from "fs";
+var TYPING_HEARTBEAT_MS2 = 4e3;
+var TYPING_AUTO_STOP_MS2 = 45e3;
 var BOT_COMMANDS = [
   { command: "start", description: "Start the bot" },
   { command: "reset", description: "Reset conversation history" },
@@ -2177,10 +2223,17 @@ var TelegramChannel = class extends BaseChannel {
     super(config, bus);
     this.sessionManager = sessionManager;
     this.transcriber = new GroqTranscriptionProvider(groqApiKey ?? null);
+    this.typingController = new ChannelTypingController({
+      heartbeatMs: TYPING_HEARTBEAT_MS2,
+      autoStopMs: TYPING_AUTO_STOP_MS2,
+      sendTyping: async (chatId) => {
+        await this.bot?.sendChatAction(Number(chatId), "typing");
+      }
+    });
   }
   name = "telegram";
   bot = null;
-  typingTasks = /* @__PURE__ */ new Map();
+  typingController;
   transcriber;
   async start() {
     if (!this.config.token) {
@@ -2246,10 +2299,7 @@ Just send me a text message to chat!`;
   }
   async stop() {
     this.running = false;
-    for (const task of this.typingTasks.values()) {
-      clearInterval(task);
-    }
-    this.typingTasks.clear();
+    this.typingController.stopAll();
     if (this.bot) {
       await this.bot.stopPolling();
       this.bot = null;
@@ -2326,35 +2376,29 @@ Just send me a text message to chat!`;
     }
     const content = contentParts.length ? contentParts.join("\n") : "[empty message]";
     this.startTyping(chatId);
-    await this.dispatchToBus(senderId, chatId, content, attachments, {
-      message_id: message.message_id,
-      user_id: sender.id,
-      username: sender.username,
-      first_name: sender.firstName,
-      sender_type: sender.type,
-      is_bot: sender.isBot,
-      is_group: message.chat.type !== "private"
-    });
+    try {
+      await this.dispatchToBus(senderId, chatId, content, attachments, {
+        message_id: message.message_id,
+        user_id: sender.id,
+        username: sender.username,
+        first_name: sender.firstName,
+        sender_type: sender.type,
+        is_bot: sender.isBot,
+        is_group: message.chat.type !== "private"
+      });
+    } catch (err) {
+      this.stopTyping(chatId);
+      throw err;
+    }
   }
   async dispatchToBus(senderId, chatId, content, attachments, metadata) {
     await this.handleMessage({ senderId, chatId, content, attachments, metadata });
   }
   startTyping(chatId) {
-    this.stopTyping(chatId);
-    if (!this.bot) {
-      return;
-    }
-    const task = setInterval(() => {
-      void this.bot?.sendChatAction(Number(chatId), "typing");
-    }, 4e3);
-    this.typingTasks.set(chatId, task);
+    this.typingController.start(chatId);
   }
   stopTyping(chatId) {
-    const task = this.typingTasks.get(chatId);
-    if (task) {
-      clearInterval(task);
-      this.typingTasks.delete(chatId);
-    }
+    this.typingController.stop(chatId);
   }
 };
 function resolveSender(message) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/channel-runtime",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "private": false,
   "description": "Runtime implementations for NextClaw builtin channel plugins.",
   "type": "module",