@alemonjs/qq-bot 2.1.30 → 2.1.32

package/lib/sdk/client.websoket.js

@@ -1,8 +1,7 @@
 import WebSocket from 'ws';
 import { QQBotAPI } from './api.js';
-import { config } from './config.js';
 import { getIntentsMask } from './intents.js';
-import { Counter } from 'alemonjs/utils';
+import { FileSessionStore } from './session.js';
 
 const normalizeGatewayMessage = (message) => {
     if (!message?.id || !message?.d || typeof message.d !== 'object' || Array.isArray(message.d)) {
@@ -14,41 +13,192 @@ const normalizeGatewayMessage = (message) => {
     return message;
 };
 class QQBotClients extends QQBotAPI {
-    #counter = new Counter(1);
     #isConnected = false;
-    #heartbeat_interval = 30000;
-    #IntervalId = null;
+    #stopped = false;
+    #sessionId = null;
+    #sessionStore;
+    #sessionLoaded = false;
+    #sequence = null;
+    #heartbeatAcknowledged = true;
+    #heartbeatInterval = 30000;
+    #heartbeatTimer = null;
+    #accessTokenTimer = null;
+    #accessTokenTask = null;
+    #reconnectTimer = null;
+    #reconnectAttempts = 0;
     #gatewayUrl = null;
-    constructor(opstion) {
-        super();
-        for (const key in opstion) {
-            config.set(key, opstion[key]);
+    #ws = null;
+    #events = {};
+    constructor(option) {
+        super(option);
+        this.#sessionStore = option.sessionStore || new FileSessionStore();
+    }
+    async #loadSession() {
+        if (this.#sessionLoaded)
+            return;
+        this.#sessionLoaded = true;
+        const botId = String(this.config.get('app_id') || '');
+        const session = botId ? await this.#sessionStore.load(botId) : null;
+        if (session) {
+            this.#sessionId = session.sessionId;
+            this.#sequence = session.sequence;
+        }
+    }
+    #persistSession() {
+        const botId = String(this.config.get('app_id') || '');
+        if (!botId || !this.#sessionId || this.#sequence === null)
+            return;
+        void this.#sessionStore.save({ botId, sessionId: this.#sessionId, sequence: this.#sequence }).catch(err => {
+            console.warn('[ws-qqbot] session persistence failed', err);
+        });
+    }
+    #clearSession() {
+        const botId = String(this.config.get('app_id') || '');
+        this.#sessionId = null;
+        this.#sequence = null;
+        if (botId)
+            void this.#sessionStore.clear(botId).catch(() => undefined);
+    }
+    #clearHeartbeat() {
+        if (this.#heartbeatTimer) {
+            clearInterval(this.#heartbeatTimer);
+            this.#heartbeatTimer = null;
         }
     }
-    async #setTimeoutBotConfig() {
-        const accessToken = async () => {
-            const app_id = config.get('app_id');
-            const secret = config.get('secret');
-            if (!app_id || !secret) {
+    #startHeartbeat(ws) {
+        this.#clearHeartbeat();
+        this.#heartbeatTimer = setInterval(() => {
+            if (this.#ws !== ws || !this.#isConnected || ws.readyState !== WebSocket.OPEN) {
+                this.#clearHeartbeat();
+                return;
+            }
+            if (!this.#heartbeatAcknowledged) {
+                this.#requestReconnect('heartbeat acknowledgement timeout');
                 return;
             }
+            try {
+                this.#heartbeatAcknowledged = false;
+                this.updateConnectionStatus({ heartbeatAcknowledged: false });
+                ws.send(JSON.stringify({
+                    op: 1,
+                    d: null
+                }));
+            }
+            catch (err) {
+                console.error('[ws-qqbot] heartbeat failed', err);
+                this.#requestReconnect('heartbeat failed');
+            }
+        }, this.#heartbeatInterval);
+    }
+    #getReconnectDelay() {
+        const delay = Math.min(1000 * 2 ** Math.min(this.#reconnectAttempts, 5), 30000);
+        const jitter = Math.floor(Math.random() * Math.min(1000, Math.floor(delay / 4)));
+        return delay + jitter;
+    }
+    #scheduleReconnect(reason) {
+        if (this.#stopped || this.#reconnectTimer) {
+            return;
+        }
+        const delay = this.#getReconnectDelay();
+        this.#reconnectAttempts++;
+        this.updateConnectionStatus({
+            state: 'reconnecting',
+            reconnectAttempts: this.#reconnectAttempts,
+            heartbeatAcknowledged: this.#heartbeatAcknowledged,
+            lastError: reason
+        });
+        console.info(`[ws-qqbot] ${reason}; reconnecting in ${delay}ms (attempt ${this.#reconnectAttempts})`);
+        this.#reconnectTimer = setTimeout(() => {
+            this.#reconnectTimer = null;
+            void this.connect();
+        }, delay);
+    }
+    #requestReconnect(reason) {
+        this.#isConnected = false;
+        this.#clearHeartbeat();
+        this.cancelStreams();
+        this.#scheduleReconnect(reason);
+        const ws = this.#ws;
+        if (ws && ws.readyState !== WebSocket.CLOSED && ws.readyState !== WebSocket.CLOSING) {
+            ws.close();
+        }
+    }
+    disconnect() {
+        this.#stopped = true;
+        this.#isConnected = false;
+        this.#clearHeartbeat();
+        if (this.#reconnectTimer) {
+            clearTimeout(this.#reconnectTimer);
+        }
+        if (this.#accessTokenTimer) {
+            clearTimeout(this.#accessTokenTimer);
+        }
+        this.#reconnectTimer = null;
+        this.#accessTokenTimer = null;
+        const ws = this.#ws;
+        this.#ws = null;
+        this.cancelStreams();
+        if (ws && ws.readyState !== WebSocket.CLOSED) {
+            ws.close(1000, 'client stopped');
+        }
+        this.updateConnectionStatus({ state: 'stopped', heartbeatAcknowledged: false });
+    }
+    #scheduleAccessTokenRefresh(delay) {
+        if (this.#accessTokenTimer) {
+            clearTimeout(this.#accessTokenTimer);
+        }
+        this.#accessTokenTimer = setTimeout(() => {
+            this.#accessTokenTimer = null;
+            void this.#startAccessTokenRefresh().catch(() => undefined);
+        }, delay);
+    }
+    async #refreshAccessToken() {
+        const appId = this.config.get('app_id');
+        const secret = this.config.get('secret');
+        if (!appId || !secret) {
+            throw new Error('QQ Bot app_id or secret is missing');
+        }
+        try {
             const data = await this.getAuthentication();
-            config.set('access_token', data.access_token);
-            console.info('refresh', data.expires_in, 's');
-            setTimeout(() => void accessToken(), data.expires_in * 1000);
-        };
-        await accessToken();
+            if (!data?.access_token) {
+                throw new Error('QQ Bot access token is empty');
+            }
+            this.config.set('access_token', data.access_token);
+            const expiresIn = Number(data.expires_in);
+            const refreshIn = Math.max(60000, (Number.isFinite(expiresIn) ? expiresIn * 1000 : 3600000) - 60000);
+            this.#scheduleAccessTokenRefresh(refreshIn);
+            console.info(`[ws-qqbot] access token refreshed; next refresh in ${refreshIn}ms`);
+        }
+        catch (err) {
+            this.#scheduleAccessTokenRefresh(30000);
+            console.error('[ws-qqbot] access token refresh failed; retrying in 30000ms', err);
+            throw err;
+        }
+    }
+    #startAccessTokenRefresh() {
+        if (this.#accessTokenTask === null) {
+            this.#accessTokenTask = this.#refreshAccessToken().finally(() => {
+                this.#accessTokenTask = null;
+            });
+        }
+        return this.#accessTokenTask;
+    }
+    async #ensureAccessToken() {
+        if (this.#accessTokenTimer) {
+            return;
+        }
+        await this.#startAccessTokenRefresh();
     }
     #aut() {
