@alemonjs/qq-bot 2.1.31 → 2.1.32

package/lib/sdk/api.d.ts

@@ -1,9 +1,51 @@
 import { type AxiosRequestConfig } from 'axios';
 import { ApiRequestData, FileType } from './typing.js';
+import { QQBotConfig } from './config.js';
 export declare const BOTS_API_RUL = "https://bots.qq.com";
 export declare const API_URL_SANDBOX = "https://sandbox.api.sgroup.qq.com";
 export declare const API_URL = "https://api.sgroup.qq.com";
+export type QQBotConnectionState = 'idle' | 'connecting' | 'ready' | 'reconnecting' | 'offline' | 'stopped';
+export type QQBotConnectionStatus = {
+    state: QQBotConnectionState;
+    transport: 'websocket' | 'webhook' | 'proxy' | null;
+    reconnectAttempts: number;
+    heartbeatAcknowledged: boolean;
+    sessionId?: string;
+    sequence?: number;
+    resumed: boolean;
+    lastError?: string;
+};
+export type QQBotMediaHashes = {
+    sha256: string;
+    md5: string;
+    sha1: string;
+    md5_10m: string;
+};
 export declare class QQBotAPI {
+    #private;
+    protected readonly config: QQBotConfig;
+    constructor(options?: Record<string, unknown>);
+    getConnectionStatus(): QQBotConnectionStatus;
+    protected updateConnectionStatus(patch: Partial<QQBotConnectionStatus>): void;
+    setStreamLifecycleListener(listener?: (streamId: string) => void): void;
+    sendTyping(params: {
+        BotId?: string;
+        userOpenId: string;
+        msgId?: string;
+        durationSec?: number;
+    }): Promise<any>;
+    streamOpen(params: {
+        BotId?: string;
+        userOpenId: string;
+        msgId: string;
+        eventId?: string;
+    }): {
+        streamId: `${string}-${string}-${string}-${string}-${string}`;
+    };
+    streamUpdate(streamId: string, fullText: string): Promise<unknown>;
+    streamComplete(streamId: string): Promise<any>;
+    streamCancel(streamId: string): void;
+    protected cancelStreams(): void;
     getAuthentication(): Promise<any>;
     groupService(options: AxiosRequestConfig): Promise<any>;
     guildServer(options: AxiosRequestConfig): Promise<any>;
@@ -37,6 +79,22 @@ export declare class QQBotAPI {
         file_info: string;
         ttl: number;
     }>;
+    getMediaFileHashes(filePath: string): Promise<QQBotMediaHashes>;
+    postChunkedRichMedia(params: {
+        scope: 'group' | 'c2c';
+        targetId: string;
+        fileType: FileType;
+        data?: Buffer;
+        filePath?: string;
+        size?: number;
+        hashes?: QQBotMediaHashes;
+        name?: string;
+        onProgress?: (uploaded: number, total: number) => void;
+    }): Promise<{
+        file_uuid: string;
+        file_info: string;
+        ttl: number;
+    }>;
     userMessageDelete(openid: string, message_id: string): Promise<any>;
     grouMessageDelte(group_openid: string, message_id: string): Promise<any>;
     channelsMessages(channel_id: string, message: {

package/lib/sdk/api.js

@@ -1,18 +1,153 @@
 import axios from 'axios';
-import { config } from './config.js';
+import { QQBotConfig } from './config.js';
 import FormData from 'form-data';
 import { createPicFrom } from 'alemonjs/utils';
 import { createAxiosInstance } from './instance.js';
+import { randomUUID, createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
 
 const BOTS_API_RUL = 'https://bots.qq.com';
 const API_URL_SANDBOX = 'https://sandbox.api.sgroup.qq.com';
 const API_URL = 'https://api.sgroup.qq.com';
-const msgMap = new Map();
 class QQBotAPI {
+    config;
+    #msgMap = new Map();
+    #streams = new Map();
+    #onStreamClosed;
+    #connectionStatus = {
+        state: 'idle',
+        transport: null,
+        reconnectAttempts: 0,
+        heartbeatAcknowledged: false,
+        resumed: false
+    };
+    constructor(options = {}) {
+        this.config = new QQBotConfig(options);
+    }
+    getConnectionStatus() {
+        return { ...this.#connectionStatus };
+    }
+    updateConnectionStatus(patch) {
+        this.#connectionStatus = { ...this.#connectionStatus, ...patch };
+    }
+    setStreamLifecycleListener(listener) {
+        this.#onStreamClosed = listener;
+    }
+    sendTyping(params) {
+        if (!params.userOpenId)
+            throw new Error('userOpenId is required');
+        return this.groupService({
+            url: `/v2/users/${params.userOpenId}/input_notify`,
+            method: 'post',
+            data: {
+                ...(params.msgId && { msg_id: params.msgId }),
+                input_second: Math.max(1, Math.min(Number(params.durationSec) || 30, 60))
+            }
+        });
+    }
+    streamOpen(params) {
+        if (!params.userOpenId || !params.msgId)
+            throw new Error('C2C streaming requires userOpenId and msgId');
+        const streamId = randomUUID();
+        const stream = {
+            userOpenId: params.userOpenId,
+            msgId: params.msgId,
+            eventId: params.eventId || params.msgId,
+            msgSeq: this.getMessageSeq(params.msgId),
+            index: 0,
+            lastSentAt: 0,
+            lastSentText: ''
+        };
+        stream.timer = setTimeout(() => this.streamCancel(streamId), 5 * 60 * 1000);
+        this.#streams.set(streamId, stream);
+        return { streamId };
+    }
+    async streamUpdate(streamId, fullText) {
+        const stream = this.#streams.get(streamId);
+        if (!stream)
+            throw new Error('Unknown or expired streamId');
+        stream.latest = fullText;
+        if (!stream.sendTask) {
+            stream.sendTask = (async () => {
+                let result;
+                while (stream.latest !== undefined && this.#streams.get(streamId) === stream) {
+                    const content = stream.latest;
+                    stream.latest = undefined;
+                    const wait = Math.max(0, 500 - (Date.now() - stream.lastSentAt));
+                    if (wait)
+                        await new Promise(resolve => setTimeout(resolve, wait));
+                    if (this.#streams.get(streamId) !== stream)
+                        break;
+                    stream.lastSentAt = Date.now();
+                    const response = await this.groupService({
+                        url: `/v2/users/${stream.userOpenId}/stream_messages`,
+                        method: 'post',
+                        data: {
+                            msg_id: stream.msgId,
+                            event_id: stream.eventId,
+                            msg_seq: stream.msgSeq,
+                            index: stream.index++,
+                            input_mode: 'replace',
+                            input_state: 1,
+                            content_type: 'markdown',
+                            content_raw: content,
+                            ...(stream.streamMessageId && { stream_msg_id: stream.streamMessageId })
+                        }
+                    });
+                    if (response?.id && !stream.streamMessageId)
+                        stream.streamMessageId = response.id;
+                    stream.lastSentText = content;
+                    result = response;
+                }
+                return result;
+            })().finally(() => {
+                if (this.#streams.get(streamId) === stream)
+                    stream.sendTask = undefined;
+            });
+        }
+        return stream.sendTask;
+    }
+    async streamComplete(streamId) {
+        const stream = this.#streams.get(streamId);
+        if (!stream)
+            throw new Error('Unknown or expired streamId');
+        try {
+            await stream.sendTask;
+            return await this.groupService({
+                url: `/v2/users/${stream.userOpenId}/stream_messages`,
+                method: 'post',
+                data: {
+                    msg_id: stream.msgId,
+                    event_id: stream.eventId,
+                    msg_seq: stream.msgSeq,
+                    index: stream.index++,
+                    input_mode: 'replace',
+                    input_state: 10,
+                    content_type: 'markdown',
+                    content_raw: stream.latest ?? stream.lastSentText,
+                    ...(stream.streamMessageId && { stream_msg_id: stream.streamMessageId })
+                }
+            });
+        }
+        finally {
+            this.streamCancel(streamId);
+        }
+    }
+    streamCancel(streamId) {
+        const stream = this.#streams.get(streamId);
+        if (stream?.timer)
+            clearTimeout(stream.timer);
+        if (this.#streams.delete(streamId))
+            this.#onStreamClosed?.(streamId);
+    }
+    cancelStreams() {
+        for (const streamId of this.#streams.keys())
+            this.streamCancel(streamId);
+    }
     getAuthentication() {
-        const app_id = config.get('app_id');
-        const secret = config.get('secret');
-        const baseUrlAppAccessToken = config.get('base_url_app_access_token');
+        const app_id = this.config.get('app_id');
+        const secret = this.config.get('secret');
+        const baseUrlAppAccessToken = this.config.get('base_url_app_access_token');
         const params = {
             url: '/app/getAppAccessToken'
         };
@@ -33,9 +168,9 @@ class QQBotAPI {
         });
     }
     groupService(options) {
-        const app_id = config.get('app_id');
-        const token = config.get('access_token');
-        const sandbox = config.get('sandbox');
+        const app_id = this.config.get('app_id');
+        const token = this.config.get('access_token');
+        const sandbox = this.config.get('sandbox');
         const service = axios.create({
             baseURL: sandbox ? API_URL_SANDBOX : API_URL,
             timeout: 20000,
@@ -50,7 +185,7 @@ class QQBotAPI {
         return this.groupService(options);
     }
     gateway() {
-        const baseUrlGateway = config.get('base_url_gateway');
+        const baseUrlGateway = this.config.get('base_url_gateway');
         const params = {
             url: '/gateway'
         };
@@ -75,13 +210,13 @@ class QQBotAPI {
         });
     }
     getMessageSeq(MessageId) {
-        let seq = msgMap.get(MessageId) || 0;
+        let seq = this.#msgMap.get(MessageId) || 0;
         seq++;
-        msgMap.set(MessageId, seq);
-        if (msgMap.size > 100) {
-            const firstKey = msgMap.keys().next().value;
+        this.#msgMap.set(MessageId, seq);
+        if (this.#msgMap.size > 100) {
+            const firstKey = this.#msgMap.keys().next().value;
             if (firstKey) {
-                msgMap.delete(firstKey);
+                this.#msgMap.delete(firstKey);
             }
         }
         return seq;
@@ -118,6 +253,109 @@ class QQBotAPI {
             }
         });
     }
+    async getMediaFileHashes(filePath) {
+        const sha256 = createHash('sha256');
+        const md5 = createHash('md5');
+        const sha1 = createHash('sha1');
+        const md5_10m = createHash('md5');
+        let firstBytes = 0;
+        const firstLimit = 10_002_432;
+        for await (const chunk of createReadStream(filePath)) {
+            const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            sha256.update(data);
+            md5.update(data);
+            sha1.update(data);
+            if (firstBytes < firstLimit) {
+                const length = Math.min(data.length, firstLimit - firstBytes);
+                md5_10m.update(data.subarray(0, length));
+                firstBytes += length;
+            }
+        }
+        return {
+            sha256: sha256.digest('hex'),
+            md5: md5.digest('hex'),
+            sha1: sha1.digest('hex'),
+            md5_10m: md5_10m.digest('hex')
+        };
+    }
+    async postChunkedRichMedia(params) {
+        const hasBuffer = Buffer.isBuffer(params.data);
+        const hasFile = Boolean(params.filePath);
+        if (hasBuffer === hasFile)
+            throw new Error('Chunked media requires exactly one of data or filePath');
+        const total = hasBuffer ? params.data.length : Number(params.size);
+        if (!Number.isSafeInteger(total) || total < 1)
+            throw new Error('Chunked media requires a valid file size');
+        const hashes = params.hashes || (hasBuffer ? this.#getMediaBufferHashes(params.data) : await this.getMediaFileHashes(params.filePath));
+        const prefix = params.scope === 'group' ? `/v2/groups/${params.targetId}` : `/v2/users/${params.targetId}`;
+        const prepared = await this.groupService({
+            url: `${prefix}/upload_prepare`,
+            method: 'post',
+            data: {
+                file_type: params.fileType,
+                file_name: params.name || 'file',
+                file_size: total,
+                md5: hashes.md5,
+                sha1: hashes.sha1,
+                md5_10m: hashes.md5_10m
+            }
+        });
+        let uploaded = 0;
+        for (const part of prepared.parts || []) {
+            const offset = (part.index - 1) * prepared.block_size;
+            const length = Math.min(prepared.block_size, total - offset);
+            if (length <= 0)
+                throw new Error(`QQ returned invalid upload part index: ${part.index}`);
+            const body = hasBuffer ? params.data.subarray(offset, offset + length) : undefined;
+            const partMd5 = body ? createHash('md5').update(body).digest('hex') : await this.#getFilePartHash(params.filePath, offset, length);
+            await this.#retry(() => axios.put(part.presigned_url, body || createReadStream(params.filePath, { start: offset, end: offset + length - 1 }), {
+                timeout: 300_000,
+                maxBodyLength: Infinity,
+                maxContentLength: Infinity,
+                headers: { 'Content-Length': String(length) }
+            }));
+            await this.#retry(() => this.groupService({
+                url: `${prefix}/upload_part_finish`,
+                method: 'post',
+                data: { upload_id: prepared.upload_id, part_index: part.index, block_size: length, md5: partMd5 }
+            }));
+            uploaded += length;
+            params.onProgress?.(uploaded, total);
+        }
+        return this.#retry(() => this.groupService({
+            url: `${prefix}/complete_upload`,
+            method: 'post',
+            data: { upload_id: prepared.upload_id }
+        }));
+    }
+    #getMediaBufferHashes(data) {
+        return {
+            sha256: createHash('sha256').update(data).digest('hex'),
+            md5: createHash('md5').update(data).digest('hex'),
+            sha1: createHash('sha1').update(data).digest('hex'),
+            md5_10m: createHash('md5').update(data.subarray(0, 10_002_432)).digest('hex')
+        };
+    }
+    async #getFilePartHash(filePath, start, length) {
+        const md5 = createHash('md5');
+        for await (const chunk of createReadStream(filePath, { start, end: start + length - 1 }))
+            md5.update(chunk);
+        return md5.digest('hex');
+    }
+    async #retry(operation, attempts = 3) {
+        let lastError;
+        for (let attempt = 0; attempt < attempts; attempt++) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt + 1 < attempts)
+                    await new Promise(resolve => setTimeout(resolve, 250 * 2 ** attempt));
+            }
+        }
+        throw lastError;
+    }
     userMessageDelete(openid, message_id) {
         return this.groupService({
             url: `/v2/users/${openid}/messages/${message_id}`,

package/lib/sdk/client.webhook.js

@@ -3,7 +3,6 @@ import bodyParser from 'koa-bodyparser';
 import Router from 'koa-router';
 import { WebhookAPI } from './webhook.secret.js';
 import Koa from 'koa';
-import { config } from './config.js';
 import { v4 } from 'uuid';
 import { WebSocketServer, WebSocket } from 'ws';
 
@@ -23,10 +22,7 @@ class QQBotClient extends QQBotAPI {
     #client = [];
     #ws = null;
     constructor(opstion) {
-        super();
-        for (const key in opstion) {
-            config.set(key, opstion[key]);
-        }
+        super(opstion);
     }
     on(key, val) {
         if (!this.#events[key]) {
@@ -37,13 +33,13 @@ class QQBotClient extends QQBotAPI {
     }
     async #setTimeoutBotConfig() {
         const callBack = async () => {
-            const app_id = config.get('app_id');
-            const secret = config.get('secret');
+            const app_id = this.config.get('app_id');
+            const secret = this.config.get('secret');
             if (!app_id || !secret) {
                 return;
             }
             const data = await this.getAuthentication();
-            config.set('access_token', data.access_token);
+            this.config.set('access_token', data.access_token);
             console.info('refresh', data.expires_in, 's');
             setTimeout(() => void callBack(), data.expires_in * 1000);
         };
@@ -51,15 +47,16 @@ class QQBotClient extends QQBotAPI {
     }
     connect() {
         try {
-            const ws = config.get('ws');
+            const ws = this.config.get('ws');
+            this.updateConnectionStatus({ state: 'connecting', transport: ws ? 'proxy' : 'webhook' });
             if (!ws) {
                 void this.#setTimeoutBotConfig();
                 this.#app = new Koa();
                 this.#app.use(bodyParser());
                 const router = new Router();
-                const port = config.get('port');
-                const secret = config.get('secret');
-                const route = config.get('route') ?? '/webhook';
+                const port = this.config.get('port');
+                const secret = this.config.get('secret');
+                const route = this.config.get('route') ?? '/webhook';
                 const cfg = {
                     secret: secret ?? '',
                     port: port ? Number(port) : 17157
@@ -96,7 +93,7 @@ class QQBotClient extends QQBotAPI {
                         for (const event of this.#events[body.t] || []) {
                             event(body.d);
                         }
-                        const accessToken = config.get('access_token');
+                        const accessToken = this.config.get('access_token');
                         for (const client of this.#client) {
                             try {
                                 if (accessToken) {
@@ -114,6 +111,7 @@ class QQBotClient extends QQBotAPI {
                 this.#app.use(router.allowedMethods());
                 const server = this.#app.listen(cfg.port, () => {
                     console.log('Server running at http://localhost:' + cfg.port + route);
+                    this.updateConnectionStatus({ state: 'ready' });
                 });
                 const wss = new WebSocketServer({ server: server });
                 console.log('Server running at ws://localhost:' + cfg.port + '/');
@@ -144,6 +142,7 @@ class QQBotClient extends QQBotAPI {
                     this.#ws = new WebSocket(ws);
                     this.#ws.on('open', () => {
                         this.#count = 0;
+                        this.updateConnectionStatus({ state: 'ready' });
                         console.log('ws connected');
                     });
                     this.#ws.on('message', data => {
@@ -151,7 +150,7 @@ class QQBotClient extends QQBotAPI {
                             const body = normalizeGatewayMessage(JSON.parse(data.toString()));
                             const accessToken = body['access_token'];
                             if (accessToken) {
-                                config.set('access_token', accessToken);
+                                this.config.set('access_token', accessToken);
                             }
                             for (const event of this.#events[body.t] || []) {
                                 event(body.d);
@@ -162,6 +161,7 @@ class QQBotClient extends QQBotAPI {
                         }
                     });
                     this.#ws.on('close', () => {
+                        this.updateConnectionStatus({ state: 'offline' });
                         console.log('ws closed');
                         if (this.#count > 5) {
                             return;

package/lib/sdk/client.websoket.d.ts

@@ -3,7 +3,8 @@ import { QQBotEventMap } from './message.js';
 import { Options } from './typing.js';
 export declare class QQBotClients extends QQBotAPI {
     #private;
-    constructor(opstion: Options);
+    constructor(option: Options);
+    disconnect(): void;
     on<T extends keyof QQBotEventMap>(key: T, val: (event: QQBotEventMap[T]) => any): this;
     connect(gatewayURL?: string): Promise<void>;
 }