@alemonjs/qq-bot 2.1.30 → 2.1.32

package/dist/index.html

@@ -1,4 +1,4 @@
-<!DOCTYPE html>
+<!doctype html>
 <html lang="en" id="__gui">
   <head>
     <meta charset="UTF-8" />

package/lib/config.d.ts

@@ -6,7 +6,15 @@ export type Options = {
     master_id?: string[];
     markdownToText?: boolean;
     hideUnsupported?: boolean | number;
+    bots?: Record<string, Omit<sdkOptions, 'app_id'> & {
+        app_id?: string;
+    }>;
+    default_bot?: string;
 } & sdkOptions;
 export declare const getQQBotConfig: () => Options;
+export declare const getQQBotBots: () => {
+    bots: Map<string, sdkOptions>;
+    defaultBot?: string;
+};
 export declare const getIdentity: (UserId: string) => readonly [boolean, string];
 export declare const getMaster: (UserId: string) => readonly [boolean, string];

package/lib/config.js

@@ -8,6 +8,28 @@ const getQQBotConfig = () => {
     const bagValue = value[platformFullName] || {};
     return { ...commonValue, ...bagValue };
 };
+const getQQBotBots = () => {
+    const config = getQQBotConfig();
+    const { bots: configuredBots, default_bot, master_id: _masterId, master_key: _masterKey, markdownToText: _markdown, hideUnsupported: _hide, ...common } = config;
+    const bots = new Map();
+    if (configuredBots && Object.keys(configuredBots).length) {
+        for (const [botId, value] of Object.entries(configuredBots)) {
+            if (value.app_id && value.app_id !== botId)
+                throw new Error(`qq-bot bots.${botId}.app_id must match its map key`);
+            if (!value.secret)
+                throw new Error(`qq-bot bots.${botId}.secret is required`);
+            bots.set(botId, { ...common, ...value, app_id: botId, secret: value.secret });
+        }
+    }
+    else if (config.app_id && config.secret) {
+        bots.set(config.app_id, common);
+    }
+    if (bots.size > 1 && !default_bot)
+        throw new Error('qq-bot.default_bot is required when multiple bots are configured');
+    if (default_bot && !bots.has(default_bot))
+        throw new Error(`qq-bot.default_bot ${default_bot} is not configured`);
+    return { bots, defaultBot: default_bot || (bots.size === 1 ? bots.keys().next().value : undefined) };
+};
 const getIdentity = (UserId) => {
     const isMasterUser = UserId ? isMaster(UserId, platform) : false;
     const UserKey = createUserHashKey({
@@ -20,4 +42,4 @@ const getMaster = (UserId) => {
     return getIdentity(UserId);
 };
 
-export { getIdentity, getMaster, getQQBotConfig, platform, platformFullName };
+export { getIdentity, getMaster, getQQBotBots, getQQBotConfig, platform, platformFullName };

package/lib/desktop.js

@@ -2,6 +2,7 @@ import { readFileSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { getConfig, getConfigValue } from 'alemonjs';
+import { getQQBotRegistry } from './index.websoket.js';
 
 const __dirname$1 = dirname(fileURLToPath(import.meta.url));
 const activate = context => {
@@ -22,7 +23,7 @@ const activate = context => {
     webView.onMessage(data => {
         try {
             if (data.type === 'qq-bot.form.save') {
-                const db = data.data;
+                const { bots_json: _botsJson, ...db } = data.data;
                 const config = getConfig();
                 const value = config.value ?? {};
                 value['qq-bot'] = {
@@ -43,6 +44,12 @@ const activate = context => {
                     data: config['qq-bot'] ?? {}
                 });
             }
+            else if (data.type === 'qq-bot.status') {
+                webView.postMessage({
+                    type: 'qq-bot.status',
+                    data: getQQBotRegistry()?.getConnectionStatus() ?? { Platform: 'qq-bot', state: 'stopped', bots: [] }
+                });
+            }
         }
         catch (e) {
             console.error(e);

package/lib/index.js

@@ -1,16 +1,13 @@
-import { definePlatform, getConfigValue } from 'alemonjs';
+import { definePlatform } from 'alemonjs';
 import { start } from './index.webhook.js';
 import { start as start$1 } from './index.websoket.js';
-import { platform } from './config.js';
+import { getQQBotConfig } from './config.js';
+export { platform } from './config.js';
 export { useClient, useMode, useValue } from './hook.js';
 export { QQBotAPI as API } from './sdk/api.js';
 
 const main = () => {
-    let value = getConfigValue();
-    if (!value) {
-        value = {};
-    }
-    const config = value[platform];
+    const config = getQQBotConfig();
     if (config?.route || config?.port || config?.ws) {
         start();
     }
@@ -20,4 +17,4 @@ const main = () => {
 };
 var index = definePlatform({ main });
 
-export { index as default, platform };
+export { index as default };

package/lib/index.webhook.js

@@ -4,6 +4,9 @@ import { getQQBotConfig } from './config.js';
 
 const start = () => {
     const config = getQQBotConfig();
+    if (config.bots && Object.keys(config.bots).length > 1) {
+        throw new Error('qq-bot.bots is only supported by WebSocket mode; remove route/port/ws to use the QQ WebSocket gateway');
+    }
     const { master_id: _, master_key: __, ...cfgConfig } = config;
     const client = new QQBotClient({
         ...cfgConfig

package/lib/index.websoket.d.ts

@@ -1 +1,3 @@
+import { QQBotRegistry } from './sdk/registry';
+export declare const getQQBotRegistry: () => QQBotRegistry;
 export declare const start: () => void;

package/lib/index.websoket.js

@@ -1,9 +1,13 @@
-import { QQBotClients } from './sdk/client.websoket.js';
-import { register } from './register.js';
-import { getQQBotConfig } from './config.js';
+import { getQQBotConfig, getQQBotBots } from './config.js';
+import { QQBotRegistry } from './sdk/registry.js';
 
+let activeRegistry;
+const getQQBotRegistry = () => activeRegistry;
 const start = () => {
     const config = getQQBotConfig();
+    const { bots, defaultBot } = getQQBotBots();
+    const registry = new QQBotRegistry(defaultBot);
+    activeRegistry = registry;
     const notPrivateIntents = [
         'GUILDS',
         'GUILD_MEMBERS',
@@ -28,18 +32,16 @@ const start = () => {
     else {
         intents.push(...notPrivateIntents, ...isGroupIntents, ...pubIntents);
     }
-    const client = new QQBotClients({
-        ...config,
-        intents: config?.intents || intents,
-        is_private: config?.is_private ?? false,
-        sandbox: config?.sandbox ?? false,
-        shard: config?.shard ?? [0, 1],
-        gatewayURL: config?.gatewayURL,
-        base_url_gateway: config?.base_url_gateway,
-        base_url_app_access_token: config?.base_url_app_access_token
-    });
-    void client.connect(config?.gatewayURL);
-    register(client);
+    for (const [botId, botConfig] of bots) {
+        const client = registry.add(botId, {
+            ...botConfig,
+            intents: botConfig.intents || intents,
+            is_private: botConfig.is_private ?? false,
+            sandbox: botConfig.sandbox ?? false,
+            shard: botConfig.shard ?? [0, 1]
+        });
+        void client.connect(botConfig.gatewayURL);
+    }
 };
 
-export { start };
+export { getQQBotRegistry, start };

package/lib/message/group/C2C_MESSAGE_CREATE.d.ts

@@ -1,4 +1,11 @@
 export type C2C_MESSAGE_CREATE_TYPE = {
+    attachments?: {
+        id?: string;
+        url?: string;
+        content_type?: string;
+        filename?: string;
+        size?: number;
+    }[];
     author: {
         id: string;
         user_openid: string;

package/lib/message/group/GROUP_AT_MESSAGE_CREATE.d.ts

@@ -1,4 +1,11 @@
 export interface GROUP_AT_MESSAGE_CREATE_TYPE {
+    attachments?: {
+        id?: string;
+        url?: string;
+        content_type?: string;
+        filename?: string;
+        size?: number;
+    }[];
     author: {
         bot?: boolean;
         id: string;

package/lib/message/group/GROUP_MESSAGE_CREATE.d.ts

@@ -1,4 +1,11 @@
 export interface GROUP_MESSAGE_CREATE_TYPE {
+    attachments?: {
+        id?: string;
+        url?: string;
+        content_type?: string;
+        filename?: string;
+        size?: number;
+    }[];
     author: {
         bot?: boolean;
         id: string;

package/lib/register.d.ts

@@ -1,2 +1,11 @@
+import { cbpPlatform } from 'alemonjs';
 import { QQBotClients } from './sdk/client.websoket';
-export declare const register: (client: QQBotClients) => void;
+export type QQBotRegistration = {
+    onAction: (data: any, consume: (result: any[]) => void) => Promise<void>;
+    onApi: (data: any, consume: (result: any[]) => void) => Promise<void>;
+};
+export declare const register: (client: QQBotClients, options?: {
+    botId?: string;
+    cbp?: ReturnType<typeof cbpPlatform>;
+    bindActions?: boolean;
+}) => QQBotRegistration;

package/lib/register.js

@@ -1,15 +1,19 @@
 import { cbpPlatform, FormatEvent, ResultCode, createResult } from 'alemonjs';
+import { createHash } from 'node:crypto';
+import { stat, readFile } from 'node:fs/promises';
+import { basename } from 'node:path';
 import { GROUP_AT_MESSAGE_CREATE, C2C_MESSAGE_CREATE, DIRECT_MESSAGE_CREATE, AT_MESSAGE_CREATE, MESSAGE_CREATE } from './sends.js';
 import { getQQBotConfig, platform, getMaster, getIdentity } from './config.js';
 
-const register = (client) => {
+const register = (client, options) => {
+    const MAX_MEDIA_SIZE = 100 * 1024 * 1024;
     const config = getQQBotConfig();
-    const botId = String(config?.app_id ?? '');
+    const botId = String(options?.botId ?? config?.app_id ?? '');
     const port = process.env?.port || config?.port || 17117;
     const url = `ws://127.0.0.1:${port}`;
-    const cbp = cbpPlatform(url);
+    const cbp = options?.cbp ?? cbpPlatform(url);
     const createUserAvatarURL = (authorId) => {
-        return `https://q.qlogo.cn/qqapp/${config.app_id}/${authorId}/640`;
+        return `https://q.qlogo.cn/qqapp/${botId}/${authorId}/640`;
     };
     const getGroupMessageMeta = (event) => {
         const author = event?.author;
@@ -39,6 +43,122 @@ const register = (client) => {
             auditTime
         };
     };
+    const getMediaItems = (attachments) => {
+        return (attachments || []).flatMap(attachment => {
+            if (!attachment?.url) {
+                return [];
+            }
+            const mimeType = attachment.content_type || '';
+            const Type = mimeType.startsWith('image/')
+                ? 'image'
+                : mimeType.startsWith('audio/')
+                    ? 'audio'
+                    : mimeType.startsWith('video/')
+                        ? 'video'
+                        : 'file';
+            return [
+                {
+                    Type,
+                    Url: attachment.url,
+                    ...(attachment.filename && { FileName: attachment.filename }),
+                    ...(typeof attachment.size === 'number' && { FileSize: attachment.size }),
+                    ...(mimeType && { MimeType: mimeType })
+                }
+            ];
+        });
+    };
+    const normalizeTarget = (target) => {
+        if (!target?.targetId || !target.scope) {
+            return undefined;
+        }
+        return target;
+    };
+    const validateTargetBot = (target) => {
+        return !target.BotId || target.BotId === botId;
+    };
+    const mediaCache = new Map();
+    const mediaType = (type) => (type === 'image' ? 1 : type === 'video' ? 2 : type === 'audio' ? 3 : 4);
+    const prepareMedia = async (target, params) => {
+        const sources = [params?.url, params?.data, params?.filePath, params?.fileId].filter(value => value !== undefined && value !== '').length;
+        if (sources !== 1) {
+            throw new Error('Provide exactly one media source: url, data, filePath, or fileId');
+        }
+        if (params.fileId) {
+            return { fileId: String(params.fileId), reused: true };
+        }
+        let data = params.data;
+        let buffer;
+        let filePath;
+        let fileSize;
+        let hashes;
+        let name = params.name;
+        let hashSource = String(params.url || '');
+        if (params.filePath) {
+            const metadata = await stat(String(params.filePath));
+            if (!metadata.isFile()) {
+                throw new Error('media filePath must point to a regular file');
+            }
+            if (metadata.size > MAX_MEDIA_SIZE) {
+                throw new Error('QQ media files must not exceed 100 MiB');
+            }
+            filePath = String(params.filePath);
+            fileSize = metadata.size;
+            hashes = await client.getMediaFileHashes(filePath);
+            hashSource = hashes.sha256;
+            name ||= basename(filePath);
+            if (fileSize < 5 * 1024 * 1024) {
+                buffer = await readFile(filePath);
+                data = `base64://${buffer.toString('base64')}`;
+            }
+        }
+        else if (data) {
+            hashSource = data;
+            const value = data.replace(/^base64:\/\//, '');
+            buffer = Buffer.from(value, 'base64');
+            if (buffer.length > MAX_MEDIA_SIZE) {
+                throw new Error('QQ media files must not exceed 100 MiB');
+            }
+        }
+        const key = [botId, target.scope, target.targetId, params.type, createHash('sha256').update(hashSource).digest('hex')].join(':');
+        const cached = mediaCache.get(key);
+        if (cached && (!cached.expiresAt || cached.expiresAt > Date.now())) {
+            return { fileId: cached.fileId, expiresAt: cached.expiresAt, reused: true };
+        }
+        return { key, url: params.url, data, buffer, filePath, fileSize, hashes, name, reused: false };
+    };
+    const uploadMedia = async (target, params) => {
+        if (!validateTargetBot(target)) {
+            throw new Error(`BotId ${target.BotId} is not active`);
+        }
+        if (target.scope !== 'group' && target.scope !== 'c2c') {
+            throw new Error('QQ media upload only supports group and c2c targets');
+        }
+        const prepared = await prepareMedia(target, params);
+        if (prepared.fileId) {
+            return prepared;
+        }
+        const fileType = mediaType(params.type);
+        const value = prepared.filePath && prepared.fileSize && prepared.fileSize >= 5 * 1024 * 1024
+            ? await client.postChunkedRichMedia({
+                scope: target.scope,
+                targetId: target.targetId,
+                fileType,
+                filePath: prepared.filePath,
+                size: prepared.fileSize,
+                hashes: prepared.hashes,
+                name: prepared.name
+            })
+            : prepared.buffer && prepared.buffer.length >= 5 * 1024 * 1024
+                ? await client.postChunkedRichMedia({ scope: target.scope, targetId: target.targetId, fileType, data: prepared.buffer, name: prepared.name })
+                : target.scope === 'group'
+                    ? await client.postRichMediaByGroup(target.targetId, { file_type: fileType, url: prepared.url, file_data: prepared.data, srv_send_msg: false })
+                    : await client.postRichMediaByUser(target.targetId, { file_type: fileType, url: prepared.url, file_data: prepared.data, srv_send_msg: false });
+        const expiresAt = value.ttl ? Date.now() + value.ttl * 1000 : undefined;
+        if (prepared.key) {
+            mediaCache.set(prepared.key, { fileId: value.file_info, expiresAt });
+        }
+        return { fileId: value.file_info, expiresAt, reused: false };
+    };
     const createUserMeta = (UserId, extra = {}) => {
         const [IsMaster, UserKey] = getIdentity(UserId);
         return {
@@ -85,6 +205,7 @@ const register = (client) => {
         })
             .addMessage({ MessageId: meta.messageId })
             .addText({ MessageText: msg?.trim() })
+            .addMedia({ MessageMedia: getMediaItems(event.attachments) })
             .addOpen({ OpenId: meta.openId })
             .add({ tag: 'GROUP_MESSAGE_CREATE' }).value);
     });
@@ -128,6 +249,7 @@ const register = (client) => {
         })
             .addMessage({ MessageId: meta.messageId })
             .addText({ MessageText: msg?.trim() })
+            .addMedia({ MessageMedia: getMediaItems(event.attachments) })
             .addOpen({ OpenId: meta.openId })
             .add({ tag: 'GROUP_AT_MESSAGE_CREATE' }).value);
     });
@@ -147,6 +269,7 @@ const register = (client) => {
         })
             .addMessage({ MessageId: event.id })
             .addText({ MessageText: event.content?.trim() })
+            .addMedia({ MessageMedia: getMediaItems(event.attachments) })
             .addOpen({ OpenId: `C2C:${event.author.user_openid}` })
             .add({ tag: 'C2C_MESSAGE_CREATE' }).value);
     });
@@ -170,6 +293,7 @@ const register = (client) => {
         })
             .addMessage({ MessageId: event.id })
             .addText({ MessageText: msg?.trim() })
+            .addMedia({ MessageMedia: getMediaItems(event.attachments) })
             .addOpen({ OpenId: `DIRECT:${event.guild_id}` })
             .add({ tag: 'DIRECT_MESSAGE_CREATE' }).value);
     });
@@ -195,6 +319,7 @@ const register = (client) => {
         })
             .addMessage({ MessageId: event.id })
             .addText({ MessageText: msg?.trim() })
+            .addMedia({ MessageMedia: getMediaItems(event.attachments) })
             .addOpen({ OpenId: `DIRECT:${event.guild_id}` })
             .add({ tag: 'AT_MESSAGE_CREATE' }).value);
     });
@@ -238,6 +363,7 @@ const register = (client) => {
         })
             .addMessage({ MessageId: event.id })
             .addText({ MessageText: msg?.trim() })
+            .addMedia({ MessageMedia: getMediaItems(event.attachments) })
             .addOpen({ OpenId: `DIRECT:${event.guild_id}` })
             .add({ tag: 'MESSAGE_CREATE' }).value);
     });
@@ -260,6 +386,11 @@ const register = (client) => {
             })
                 .addMessage({ MessageId: `INTERACTION_CREATE:${event.id}` })
                 .addText({ MessageText: MessageText })
+                .addInteraction({
+                InteractionId: event.id,
+                InteractionData: JSON.stringify(event.data.resolved),
+                Target: { scope: 'group', targetId: event.group_openid, BotId: botId }
+            })
                 .addOpen({ OpenId: `C2C:${event.group_member_openid}` })
                 .add({ tag: 'INTERACTION_CREATE_GROUP' }).value;
             cbp.send(e);
@@ -280,6 +411,11 @@ const register = (client) => {
             })
                 .addMessage({ MessageId: event.id })
                 .addText({ MessageText: MessageText })