-        const token = config.get('access_token');
-        const intents = config.get('intents');
-        const shard = config.get('shard');
+        const token = this.config.get('access_token');
+        const intents = this.config.get('intents');
+        const shard = this.config.get('shard');
         return {
             op: 2,
             d: {
                 token: `QQBot ${token}`,
                 intents: getIntentsMask(intents),
-                shard: shard,
+                shard,
                 properties: {
                     $os: process.platform,
                     $browser: 'alemonjs',
@@ -57,8 +207,16 @@ class QQBotClients extends QQBotAPI {
             }
         };
     }
-    #ws = null;
-    #events = {};
+    #resume() {
+        return {
+            op: 6,
+            d: {
+                token: `QQBot ${this.config.get('access_token')}`,
+                session_id: this.#sessionId,
+                seq: this.#sequence
+            }
+        };
+    }
     on(key, val) {
         if (!this.#events[key]) {
             this.#events[key] = [];
@@ -66,119 +224,172 @@ class QQBotClients extends QQBotAPI {
         this.#events[key].push(val);
         return this;
     }
+    #emitError(err) {
+        for (const event of this.#events.ERROR || []) {
+            try {
+                event(err);
+            }
+            catch (error) {
+                console.error('[ws-qqbot] error handler failed', error);
+            }
+        }
+    }
+    #handleDispatch(t, d) {
+        for (const event of this.#events[t] || []) {
+            try {
+                event(d);
+            }
+            catch (err) {
+                this.#emitError(err);
+            }
+        }
+    }
     async connect(gatewayURL) {
-        await this.#setTimeoutBotConfig();
+        this.#stopped = false;
+        if (gatewayURL) {
+            this.#gatewayUrl = gatewayURL;
+        }
+        if (this.#ws && this.#ws.readyState !== WebSocket.CLOSED) {
+            return;
+        }
+        await this.#loadSession();
+        try {
+            await this.#ensureAccessToken();
+        }
+        catch {
+            this.#scheduleReconnect('access token unavailable');
+            return;
+        }
         if (!this.#gatewayUrl) {
-            this.#gatewayUrl = gatewayURL ?? (await this.gateway().then(res => res?.url));
+            try {
+                this.#gatewayUrl = await this.gateway().then(res => res?.url);
+            }
+            catch (err) {
+                this.#emitError(err);
+                this.#scheduleReconnect('gateway request failed');
+                return;
+            }
         }
         if (!this.#gatewayUrl) {
+            this.#scheduleReconnect('gateway URL is empty');
             return;
         }
-        const reconnect = () => {
-            if (this.#counter.value >= 5) {
-                console.info('The maximum number of reconnections has been reached, cancel reconnection');
+        let ws;
+        try {
+            ws = new WebSocket(this.#gatewayUrl);
+        }
+        catch (err) {
+            this.#emitError(err);
+            this.#scheduleReconnect('gateway connection creation failed');
+            return;
+        }
+        this.#ws = ws;
+        this.updateConnectionStatus({ state: 'connecting', transport: 'websocket', lastError: undefined });
+        ws.on('open', () => {
+            if (this.#ws === ws) {
+                console.info('[ws-qqbot] open');
+            }
+        });
+        ws.on('message', msg => {
+            if (this.#ws !== ws) {
                 return;
             }
-            setTimeout(() => {
-                console.info('[ws-qqbot] reconnecting...');
-                start();
-                this.#counter.next();
-            }, 5000);
-        };
-        const start = () => {
-            if (this.#gatewayUrl) {
+            try {
+                const message = normalizeGatewayMessage(JSON.parse(msg.toString('utf8')));
+                if (process.env.NTQQ_WS === 'dev') {
+                    console.info('message', message);
+                }
                 const map = {
-                    0: ({ t, d }) => {
-                        if (this.#events[t]) {
-                            try {
-                                for (const event of this.#events[t]) {
-                                    if (typeof event !== 'function') {
-                                        continue;
-                                    }
-                                    event(d);
-                                }
-                            }
-                            catch (err) {
-                                if (this.#events['ERROR']) {
-                                    for (const event of this.#events['ERROR']) {
-                                        if (typeof event !== 'function') {
-                                            continue;
-                                        }
-                                        event(err);
-                                    }
-                                }
-                            }
+                    0: ({ t, d, s }) => {
+                        if (typeof s === 'number') {
+                            this.#sequence = s;
                         }
-                        if (t === 'READY') {
-                            if (this.#IntervalId) {
-                                clearInterval(this.#IntervalId);
-                            }
-                            this.#IntervalId = setInterval(() => {
-                                if (this.#isConnected && this.#ws) {
-                                    this.#ws.send(JSON.stringify({
-                                        op: 1,
-                                        d: null
-                                    }));
-                                }
-                            }, this.#heartbeat_interval);
+                        if (t === 'READY' && d?.session_id) {
+                            this.#sessionId = String(d.session_id);
                         }
-                        if (t === 'RESUMED') {
-                            console.info('[ws-qqbot] restore connection');
-                            this.#counter.reStart();
+                        this.#persistSession();
+                        this.#handleDispatch(t, d);
+                        if (t === 'READY' || t === 'RESUMED') {
+                            this.#reconnectAttempts = 0;
+                            this.updateConnectionStatus({
+                                state: 'ready',
+                                reconnectAttempts: 0,
+                                heartbeatAcknowledged: this.#heartbeatAcknowledged,
+                                sessionId: this.#sessionId ?? undefined,
+                                sequence: this.#sequence ?? undefined,
+                                resumed: t === 'RESUMED'
+                            });
+                            console.info(t === 'READY' ? '[ws-qqbot] ready' : '[ws-qqbot] restored connection');
                         }
                     },
-                    6: ({ d }) => {
-                        console.info('[ws-qqbot] connection attempt', d);
-                    },
                     7: ({ d }) => {
-                        console.info('[ws-qqbot] reconnect', d);
-                        if (this.#IntervalId) {
-                            clearInterval(this.#IntervalId);
-                        }
+                        console.info('[ws-qqbot] gateway requested reconnect', d);
+                        this.#requestReconnect('gateway requested reconnect');
                     },
                     9: ({ d }) => {
-                        console.info('[ws-qqbot] parameter error', d);
+                        console.error('[ws-qqbot] invalid session', d);
+                        this.#clearSession();
+                        this.#requestReconnect('invalid session');
                     },
                     10: ({ d }) => {
                         this.#isConnected = true;
-                        this.#heartbeat_interval = d.heartbeat_interval;
-                        if (this.#ws) {
-                            this.#ws.send(JSON.stringify(this.#aut()));
+                        this.#heartbeatInterval = Number(d?.heartbeat_interval) || 30000;
+                        this.#startHeartbeat(ws);
+                        try {
+                            const resumable = this.#sessionId && this.#sequence !== null;
+                            ws.send(JSON.stringify(resumable ? this.#resume() : this.#aut()));
+                            this.updateConnectionStatus({
+                                state: 'connecting',
+                                heartbeatAcknowledged: true,
+                                sessionId: this.#sessionId ?? undefined,
+                                sequence: this.#sequence ?? undefined,
+                                resumed: Boolean(resumable)
+                            });
+                        }
+                        catch (err) {
+                            console.error('[ws-qqbot] identify failed', err);
+                            this.#emitError(err);
+                            this.#requestReconnect('identify failed');
                         }
                     },
                     11: () => {
-                        console.info('[ws-qqbot] heartbeat transmission');
-                        this.#counter.reStart();
+                        this.#heartbeatAcknowledged = true;
+                        this.updateConnectionStatus({ heartbeatAcknowledged: true });
+                        console.debug('[ws-qqbot] heartbeat acknowledged');
                     },
                     12: ({ d }) => {
                         console.debug('[ws-qqbot] platform data', d);
                     }
                 };
-                this.#ws = new WebSocket(this.#gatewayUrl);
-                this.#ws.on('open', () => {
-                    console.info('[ws-qqbot] open');
-                });
-                this.#ws.on('message', msg => {
-                    const message = normalizeGatewayMessage(JSON.parse(msg.toString('utf8')));
-                    if (process.env.NTQQ_WS === 'dev') {
-                        console.info('message', message);
-                    }
-                    if (map[message.op]) {
-                        map[message.op](message);
-                    }
-                });
-                this.#ws.on('close', err => {
-                    this.#isConnected = false;
-                    if (this.#IntervalId) {
-                        clearInterval(this.#IntervalId);
-                        this.#IntervalId = null;
-                    }
-                    void reconnect();
-                    console.info('[ws-qqbot] close', err);
-                });
+                if (map[message.op]) {
+                    map[message.op](message);
+                }
             }
-        };
-        start();
+            catch (err) {
+                console.error('[ws-qqbot] invalid gateway message', err);
+                this.#emitError(err);
+            }
+        });
+        ws.on('close', (code, reason) => {
+            if (this.#ws !== ws) {
+                return;
+            }
+            this.#ws = null;
+            this.#isConnected = false;
+            this.#clearHeartbeat();
+            this.updateConnectionStatus({ state: 'offline', heartbeatAcknowledged: false });
+            console.info(`[ws-qqbot] close ${code}${reason.length ? `: ${reason.toString('utf8')}` : ''}`);
+            this.#scheduleReconnect('connection closed');
+        });
+        ws.on('error', err => {
+            if (this.#ws !== ws) {
+                return;
+            }
+            console.error('[ws-qqbot] error', err);
+            this.updateConnectionStatus({ state: 'offline', lastError: err.message });
+            this.#emitError(err);
+            this.#requestReconnect('connection error');
+        });
     }
 }
 

package/lib/sdk/config.d.ts

@@ -1 +1,3 @@
-export declare const config: Map<string, any>;
+export declare class QQBotConfig extends Map<string, any> {
+    constructor(value?: Record<string, unknown>);
+}

package/lib/sdk/config.js

@@ -1,3 +1,7 @@
-const config = new Map();
+class QQBotConfig extends Map {
+    constructor(value = {}) {
+        super(Object.entries(value));
+    }
+}
 
-export { config };
+export { QQBotConfig };

package/lib/sdk/registry.d.ts

@@ -0,0 +1,25 @@
+import { cbpPlatform } from 'alemonjs';
+import { QQBotClients } from './client.websoket.js';
+import type { Options } from './typing.js';
+export declare class QQBotRegistry {
+    #private;
+    constructor(defaultBot?: string, cbp?: ReturnType<typeof cbpPlatform>);
+    add(botId: string, options: Options): QQBotClients;
+    get(botId?: string): QQBotClients;
+    getConnectionStatus(botId?: string): {
+        Platform: string;
+        state: import("./api.js").QQBotConnectionState;
+        bots: {
+            state: import("./api.js").QQBotConnectionState;
+            transport: "websocket" | "webhook" | "proxy" | null;
+            reconnectAttempts: number;
+            heartbeatAcknowledged: boolean;
+            sessionId?: string;
+            sequence?: number;
+            resumed: boolean;
+            lastError?: string;
+            BotId: string;
+        }[];
+    };
+    disconnect(): void;
+}

package/lib/sdk/registry.js

@@ -0,0 +1,116 @@
+import { cbpPlatform, createResult, ResultCode } from 'alemonjs';
+import { getQQBotConfig } from '../config.js';
+import { register } from '../register.js';
+import { QQBotClients } from './client.websoket.js';
+
+class QQBotRegistry {
+    #bots = new Map();
+    #streams = new Map();
+    #defaultBot;
+    #cbp;
+    constructor(defaultBot, cbp) {
+        this.#defaultBot = defaultBot;
+        if (cbp) {
+            this.#cbp = cbp;
+        }
+        else {
+            const config = getQQBotConfig();
+            const port = process.env.port || config.port || 17117;
+            this.#cbp = cbpPlatform(`ws://127.0.0.1:${port}`);
+        }
+        this.#cbp.onactions((data, consume) => void this.#onAction(data, consume));
+        this.#cbp.onapis((data, consume) => void this.#onApi(data, consume));
+    }
+    add(botId, options) {
+        if (!botId)
+            throw new Error('QQ BotId is required');
+        if (this.#bots.has(botId))
+            throw new Error(`Duplicate QQ BotId: ${botId}`);
+        const client = new QQBotClients({ ...options, app_id: botId });
+        client.setStreamLifecycleListener(streamId => this.#streams.delete(streamId));
+        const adapter = register(client, { botId, cbp: this.#cbp, bindActions: false });
+        this.#bots.set(botId, { client, adapter });
+        return client;
+    }
+    get(botId) {
+        return botId ? this.#bots.get(botId)?.client : undefined;
+    }
+    getConnectionStatus(botId) {
+        const bots = [...this.#bots].flatMap(([BotId, entry]) => {
+            if (botId && botId !== BotId)
+                return [];
+            return [{ BotId, ...entry.client.getConnectionStatus() }];
+        });
+        const state = bots.some(item => item.state === 'ready')
+            ? 'ready'
+            : bots.some(item => item.state === 'connecting' || item.state === 'reconnecting')
+                ? 'connecting'
+                : bots[0]?.state || 'idle';
+        return { Platform: 'qq-bot', state, bots };
+    }
+    disconnect() {
+        for (const { client } of this.#bots.values())
+            client.disconnect();
+        this.#streams.clear();
+    }
+    #requestedBotId(data) {
+        const payload = data?.payload || {};
+        return payload.target?.BotId || payload.BotId || payload.event?.BotId || payload.event?.Platform?.BotId;
+    }
+    #select(data) {
+        const requested = this.#requestedBotId(data);
+        if (requested) {
+            const entry = this.#bots.get(String(requested));
+            return entry ? { entry } : { error: `BotId ${requested} is not configured (available: ${[...this.#bots.keys()].join(', ') || 'none'})` };
+        }
+        if (this.#bots.size === 1)
+            return { entry: this.#bots.values().next().value };
+        if (this.#defaultBot)
+            return { entry: this.#bots.get(this.#defaultBot) };
+        return { error: 'BotId is required because multiple QQ bots are active and no default_bot is configured' };
+    }
+    async #onAction(data, consume) {
+        if (data?.action === 'connection.status') {
+            const botId = data?.payload?.BotId;
+            const status = this.getConnectionStatus(botId);
+            if (botId && !status.bots.length) {
+                consume([createResult(ResultCode.FailParams, `BotId ${botId} is not configured`, null)]);
+            }
+            else {
+                consume([createResult(ResultCode.Ok, data.action, status)]);
+            }
+            return;
+        }
+        const { entry, error } = this.#select(data);
+        if (!entry) {
+            consume([createResult(ResultCode.FailParams, error || 'QQ Bot is unavailable', null)]);
+            return;
+        }
+        await entry.adapter.onAction(data, consume);
+    }
+    async #onApi(data, consume) {
+        const params = data?.payload?.params;
+        const key = String(data?.payload?.key || '');
+        const method = key.split('.').at(-1);
+        const streamId = method === 'streamUpdate' || method === 'streamComplete' || method === 'streamCancel' ? params?.[0] : undefined;
+        const requested = (Array.isArray(params) ? params[0]?.BotId : undefined) || (streamId ? this.#streams.get(String(streamId)) : undefined);
+        const { entry, error } = this.#select({ payload: { BotId: requested, event: data?.payload?.event } });
+        if (!entry) {
+            consume([createResult(ResultCode.FailParams, error || 'QQ Bot is unavailable', null)]);
+            return;
+        }
+        await entry.adapter.onApi(data, results => {
+            const result = results.find((item) => item.code === ResultCode.Ok)?.data;
+            if (method === 'streamOpen' && result?.streamId)
+                this.#streams.set(String(result.streamId), requested || this.#botIdFor(entry));
+            if (streamId && (method === 'streamComplete' || method === 'streamCancel'))
+                this.#streams.delete(String(streamId));
+            consume(results);
+        });
+    }
+    #botIdFor(entry) {
+        return [...this.#bots.entries()].find(([, value]) => value === entry)?.[0] || '';
+    }
+}
+
+export { QQBotRegistry };

package/lib/sdk/session.d.ts

@@ -0,0 +1,18 @@
+export type PersistedSession = {
+    botId: string;
+    sessionId: string;
+    sequence: number;
+};
+export interface SessionStore {
+    load(botId: string): Promise<PersistedSession | null>;
+    save(session: PersistedSession): Promise<void>;
+    clear(botId: string): Promise<void>;
+}
+export declare class FileSessionStore implements SessionStore {
+    #private;
+    private readonly root;
+    constructor(root?: string);
+    load(botId: string): Promise<PersistedSession | null>;
+    save(session: PersistedSession): Promise<void>;
+    clear(botId: string): Promise<void>;
+}