channel 支持主动 send

Author: linyuan.yang

packages/channel.base/src/ChannelPlugin.ts

@@ -4,7 +4,10 @@ import { SessionService } from "./SessionService";
 
 export interface IChannelService {
   createSessionHandler(session: SessionService): ChannelSessionHandler;
-  dispose?(): void;
+  sendText(sessionId: string, text: string): Promise<void>;
+  sendFile(sessionId: string, file: string | Buffer, fileName?: string): Promise<void>;
+  sendNative(sessionId: string, payload: any): Promise<void>;
+  dispose(): void;
 }
 
 export interface InitSessionContext {

packages/channel.lark/src/LarkService.ts

@@ -147,6 +147,19 @@ export class LarkService implements IChannelService {
     return new LarkSessionHandler(session, this);
   }
 
+  async sendText(sessionId: string, text: string): Promise<void> {
+    await this.sendMarkdownMessage(LarkReceiveIdType.ChatId, sessionId, text);
+  }
+
+  async sendFile(sessionId: string, file: string | Buffer, fileName?: string): Promise<void> {
+    await this.sendFileMessage(LarkReceiveIdType.ChatId, sessionId, file, fileName);
+  }
+
+  async sendNative(sessionId: string, payload: any): Promise<void> {
+    const content = typeof payload === 'string' ? payload : JSON.stringify(payload);
+    await this.sendMessage(LarkReceiveIdType.ChatId, sessionId, 'interactive', content);
+  }
+
   dispose() {
     try { this.larkWsClient?.close(); } catch (_) {}
     this.tenantAccessToken = '';

packages/channel.onebot/src/OnebotService.ts

@@ -50,6 +50,20 @@ export class OnebotService implements IChannelService {
     return new OnebotSessionHandler(session, this);
   }
 
+  private parseSessionTarget(sessionId: string): { userId?: number; groupId?: number } {
+    const parts = sessionId.split(':');
+    if (parts[1] === 'group') return { groupId: Number(parts[2]), userId: Number(parts[3]) };
+    return { userId: Number(parts[2]) };
+  }
+
+  async sendText(sessionId: string, text: string): Promise<void> {
+    await this.sendTextMessage(this.parseSessionTarget(sessionId), text);
+  }
+
+  async sendFile(_sessionId: string, _file: string | Buffer, _fileName?: string): Promise<void> {}
+
+  async sendNative(_sessionId: string, _payload: any): Promise<void> {}
+
   dispose() {
     for (const ws of this.connections) {
       try { ws.close(); } catch (_) {}

packages/channel.slack/src/SlackService.ts

@@ -40,6 +40,20 @@ export class SlackService implements IChannelService {
     return new SlackSessionHandler(session, this);
   }
 
+  async sendText(sessionId: string, text: string): Promise<void> {
+    await this.sendMessage(sessionId, text);
+  }
+
+  async sendFile(_sessionId: string, _file: string | Buffer, _fileName?: string): Promise<void> {}
+
+  async sendNative(sessionId: string, payload: any): Promise<void> {
+    await this.app.client.chat.postMessage({
+      channel: sessionId,
+      text: payload.text ?? '',
+      ...(payload.blocks ? { blocks: payload.blocks } : {}),
+    });
+  }
+
   dispose() {
     this.app.stop().catch(() => {});
   }

packages/channel.wechat/src/WechatService.ts

@@ -53,6 +53,16 @@ export class WechatService implements IChannelService {
     return new WechatSessionHandler(session, this);
   }
 
+  async sendText(sessionId: string, text: string): Promise<void> {
+    await this.sendTextMessage(sessionId, text);
+  }
+
+  async sendFile(sessionId: string, file: string | Buffer, fileName?: string): Promise<void> {
+    await this.sendFileMessage(sessionId, file, fileName);
+  }
+
+  async sendNative(_sessionId: string, _payload: any): Promise<void> {}
+
   dispose(): void {
     this._running = false;
     this._abortController?.abort();

packages/channel.wecom/src/WecomService.ts

@@ -58,6 +58,18 @@ export class WecomService implements IChannelService {
     return new WecomSessionHandler(session, this);
   }
 
+  async sendText(sessionId: string, text: string): Promise<void> {
+    await this.sendMessage(sessionId, { msgtype: 'markdown', markdown: { content: text } } as any);
+  }
+
+  async sendFile(sessionId: string, file: string | Buffer, fileName?: string): Promise<void> {
+    await this.sendFileMessage(sessionId, file, fileName);
+  }
+
+  async sendNative(sessionId: string, payload: any): Promise<void> {
+    await this.sendMessage(sessionId, payload);
+  }
+
   dispose() {
     try { this.wsClient.disconnect(); } catch (_) {}
   }

packages/channel.xiaoai/src/XiaoaiService.ts

@@ -5,6 +5,7 @@ import {
 import { login } from './mi/account';
 import { getDeviceList, findDeviceByName } from './mi/mina';
 import { MessagePoller, type PollingMessage } from './polling';
+import { speak } from './speaker';
 import type { AuthedAccount } from './mi/types';
 import { XiaoaiSessionHandler } from './XiaoaiSessionHandler';
 
@@ -29,6 +30,7 @@ export interface XiaoaiServiceOptions {
 export class XiaoaiService implements IChannelService {
   private authed: AuthedAccount | undefined;
   private poller: MessagePoller | undefined;
+  private deviceId: string = '';
   private logger?: ILogger;
   private options: XiaoaiServiceOptions;
 
@@ -41,6 +43,16 @@ export class XiaoaiService implements IChannelService {
     return new XiaoaiSessionHandler(session, this);
   }
 
+  async sendText(_sessionId: string, text: string): Promise<void> {
+    if (!this.authed || !this.deviceId) return;
+    await speak(this.authed, this.deviceId, text, {
+      chunkLimit: this.options.textChunkLimit,
+      volume: this.options.volume,
+    });
+  }
+  async sendFile(_sessionId: string, _file: string | Buffer, _fileName?: string): Promise<void> {}
+  async sendNative(_sessionId: string, _payload: any): Promise<void> {}
+
   getAuthedAccount(): AuthedAccount | undefined {
     return this.authed;
   }
@@ -75,6 +87,7 @@ export class XiaoaiService implements IChannelService {
       (msg) => this.handleMessage(msg),
       this.logger,
     );
+    this.deviceId = matched.deviceID;
     this.poller.startDevice(matched.deviceID, device);
   }
 

packages/channel.xiaoai/tsconfig.tsbuildinfo

@@ -201,6 +201,27 @@ export class ChannelManager {
     getChannel(channelId: string) { return config.getChannel(channelId); }
     getService(channelId: string) { return this.services.get(channelId); }
 
+    async sendText(channelId: string, sessionId: string, text: string): Promise<boolean> {
+        const service = this.services.get(channelId);
+        if (!service) return false;
+        await service.sendText(sessionId, text);
+        return true;
+    }
+
+    async sendFile(channelId: string, sessionId: string, file: string | Buffer, fileName?: string): Promise<boolean> {
+        const service = this.services.get(channelId);
+        if (!service) return false;
+        await service.sendFile(sessionId, file, fileName);
+        return true;
+    }
+
+    async sendNative(channelId: string, sessionId: string, payload: any): Promise<boolean> {
+        const service = this.services.get(channelId);
+        if (!service) return false;
+        await service.sendNative(sessionId, payload);
+        return true;
+    }
+
     async loadPlugin(moduleOrPath: string): Promise<ChannelPlugin | undefined> {
         const plugin = this.pluginLoader.loadPlugin(moduleOrPath);
         if (plugin) this.plugins.set(plugin.type, plugin);

packages/sbot/src/Channel/ChannelManager.ts

@@ -1391,6 +1391,31 @@ class HttpServer {
             await database.destroy(database.channelSession, { where: { id } });
         }));
 
+        app.post('/api/channels/:channelId/send', api(async req => {
+            const channelId = req.params.channelId as string;
+            const { sessionId, type, content, payload } = req.body as Record<string, any>;
+            if (!sessionId) throwBad('sessionId is required');
+            if (!type) throwBad('type is required');
+            let ok: boolean;
+            switch (type) {
+                case 'text':
+                    if (!content) throwBad('content is required for type "text"');
+                    ok = await channelManager.sendText(channelId, sessionId, content);
+                    break;
+                case 'file':
+                    if (!content) throwBad('content (file path) is required for type "file"');
+                    ok = await channelManager.sendFile(channelId, sessionId, content, req.body.fileName);
+                    break;
+                case 'native':
+                    if (!payload) throwBad('payload is required for type "native"');
+                    ok = await channelManager.sendNative(channelId, sessionId, payload);
+                    break;
+                default:
+                    throwBad(`Unknown type "${type}", expected "text" | "file" | "native"`);
+            }
+            if (!ok) throwBad(`Channel "${channelId}" not found or not running`);
+        }));
+
         // --- QR code login ---
         // Supports both /api/channel-plugins/:type/qrcode/:key (add flow)
         // and /api/channels/:id/qrcode/:key (edit flow, auto-persists)