+                .addInteraction({
+                InteractionId: event.id,
+                InteractionData: JSON.stringify(event.data.resolved),
+                Target: { scope: 'c2c', targetId: event.user_openid, BotId: botId }
+            })
                 .addOpen({ OpenId: `C2C:${event.user_openid}` })
                 .add({ tag: 'INTERACTION_CREATE_C2C' }).value;
             cbp.send(e);
@@ -296,6 +432,11 @@ const register = (client) => {
                 .addUser({ UserId: event.data.resolved.user_id, UserKey, UserAvatar: UserAvatar, IsMaster: isMaster, IsBot: false })
                 .addMessage({ MessageId: event.data.resolved.message_id })
                 .addText({ MessageText: MessageText })
+                .addInteraction({
+                InteractionId: event.id,
+                InteractionData: JSON.stringify(event.data.resolved),
+                Target: { scope: 'channel', targetId: event.channel_id, BotId: botId }
+            })
                 .addOpen({ OpenId: `DIRECT:${event.guild_id}` })
                 .add({ tag: 'INTERACTION_CREATE_GUILD' }).value;
             cbp.send(e);
@@ -483,6 +624,24 @@ const register = (client) => {
     const api = {
         active: {
             send: {
+                target: async (target, val, replyId) => {
+                    if (!validateTargetBot(target)) {
+                        return [createResult(ResultCode.FailParams, `BotId ${target.BotId} is not active`, null)];
+                    }
+                    if (target.scope === 'group') {
+                        return GROUP_AT_MESSAGE_CREATE(client, { ChannelId: target.targetId, MessageId: replyId }, val);
+                    }
+                    if (target.scope === 'c2c') {
+                        return C2C_MESSAGE_CREATE(client, { UserId: target.targetId, MessageId: replyId }, val);
+                    }
+                    if (target.scope === 'channel') {
+                        return AT_MESSAGE_CREATE(client, { ChannelId: target.targetId, MessageId: replyId }, val);
+                    }
+                    if (target.scope === 'direct') {
+                        return DIRECT_MESSAGE_CREATE(client, { UserId: target.targetId, MessageId: replyId }, val);
+                    }
+                    return [createResult(ResultCode.FailParams, `Unsupported target scope: ${target.scope}`, null)];
+                },
                 channel: async (SpaceId, val) => {
                     if (/^GUILD:/.test(SpaceId)) {
                         const id = SpaceId.replace('GUILD:', '');
@@ -619,11 +778,44 @@ const register = (client) => {
                 const res = await api.active.send.user(userId, paramFormat);
                 consume(res);
             }
+            else if (data.action === 'message.send.target') {
+                const target = normalizeTarget(data.payload.target);
+                if (!target) {
+                    consume([createResult(ResultCode.FailParams, 'message.send.target 缺少 target', null)]);
+                    return;
+                }
+                const res = await api.active.send.target(target, data.payload.params?.format || [], data.payload.params?.replyId);
+                consume(res);
+            }
             else if (data.action === 'message.delete') {
-                const channelId = data.payload.ChannelId;
                 const messageId = data.payload.MessageId;
+                const params = data.payload.params ?? {};
+                const target = normalizeTarget(data.payload.target);
+                if (target && !validateTargetBot(target)) {
+                    consume([createResult(ResultCode.FailParams, `BotId ${target.BotId} is not active`, null)]);
+                    return;
+                }
+                const scope = target?.scope ?? params.scope ?? params.messageType;
+                const request = scope === 'group'
+                    ? client.grouMessageDelte(String(target?.targetId ?? params.groupId ?? data.payload.GroupId ?? data.payload.ChannelId), messageId)
+                    : scope === 'user' || scope === 'c2c'
+                        ? client.userMessageDelete(String(target?.targetId ?? params.userId ?? data.payload.UserId), messageId)
+                        : scope === 'direct'
+                            ? client.dmsMessageDelete(String(target?.targetId ?? params.guildId ?? data.payload.GuildId ?? data.payload.ChannelId), messageId)
+                            : client.channelsMessagesDelete(target?.targetId ?? data.payload.ChannelId, messageId);
+                const res = await request.then(r => createResult(ResultCode.Ok, data.action, r)).catch(err => createResult(ResultCode.Fail, data.action, err));
+                consume([res]);
+            }
+            else if (data.action === 'interaction.ack') {
+                const params = data.payload.params ?? {};
+                const interactionId = String(params.interactionId ?? data.payload.InteractionId ?? '');
+                const mode = data.payload.target?.scope === 'channel' || data.payload.target?.scope === 'direct' || params.mode === 'guild' ? 'guild' : 'group';
+                if (!interactionId) {
+                    consume([createResult(ResultCode.Fail, 'interaction.ack 缺少 InteractionId', null)]);
+                    return;
+                }
                 const res = await client
-                    .channelsMessagesDelete(channelId, messageId)
+                    .interactionResponse(mode, interactionId, params.code)
                     .then(r => createResult(ResultCode.Ok, data.action, r))
                     .catch(err => createResult(ResultCode.Fail, data.action, err));
                 consume([res]);
@@ -870,7 +1062,63 @@ const register = (client) => {
                 consume([res]);
             }
             else if (data.action === 'media.upload') {
-                consume([createResult(ResultCode.Warn, 'media.upload not supported, use media.send.user or media.send.channel', null)]);
+                const target = normalizeTarget(data.payload.target);
+                if (!target) {
+                    consume([createResult(ResultCode.Warn, 'QQ media.upload requires target', null)]);
+                    return;
+                }
+                const res = await uploadMedia(target, data.payload.params || {})
+                    .then(value => createResult(ResultCode.Ok, data.action, value))
+                    .catch(err => createResult(ResultCode.Fail, data.action, err));
+                consume([res]);
+            }
+            else if (data.action === 'media.send') {
+                const target = normalizeTarget(data.payload.target);
+                if (!target) {
+                    consume([createResult(ResultCode.FailParams, 'media.send 缺少 target', null)]);
+                    return;
+                }
+                if (!validateTargetBot(target)) {
+                    consume([createResult(ResultCode.FailParams, `BotId ${target.BotId} is not active`, null)]);
+                    return;
+                }
+                const params = data.payload.params || {};
+                if (params.fileId) {
+                    const send = target.scope === 'group'
+                        ? client.groupOpenMessages(target.targetId, { msg_type: 7, content: params.content || '', media: { file_info: params.fileId } })
+                        : target.scope === 'c2c'
+                            ? client.usersOpenMessages(target.targetId, { msg_type: 7, content: params.content || '', media: { file_info: params.fileId } })
+                            : null;
+                    if (!send) {
+                        consume([createResult(ResultCode.Warn, 'QQ media.send only supports group and c2c targets', null)]);
+                        return;
+                    }
+                    const res = await send
+                        .then(value => createResult(ResultCode.Ok, data.action, { id: value.id }))
+                        .catch(err => createResult(ResultCode.Fail, data.action, err));
+                    consume([res]);
+                    return;
+                }
+                const upload = await uploadMedia(target, params)
+                    .then(value => value.fileId)
+                    .catch(error => {
+                    consume([createResult(ResultCode.Fail, data.action, error)]);
+                    return null;
+                });
+                if (!upload) {
+                    return;
+                }
+                await onactions({ action: 'media.send', payload: { target, params: { ...params, fileId: upload, url: undefined, data: undefined, filePath: undefined } } }, consume);
+            }
+            else if (data.action === 'connection.status') {
+                const status = client.getConnectionStatus();
+                consume([
+                    createResult(ResultCode.Ok, data.action, {
+                        Platform: platform,
+                        state: status.state,
+                        bots: [{ BotId: botId, ...status }]
+                    })
+                ]);
             }
             else if (data.action === 'permission.get') {
                 const res = await client
@@ -920,7 +1168,6 @@ const register = (client) => {
             consume([createResult(ResultCode.Fail, '请求失败', error)]);
         }
     };
-    cbp.onactions((data, consume) => void onactions(data, consume));
     const onapis = async (data, consume) => {
         const key = data.payload?.key;
         const params = data.payload?.params;
@@ -947,7 +1194,11 @@ const register = (client) => {
             consume([createResult(ResultCode.Fail, '请求失败', error)]);
         }
     };
-    cbp.onapis((data, consume) => void onapis(data, consume));
+    if (options?.bindActions !== false) {
+        cbp.onactions((data, consume) => void onactions(data, consume));
+        cbp.onapis((data, consume) => void onapis(data, consume));
+    }
+    return { onAction: onactions, onApi: onapis };
 };
 
 export { register };