kook-client 1.0.0

package/lib/core/receivers/websocket.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebsocketReceiver = void 0;
+const receiver_1 = require("../../core/receiver");
+const ws_1 = require("ws");
+const constans_1 = require("../../constans");
+class WebsocketReceiver extends receiver_1.Receiver {
+    constructor(client, config) {
+        super(client);
+        this.config = config;
+        this.ws = null;
+        this.url = null;
+        this.session_id = null;
+        this.timers = new Map();
+        this.pingJitterRange = 10000;
+        this.pingBaseInterval = 25000;
+        this.helloTimeout = 5000;
+        // 重连相关属性
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 10;
+        this.reconnectBaseDelay = 1000;
+        this.reconnectTimer = null;
+        // 心跳检测相关属性
+        this.lastPongTime = 0;
+        this.heartbeatTimeout = null;
+        this._state = WebsocketReceiver.State.Initial;
+        this.compress = config.compress ?? false;
+        this.setupNetworkMonitoring();
+    }
+    get state() {
+        return this._state;
+    }
+    set state(value) {
+        this._state = value;
+        this.logger.info(`WebSocket state changed to: ${WebsocketReceiver.State[value]}`);
+    }
+    get logger() {
+        return this.c.logger;
+    }
+    async getGatewayUrl(compress) {
+        try {
+            const res = await this.c.request.get('/v3/gateway/index', { params: { compress } });
+            return res.data.url;
+        }
+        catch (error) {
+            this.logger.error('Failed to get gateway URL', error);
+            throw error;
+        }
+    }
+    async waitForHello() {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.off('hello', helloHandler);
+                reject(new Error('WebSocket receive hello code timeout'));
+            }, this.helloTimeout);
+            const helloHandler = (data) => {
+                clearTimeout(timer);
+                this.session_id = data.session_id;
+                resolve(data.code);
+            };
+            this.once('hello', helloHandler);
+        });
+    }
+    sendPing() {
+        if (this.ws?.readyState === ws_1.WebSocket.OPEN) {
+            // 发送包含当前 sn 的 Ping（必须为数字）
+            this.ws.send(JSON.stringify({
+                s: constans_1.OpCode.Ping,
+                sn: this.sn || 0
+            }));
+            this.lastPongTime = Date.now();
+            // 设置心跳超时检测
+            if (this.heartbeatTimeout) {
+                clearTimeout(this.heartbeatTimeout);
+            }
+            this.heartbeatTimeout = setTimeout(() => {
+                if (Date.now() - this.lastPongTime > 10000) { // 10秒超时
+                    this.logger.debug('Heartbeat timeout, reconnecting...');
+                    this.scheduleReconnect();
+                }
+            }, 10000);
+            this.logger.debug(`Sent ping to server with sn: ${this.sn}`);
+        }
+    }
+    setupEventListeners() {
+        if (!this.ws)
+            return;
+        this.ws.on('message', (event) => {
+            try {
+                const data = JSON.parse(this.decryptData(event.toString(), this.config.encrypt_key ?? ''));
+                if (data.sn)
+                    this.sn = Number(data.sn); // 确保为数字
+                switch (data.s) {
+                    case constans_1.OpCode.Hello:
+                        this.emit('hello', data.d);
+                        break;
+                    case constans_1.OpCode.Event:
+                        this.emit('event', data.d);
+                        break;
+                    case constans_1.OpCode.Reconnect:
+                        this.logger.debug('Received reconnect command from server', data.d);
+                        this.scheduleReconnect();
+                        break;
+                    case constans_1.OpCode.ResumeAck:
+                        this.emit('resume', data.d);
+                        break;
+                    case constans_1.OpCode.Pong:
+                        this.lastPongTime = Date.now();
+                        this.logger.debug('Received pong from server');
+                        break;
+                    default:
+                        this.logger.debug('Received unknown opcode', data.s);
+                }
+            }
+            catch (error) {
+                this.logger.error('Error processing WebSocket message', error);
+            }
+        });
+        this.ws.on('close', (code, reason) => {
+            this.logger.info(`WebSocket connection closed, code: ${code}, reason: ${reason.toString()}`);
+            this.cleanup();
+            this.state = WebsocketReceiver.State.Closed;
+            // 自动重连（非正常关闭时）
+            if (code !== 1000) { // 1000是正常关闭
+                this.scheduleReconnect();
+            }
+        });
+        this.ws.on('error', (error) => {
+            this.logger.error('WebSocket error', error);
+            this.cleanup();
+            this.state = WebsocketReceiver.State.Closed;
+            this.scheduleReconnect();
+        });
+        this.ws.on('open', () => {
+            this.logger.debug('WebSocket connection opened');
+        });
+    }
+    cleanup() {
+        // Clear all timers
+        this.timers.forEach((timer, key) => {
+            clearInterval(timer);
+            this.timers.delete(key);
+        });
+        // 清理重连定时器
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        // 清理心跳超时检测
+        if (this.heartbeatTimeout) {
+            clearTimeout(this.heartbeatTimeout);
+            this.heartbeatTimeout = null;
+        }
+        // Clean up WebSocket
+        if (this.ws) {
+            this.ws.removeAllListeners();
+            if (this.ws.readyState === ws_1.WebSocket.OPEN) {
+                this.ws.close();
+            }
+            this.ws = null;
+        }
+    }
+    getResumeQueryParams() {
+        const params = new URLSearchParams();
+        if (this.sn)
+            params.append('sn', this.sn.toString());
+        if (this.session_id)
+            params.append('session_id', this.session_id);
+        params.append('resume', '1');
+        return params;
+    }
+    scheduleReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            this.logger.error('Max reconnection attempts reached');
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = this.reconnectBaseDelay * Math.pow(2, this.reconnectAttempts - 1);
+        this.logger.info(`Scheduling reconnect in ${delay}ms (attempt ${this.reconnectAttempts})`);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnect().catch(error => {
+                this.logger.error('Reconnect failed', error);
+                this.scheduleReconnect();
+            });
+        }, delay);
+    }
+    async reconnect() {
+        this.logger.info('Attempting to reconnect...');
+        this.cleanup();
+        this.state = WebsocketReceiver.State.Reconnection;
+        await this.connect(true);
+    }
+    setupNetworkMonitoring() {
+        // 在Node.js环境中监听网络状态变化
+        if (typeof process !== 'undefined') {
+            // 可以添加定期的网络连通性检查
+            const networkCheckInterval = setInterval(() => {
+                // 简单的网络连通性检查
+                require('dns').resolve('www.kookapp.cn', (err) => {
+                    if (err) {
+                        this.logger.debug('Network connectivity issue detected');
+                        if (this.state === WebsocketReceiver.State.Closed) {
+                            this.scheduleReconnect();
+                        }
+                    }
+                });
+            }, 30000); // 每30秒检查一次
+            // 在清理时移除监听
+            this.timers.set('networkCheck', networkCheckInterval);
+        }
+    }
+    async connect(isReconnect = false) {
+        try {
+            this.state = WebsocketReceiver.State.PullingGateway;
+            const gatewayUrl = await this.getGatewayUrl(this.config.compress ? 1 : 0);
+            const url = new URL(gatewayUrl);
+            if (isReconnect) {
+                this.getResumeQueryParams().forEach((value, key) => {
+                    url.searchParams.append(key, value);
+                });
+            }
+            this.url = url;
+            this.state = WebsocketReceiver.State.Connecting;
+            this.ws = new ws_1.WebSocket(this.url);
+            this.setupEventListeners();
+            const receiveCode = await this.waitForHello();
+            if (receiveCode !== 0) {
+                this.logger.error(`WebSocket connect failed, receive code: ${receiveCode}`);
+                return this.connect(isReconnect);
+            }
+            this.state = WebsocketReceiver.State.Open;
+            this.reconnectAttempts = 0; // 重置重连计数器
+            this.sendPing();
+            // Schedule periodic pings with jitter
+            const pingInterval = this.pingBaseInterval + Math.random() * this.pingJitterRange;
+            this.timers.set('ping', setInterval(() => this.sendPing(), pingInterval));
+            this.logger.info(`WebSocket connected successfully to ${this.url.host}`);
+        }
+        catch (error) {
+            this.logger.error('WebSocket connection error', error);
+            this.cleanup();
+            // 连接失败时也触发重连
+            if (!isReconnect) {
+                this.scheduleReconnect();
+            }
+            throw error;
+        }
+    }
+    async disconnect() {
+        this.logger.info('Disconnecting WebSocket...');
+        this.cleanup();
+        this.state = WebsocketReceiver.State.Closed;
+    }
+}
+exports.WebsocketReceiver = WebsocketReceiver;
+(function (WebsocketReceiver) {
+    let State;
+    (function (State) {
+        State[State["Initial"] = 0] = "Initial";
+        State[State["PullingGateway"] = 1] = "PullingGateway";
+        State[State["Connecting"] = 2] = "Connecting";
+        State[State["Open"] = 3] = "Open";
+        State[State["Closed"] = 4] = "Closed";
+        State[State["Reconnection"] = 5] = "Reconnection";
+    })(State = WebsocketReceiver.State || (WebsocketReceiver.State = {}));
+})(WebsocketReceiver || (exports.WebsocketReceiver = WebsocketReceiver = {}));
+receiver_1.Receiver.register('websocket', WebsocketReceiver);

package/lib/elements.js

@@ -0,0 +1,342 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.segment = exports.msgMod = exports.element = void 0;
+exports.validateCard = validateCard;
+// 验证卡片消息
+function validateCard(card) {
+    // 1. 验证卡片结构
+    if (!card.modules || !Array.isArray(card.modules)) {
+        throw new Error("卡片必须包含 'modules' 数组");
+    }
+    // 2. 验证模块数量限制
+    const totalModules = card.modules.length;
+    if (totalModules > 50) {
+        throw new Error(`卡片模块数量不能超过 50，当前有 ${totalModules} 个`);
+    }
+    // 3. 验证主题限制
+    if (card.theme === 'invisible') {
+        const allowedTypes = new Set(['context', 'action-group', 'divider', 'header', 'container', 'file', 'audio', 'video']);
+        for (const mod of card.modules) {
+            if (!allowedTypes.has(mod.type)) {
+                // 使用类型守卫检查 section 模块
+                if (isSectionModule(mod) && mod.accessory) {
+                    throw new Error("在 'invisible' 主题下，section 模块不能包含 accessory");
+                }
+                if (!allowedTypes.has(mod.type)) {
+                    throw new Error(`在 'invisible' 主题下，不允许使用 ${mod.type} 模块`);
+                }
+            }
+        }
+    }
+    // 4. 验证每个模块
+    for (const mod of card.modules) {
+        validateModule(mod);
+    }
+}
+// 类型守卫函数
+function isSectionModule(module) {
+    return module.type === 'section';
+}
+function validateModule(module) {
+    switch (module.type) {
+        case 'header':
+            const headerMod = module;
+            if (!headerMod.text || headerMod.text.type !== 'plain-text') {
+                throw new Error("header 模块必须包含 'text' 元素，且类型必须是 'plain-text'");
+            }
+            if (headerMod.text.content.length > 100) {
+                throw new Error("header 文本内容不能超过 100 个字符");
+            }
+            break;
+        case 'section':
+            if (!isSectionModule(module))
+                break;
+            const validTextTypes = ['plain-text', 'kmarkdown', 'paragraph'];
+            if (module.text && !validTextTypes.includes(module.text.type)) {
+                throw new Error(`section 的 text 必须是以下类型之一: ${validTextTypes.join(', ')}`);
+            }
+            const validAccessoryTypes = ['image', 'button'];
+            if (module.accessory && !validAccessoryTypes.includes(module.accessory.type)) {
+                throw new Error(`section 的 accessory 必须是以下类型之一: ${validAccessoryTypes.join(', ')}`);
+            }
+            if (module.mode !== 'left' && module.mode !== 'right') {
+                throw new Error("section 的 mode 必须是 'left' 或 'right'");
+            }
+            if (module.accessory && module.mode === 'left' && module.accessory.type === 'button') {
+                throw new Error("button 不能放置在左侧");
+            }
+            break;
+        case 'image-group':
+            const imageGroupMod = module;
+            if (!imageGroupMod.elements || !Array.isArray(imageGroupMod.elements)) {
+                throw new Error("image-group 必须包含 'elements' 数组");
+            }
+            if (imageGroupMod.elements.length < 1 || imageGroupMod.elements.length > 9) {
+                throw new Error("image-group 只能包含 1-9 张图片");
+            }
+            for (const el of imageGroupMod.elements) {
+                if (el.type !== 'image') {
+                    throw new Error("image-group 只能包含 image 元素");
+                }
+            }
+            break;
+        case 'container':
+            const containerMod = module;
+            if (!containerMod.elements || !Array.isArray(containerMod.elements)) {
+                throw new Error("container 必须包含 'elements' 数组");
+            }
+            if (containerMod.elements.length < 1 || containerMod.elements.length > 9) {
+                throw new Error("container 只能包含 1-9 张图片");
+            }
+            for (const el of containerMod.elements) {
+                if (el.type !== 'image') {
+                    throw new Error("container 只能包含 image 元素");
+                }
+            }
+            break;
+        case 'action-group':
+            const actionMod = module;
+            if (!actionMod.elements || !Array.isArray(actionMod.elements)) {
+                throw new Error("action-group 必须包含 'elements' 数组");
+            }
+            if (actionMod.elements.length > 4) {
+                throw new Error("action-group 最多只能包含 4 个按钮");
+            }
+            for (const el of actionMod.elements) {
+                if (el.type !== 'button') {
+                    throw new Error("action-group 只能包含 button 元素");
+                }
+            }
+            break;
+        case 'context':
+            const contextMod = module;
+            if (!contextMod.elements || !Array.isArray(contextMod.elements)) {
+                throw new Error("context 必须包含 'elements' 数组");
+            }
+            if (contextMod.elements.length > 10) {
+                throw new Error("context 最多只能包含 10 个元素");
+            }
+            const validContextTypes = ['plain-text', 'kmarkdown', 'image'];
+            for (const el of contextMod.elements) {
+                if (!validContextTypes.includes(el.type)) {
+                    throw new Error(`context 只能包含以下类型元素: ${validContextTypes.join(', ')}`);
+                }
+            }
+            break;
+        case 'file':
+        case 'audio':
+        case 'video':
+            const fileMod = module;
+            if (!fileMod.src) {
+                throw new Error(`${fileMod.type} 模块必须包含 'src' 属性`);
+            }
+            if (!fileMod.title) {
+                throw new Error(`${fileMod.type} 模块必须包含 'title' 属性`);
+            }
+            if (fileMod.type === 'audio' && !('cover' in fileMod)) {
+                console.warn("audio 模块建议提供 'cover' 属性");
+            }
+            break;
+        case 'countdown':
+            const countdownMod = module;
+            if (!countdownMod.endTime) {
+                throw new Error("countdown 模块必须包含 'endTime' 属性");
+            }
+            if (!countdownMod.mode || !['day', 'hour', 'second'].includes(countdownMod.mode)) {
+                throw new Error("countdown 的 mode 必须是 'day', 'hour' 或 'second'");
+            }
+            if (countdownMod.mode === 'second' && !countdownMod.startTime) {
+                throw new Error("当 mode 为 'second' 时，必须提供 'startTime'");
+            }
+            break;
+        case 'invite':
+            const inviteMod = module;
+            if (!inviteMod.code) {
+                throw new Error("invite 模块必须包含 'code' 属性");
+            }
+            break;
+    }
+}
+// 验证元素
+function validateElement(element) {
+    switch (element.type) {
+        case 'plain-text':
+            if (!element.content) {
+                throw new Error("plain-text 元素必须包含 'content' 属性");
+            }
+            if (element.content.length > 2000) {
+                throw new Error("plain-text 内容不能超过 2000 个字符");
+            }
+            break;
+        case 'kmarkdown':
+            if (!element.content) {
+                throw new Error("kmarkdown 元素必须包含 'content' 属性");
+            }
+            if (element.content.length > 5000) {
+                throw new Error("kmarkdown 内容不能超过 5000 个字符");
+            }
+            break;
+        case 'image':
+            if (!element.src) {
+                throw new Error("image 元素必须包含 'src' 属性");
+            }
+            break;
+        case 'button':
+            if (!element.text) {
+                throw new Error("button 元素必须包含 'text' 属性");
+            }
+            if (!element.value) {
+                throw new Error("button 元素必须包含 'value' 属性");
+            }
+            if (element.click && !['link', 'return-val'].includes(element.click)) {
+                throw new Error("button 的 click 属性必须是 'link' 或 'return-val'");
+            }
+            break;
+        case 'paragraph':
+            if (!element.fields || !Array.isArray(element.fields)) {
+                throw new Error("paragraph 必须包含 'fields' 数组");
+            }
+            if (element.fields.length > 50) {
+                throw new Error("paragraph 最多只能包含 50 个字段");
+            }
+            if (element.cols < 1 || element.cols > 3) {
+                throw new Error("paragraph 的 cols 必须是 1, 2 或 3");
+            }
+            const validFieldTypes = ['plain-text', 'kmarkdown'];
+            for (const field of element.fields) {
+                if (!validFieldTypes.includes(field.type)) {
+                    throw new Error(`paragraph 只能包含以下类型字段: ${validFieldTypes.join(', ')}`);
+                }
+            }
+            break;
+    }
+}
+exports.element = function (type, data) {
+    return {
+        type,
+        ...data
+    };
+};
+exports.element.text = (content, emoji = true) => ({
+    type: 'plain-text',
+    content,
+    emoji
+});
+exports.element.markdown = (content) => ({
+    type: 'kmarkdown',
+    content
+});
+exports.element.image = (src, alt, size, circle, fallbackUrl) => ({
+    type: 'image',
+    src,
+    ...(alt && { alt }),
+    ...(size && { size }),
+    ...(circle && { circle }),
+    ...(fallbackUrl && { fallbackUrl })
+});
+exports.element.button = (text, value, theme = 'primary', click) => ({
+    type: 'button',
+    text,
+    value,
+    theme,
+    ...(click && { click })
+});
+exports.element.paragraph = (cols, fields) => ({
+    type: 'paragraph',
+    cols,
+    fields
+});
+exports.msgMod = function (type, data) {
+    return {
+        type,
+        ...data
+    };
+};
+exports.msgMod.header = (text) => ({
+    type: 'header',
+    text
+});
+exports.msgMod.section = (text, mode = 'left', accessory) => ({
+    type: 'section',
+    ...(text && { text }),
+    mode,
+    ...(accessory && { accessory })
+});
+exports.msgMod.image = (elements) => ({
+    type: 'image-group',
+    elements
+});
+exports.msgMod.container = (elements) => ({
+    type: 'container',
+    elements
+});
+exports.msgMod.action = (elements) => ({
+    type: 'action-group',
+    elements
+});
+exports.msgMod.context = (elements) => ({
+    type: 'context',
+    elements
+});
+exports.msgMod.divider = () => ({
+    type: 'divider'
+});
+exports.msgMod.file = (src, title) => ({
+    type: 'file',
+    src,
+    title
+});
+exports.msgMod.audio = (src, title, cover) => ({
+    type: 'audio',
+    src,
+    title,
+    ...(cover && { cover })
+});
+exports.msgMod.video = (src, title) => ({
+    type: 'video',
+    src,
+    title
+});
+exports.msgMod.countdown = (endTime, mode = 'hour', startTime) => ({
+    type: 'countdown',
+    endTime,
+    mode,
+    ...(startTime && { startTime })
+});
+exports.msgMod.invite = (code) => ({
+    type: 'invite',
+    code
+});
+exports.segment = function (type, attrs) {
+    return {
+        type,
+        ...attrs
+    };
+};
+exports.segment.text = (text) => (0, exports.segment)('text', { text });
+exports.segment.at = (user_id) => (0, exports.segment)('at', { user_id });
+// 修改后的卡片消息段生成器
+exports.segment.card = (modules, options) => {
+    // 创建卡片对象
+    const cardObj = {
+        type: 'card',
+        modules,
+        ...(options || {})
+    };
+    // 返回一个特殊对象，标记为卡片类型
+    return {
+        __isCard: true,
+        ...cardObj
+    };
+};
+exports.segment.image = (url, title) => (0, exports.segment)('image', { url, ...(title && { title }) });
+exports.segment.video = (url, title) => (0, exports.segment)('video', { url, ...(title && { title }) });
+exports.segment.audio = (url, title) => (0, exports.segment)('audio', { url, ...(title && { title }) });
+exports.segment.markdown = (text) => (0, exports.segment)('markdown', { text });
+exports.segment.reply = (message_id) => (0, exports.segment)('reply', { id: message_id });
+exports.segment.file = (url, name, file_type, size) => (0, exports.segment)('file', {
+    url,
+    ...(name && { name }),
+    ...(file_type && { file_type }),
+    ...(size && { size })
+});