@izhimu/qq 0.1.1

package/dist/src/core/connection.js

@@ -0,0 +1,328 @@
+/**
+ * WebSocket Connection Manager for NapCat
+ * Handles per-account WebSocket connections with auto-reconnect and heartbeat
+ */
+import WebSocket from 'ws';
+import EventEmitter from 'events';
+import { Logger as log, generateEchoId, calculateBackoff, getCloseCodeMessage, } from '../utils/index.js';
+const MAX_RECONNECT_ATTEMPTS = -1;
+const REQUEST_TIMEOUT = 30000; // 30 seconds
+/**
+ * Connection Manager for a single NapCat account
+ */
+export class ConnectionManager extends EventEmitter {
+    config;
+    ws = null;
+    state = 'disconnected';
+    // Heartbeat - active ping + OneBot 11 meta_event based
+    lastHeartbeatTime = 0;
+    // Connection stats
+    totalReconnectAttempts = 0;
+    // Reconnection
+    reconnectTimer;
+    reconnectAttempts = 0;
+    shouldReconnect = true;
+    // Pending requests
+    pendingRequests = new Map();
+    // Health status
+    healthStatus = {
+        healthy: false,
+        lastHeartbeatAt: 0,
+        consecutiveFailures: 0,
+    };
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    // ==========================================================================
+    // Connection Lifecycle
+    // ==========================================================================
+    /**
+     * Start the connection
+     */
+    async start() {
+        if (this.state === 'connected' || this.state === 'connecting') {
+            log.debug('connection', `Already ${this.state}`);
+            return;
+        }
+        this.shouldReconnect = true;
+        this.reconnectAttempts = 0;
+        await this.connect();
+        log.info('connection', `Started connection`);
+    }
+    /**
+     * Stop the connection
+     */
+    async stop() {
+        this.shouldReconnect = false;
+        this.clearReconnectTimer();
+        await this.close('Stopping connection');
+        this.setState('disconnected');
+        log.info('connection', `Stopped connection`);
+    }
+    /**
+     * Establish WebSocket connection
+     */
+    async connect() {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            return;
+        }
+        this.setState('connecting');
+        try {
+            // Build WebSocket URL with access_token query parameter (NapCat OneBot 11 standard)
+            let wsUrl = this.config.wsUrl;
+            if (this.config.accessToken) {
+                const url = new URL(wsUrl);
+                url.searchParams.set('access_token', this.config.accessToken);
+                wsUrl = url.toString();
+            }
+            log.info('connection', `Connecting to ${wsUrl}`);
+            this.ws = new WebSocket(wsUrl);
+            this.ws.on('open', this.handleOpen.bind(this));
+            this.ws.on('message', this.handleMessage.bind(this));
+            this.ws.on('error', this.handleError.bind(this));
+            this.ws.on('close', this.handleClose.bind(this));
+            // Wait for connection to be established or failed
+            await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    reject(new Error('Connection timeout'));
+                }, 30000);
+                this.once('connected', () => {
+                    clearTimeout(timeout);
+                    resolve();
+                });
+                this.once('failed', (error) => {
+                    clearTimeout(timeout);
+                    reject(error);
+                });
+            });
+        }
+        catch (error) {
+            log.error('connection', `Connection failed:`, error);
+            this.handleConnectionFailed(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Close WebSocket connection
+     */
+    async close(reason) {
+        if (this.ws) {
+            log.info('connection', `Closing connection: ${reason}`);
+            // Clear event listeners to prevent further processing
+            this.ws.removeAllListeners();
+            if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+                this.ws.close(1000, reason);
+            }
+            this.ws = null;
+        }
+    }
+    // ==========================================================================
+    // WebSocket Event Handlers
+    // ==========================================================================
+    handleOpen() {
+        log.info('connection', `Connected to NapCat`);
+        this.setState('connected');
+        this.totalReconnectAttempts += this.reconnectAttempts;
+        this.reconnectAttempts = 0;
+        this.emit('connected');
+    }
+    handleMessage(data) {
+        try {
+            const message = JSON.parse(data.toString());
+            // Handle response to a request
+            if ('echo' in message && message.echo) {
+                this.handleResponse(message);
+                return;
+            }
+            // Handle meta_event (heartbeat/lifecycle)
+            if ('post_type' in message && message.post_type === 'meta_event') {
+                this.handleMetaEvent(message);
+                return;
+            }
+            // Handle event
+            if ('post_type' in message) {
+                this.emit('event', message);
+                return;
+            }
+            log.debug('connection', `Received unsolicited response:`, message);
+        }
+        catch (error) {
+            log.error('connection', `Failed to parse message:`, error);
+        }
+    }
+    /**
+     * Handle OneBot 11 meta_event (lifecycle and heartbeat)
+     */
+    handleMetaEvent(event) {
+        if (event.meta_event_type === 'heartbeat') {
+            // NapCat sent us a heartbeat - update health status
+            this.lastHeartbeatTime = Date.now();
+            this.healthStatus = {
+                healthy: true,
+                lastHeartbeatAt: this.lastHeartbeatTime,
+                consecutiveFailures: 0,
+            };
+            log.debug('connection', `Received heartbeat`);
+            this.emit('heartbeat', this.healthStatus);
+        }
+        else if (event.meta_event_type === 'lifecycle') {
+            log.info('connection', `Lifecycle event: ${event.sub_type}`);
+            this.emit('lifecycle', event);
+        }
+    }
+    handleError(error) {
+        log.error('connection', `WebSocket error:`, error.message);
+    }
+    handleClose(code, reason) {
+        const reasonStr = reason.toString() || getCloseCodeMessage(code);
+        log.warn('connection', `Connection closed: ${code} - ${reasonStr}`);
+        if (this.shouldReconnect && !this.isNormalClosure(code)) {
+            this.scheduleReconnect();
+        }
+        else {
+            this.setState('disconnected');
+        }
+    }
+    handleConnectionFailed(error) {
+        this.setState('failed', error.message);
+        this.emit('failed', error);
+        if (this.shouldReconnect) {
+            this.scheduleReconnect();
+        }
+    }
+    handleResponse(response) {
+        const { echo } = response;
+        if (!echo) {
+            return;
+        }
+        const pending = this.pendingRequests.get(echo);
+        if (!pending) {
+            log.debug('connection', `Received response for unknown request: ${echo}`);
+            return;
+        }
+        this.pendingRequests.delete(echo);
+        clearTimeout(pending.timeout);
+        if (response.status === 'ok') {
+            pending.resolve(response);
+        }
+        else {
+            pending.reject(new Error(response.msg || 'Request failed'));
+        }
+        log.debug('connection', `Received response for echo: ${echo}`);
+    }
+    isNormalClosure(code) {
+        return code === 1000 || code === 1001;
+    }
+    // ==========================================================================
+    // Reconnection Logic
+    // ==========================================================================
+    scheduleReconnect() {
+        if (!this.shouldReconnect) {
+            return;
+        }
+        if (MAX_RECONNECT_ATTEMPTS != -1 && this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+            log.error('connection', `Max reconnect attempts reached`);
+            this.setState('failed', 'Max reconnect attempts reached');
+            this.emit('max-reconnect-attempts-reached');
+            return;
+        }
+        const delayMs = calculateBackoff(this.reconnectAttempts);
+        log.info('connection', `Scheduling reconnect in ${delayMs}ms (attempt ${this.reconnectAttempts + 1}/${MAX_RECONNECT_ATTEMPTS})`);
+        this.clearReconnectTimer();
+        this.reconnectTimer = setTimeout(async () => {
+            this.reconnectAttempts++;
+            try {
+                await this.connect();
+            }
+            catch (error) {
+                log.error('connection', `Reconnect failed:`, error);
+            }
+        }, delayMs);
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+    }
+    // ==========================================================================
+    // Request/Response Handling
+    // ==========================================================================
+    /**
+     * Send a request and wait for response
+     */
+    async sendRequest(action, params) {
+        if (!this.isConnected()) {
+            return failResp();
+        }
+        const echo = generateEchoId();
+        return new Promise((resolve, reject) => {
+            // Set up timeout
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(echo);
+                reject(new Error(`Request timeout: ${action}`));
+            }, REQUEST_TIMEOUT);
+            // Store pending request
+            this.pendingRequests.set(echo, {
+                resolve: resolve,
+                reject,
+                timeout,
+            });
+            // Send request
+            const request = {
+                action,
+                params,
+                echo,
+            };
+            try {
+                this.ws?.send(JSON.stringify(request));
+                log.debug('connection', `Sent request: ${action} (echo: ${echo})`);
+            }
+            catch (error) {
+                this.pendingRequests.delete(echo);
+                clearTimeout(timeout);
+                reject(error);
+            }
+        });
+    }
+    // ==========================================================================
+    // State Management
+    // ==========================================================================
+    setState(state, error) {
+        const oldState = this.state;
+        this.state = state;
+        log.info('connection', `State changed: ${oldState} -> ${state}`);
+        if (state === 'connected') {
+            this.lastHeartbeatTime = Date.now();
+        }
+        this.emit('state-changed', { ...this.getStatus(), error });
+    }
+    /**
+     * Get current connection status
+     */
+    getStatus() {
+        return {
+            state: this.state,
+            lastConnected: this.lastHeartbeatTime || undefined,
+            lastAttempted: this.reconnectAttempts > 0 ? Date.now() : undefined,
+            error: this.state === 'failed' ? 'Connection failed' : undefined,
+            reconnectAttempts: this.reconnectAttempts > 0 ? this.reconnectAttempts : undefined,
+        };
+    }
+    // ==========================================================================
+    // Public API
+    // ==========================================================================
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.state === 'connected' && this.ws?.readyState === WebSocket.OPEN;
+    }
+}
+export async function failResp(msg = '') {
+    return Promise.resolve({
+        status: "failed",
+        retcode: -1,
+        msg
+    });
+}

package/dist/src/core/dispatch.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Message Dispatch Module
+ * Handles routing and dispatching incoming messages to the AI
+ */
+import type { DispatchMessageParams } from '../types/index.js';
+/**
+ * Dispatch an incoming message to the AI for processing
+ */
+export declare function dispatchMessage(params: DispatchMessageParams): Promise<void>;
+/**
+ * Handle group message event
+ */
+export declare function handleGroupMessage(event: {
+    time: number;
+    self_id: number;
+    message_id: number;
+    group_id: number;
+    user_id: number;
+    message: Array<{
+        type: string;
+        data: Record<string, unknown>;
+    }>;
+    raw_message: string;
+    sender?: {
+        nickname?: string;
+        card?: string;
+    };
+}): Promise<void>;
+/**
+ * Handle private message event
+ */
+export declare function handlePrivateMessage(event: {
+    time: number;
+    self_id: number;
+    message_id: number;
+    user_id: number;
+    message: Array<{
+        type: string;
+        data: Record<string, unknown>;
+    }>;
+    raw_message: string;
+    sender?: {
+        nickname?: string;
+    };
+}): Promise<void>;
+export declare function handlePokeEvent(event: {
+    user_id: number;
+    target_id: number;
+    group_id?: number;
+    raw_info?: Array<{
+        type: string;
+        txt?: string;
+    }>;
+}): Promise<void>;

package/dist/src/core/dispatch.js

@@ -0,0 +1,285 @@
+/**
+ * Message Dispatch Module
+ * Handles routing and dispatching incoming messages to the AI
+ */
+import { getRuntime, getContext } from './runtime.js';
+import { getMsg, getFile, sendMsg, setInputStatus } from './request.js';
+import { napCatToOpenClawMessage } from '../adapters/message.js';
+import { Logger as log, markdownToText } from '../utils/index.js';
+import { CHANNEL_ID } from "./config.js";
+/**
+ * Convert OpenClaw message content array to plain text
+ * For images, includes the URL so AI models can access them
+ * For replies, includes quoted message content if available
+ */
+async function contentToPlainText(content) {
+    return content
+        .filter(c => c.type !== 'reply' && c.type !== 'image' && c.type !== 'audio' && c.type !== 'file')
+        .map((c) => {
+        switch (c.type) {
+            case 'text':
+                return c.text;
+            case 'at':
+                return c.isAll ? '@全体成员' : `@${c.userId}`;
+            case 'json':
+                return `[JSON]\n\`\`\`json\n${c.data}\n\`\`\``;
+            default:
+                return '';
+        }
+    }).join('');
+}
+async function contextToMedia(content) {
+    const hasMedia = content.some(c => c.type === 'image' || c.type === 'audio' || c.type === 'file');
+    if (!hasMedia) {
+        return;
+    }
+    const image = content.find(c => c.type === 'image');
+    if (image) {
+        return {
+            type: 'image/jpeg',
+            path: image.url,
+            url: image.url,
+        };
+    }
+    const audio = content.find(c => c.type === 'audio');
+    if (audio) {
+        return {
+            type: 'audio/amr',
+            path: audio.path,
+            url: audio.url,
+        };
+    }
+    const file = content.find(c => c.type === 'file');
+    if (file) {
+        const fileInfo = await getFile({ file_id: file.fileId });
+        if (fileInfo.data?.file == undefined) {
+            return;
+        }
+        return {
+            type: 'application/octet-stream',
+            path: fileInfo.data?.file,
+            url: fileInfo.data?.url,
+        };
+    }
+    return;
+}
+async function contextToReply(content) {
+    const hasReply = content.some(c => c.type === 'reply');
+    if (!hasReply) {
+        return;
+    }
+    const reply = content.find(c => c.type === 'reply');
+    if (!reply) {
+        return;
+    }
+    const response = await getMsg({
+        message_id: Number(reply.messageId),
+    });
+    if (response.data?.message == undefined) {
+        return;
+    }
+    const replyMessage = await napCatToOpenClawMessage(response.data?.message);
+    const text = await contentToPlainText(replyMessage);
+    return {
+        id: reply.messageId,
+        content: text,
+        sender: String(response.data?.sender.user_id)
+    };
+}
+/**
+ * Dispatch an incoming message to the AI for processing
+ */
+export async function dispatchMessage(params) {
+    const { chatType, chatId, senderId, senderName, messageId, content, media, reply, timestamp } = params;
+    const runtime = getRuntime();
+    if (!runtime) {
+        log.warn('dispatch', `Plugin runtime not available`);
+        return;
+    }
+    const context = getContext();
+    if (!context) {
+        log.warn('dispatch', `No gateway context`);
+        return;
+    }
+    const isGroup = chatType === 'group';
+    const peerId = isGroup ? `group:${chatId}` : senderId;
+    if (!isGroup) {
+        // 输入状态
+        await setInputStatus({
+            user_id: senderId,
+            event_type: 1
+        });
+    }
+    const route = runtime.channel.routing.resolveAgentRoute({
+        cfg: context.cfg,
+        channel: CHANNEL_ID,
+        peer: {
+            kind: isGroup ? 'group' : 'dm',
+            id: peerId,
+        },
+    });
+    const envelopeOptions = runtime.channel.reply.resolveEnvelopeFormatOptions(context.cfg);
+    const body = runtime.channel.reply.formatInboundEnvelope({
+        channel: CHANNEL_ID,
+        from: senderName || senderId,
+        body: content,
+        timestamp,
+        chatType: isGroup ? 'group' : 'direct',
+        sender: {
+            id: senderId,
+            name: senderName,
+        },
+        envelope: envelopeOptions,
+    });
+    const fromAddress = isGroup ? `qq:group:${chatId}` : `qq:private:${senderId}`;
+    const toAddress = `qq:${route.accountId}`;
+    const ctxPayload = runtime.channel.reply.finalizeInboundContext({
+        Body: body,
+        RawBody: content,
+        CommandBody: content,
+        From: fromAddress,
+        To: toAddress,
+        SessionKey: route.sessionKey,
+        AccountId: route.accountId,
+        ChatType: isGroup ? 'group' : 'direct',
+        SenderId: senderId,
+        SenderName: senderName,
+        Provider: CHANNEL_ID,
+        Surface: CHANNEL_ID,
+        MessageSid: messageId,
+        Timestamp: timestamp,
+        ReplyToId: reply?.id,
+        ReplyToBody: reply?.content,
+        ReplyToSender: reply?.sender,
+        ReplyToIsQuote: !!reply,
+        MediaType: media?.type,
+        MediaPath: media?.path,
+        MediaUrl: media?.url,
+        OriginatingChannel: CHANNEL_ID,
+        OriginatingTo: toAddress,
+    });
+    log.info('dispatch', `Dispatching to agent ${route.agentId}, session: ${route.sessionKey}`);
+    const sendReply = async (text) => {
+        const messageSegments = [{ type: 'text', data: { text: markdownToText(text) } }];
+        try {
+            await sendMsg({
+                message_type: isGroup ? 'group' : 'private',
+                group_id: isGroup ? chatId : undefined,
+                user_id: !isGroup ? chatId : undefined,
+                message: messageSegments,
+            });
+            log.info('dispatch', `Sent reply: ${text.slice(0, 100)}`);
+        }
+        catch (error) {
+            log.error('dispatch', `Send failed: ${error}`);
+        }
+    };
+    const messagesConfig = runtime.channel.reply.resolveEffectiveMessagesConfig(context.cfg, route.agentId);
+    log.info('dispatch', `Messages config: ${JSON.stringify(messagesConfig)}`);
+    let hasResponse = false;
+    try {
+        await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            ctx: ctxPayload,
+            cfg: context.cfg,
+            dispatcherOptions: {
+                humanDelay: {
+                    mode: "off"
+                },
+                responsePrefix: messagesConfig.responsePrefix,
+                deliver: async (payload, info) => {
+                    hasResponse = true;
+                    log.info('dispatch', `deliver(${info.kind}): ${JSON.stringify(payload)}`);
+                    if (payload.text) {
+                        await sendReply(payload.text);
+                    }
+                },
+                onError: async (err) => {
+                    hasResponse = true;
+                    log.error('dispatch', `Dispatch error: ${err}`);
+                    await sendReply(`[错误] ${String(err)}`);
+                },
+            },
+            replyOptions: {},
+        });
+        log.info('dispatch', `Dispatch completed, hasResponse: ${hasResponse}`);
+    }
+    catch (error) {
+        log.error('dispatch', `Message processing failed: ${error}`);
+    }
+    finally {
+        if (!isGroup) {
+            // 输入状态
+            await setInputStatus({
+                user_id: senderId,
+                event_type: 2
+            });
+        }
+    }
+}
+/**
+ * Handle group message event
+ */
+export async function handleGroupMessage(event) {
+    const content = await napCatToOpenClawMessage(event.message);
+    const plainText = await contentToPlainText(content);
+    const media = await contextToMedia(content);
+    const reply = await contextToReply(content);
+    log.info('dispatch', `Group message from ${event.sender?.nickname || event.sender?.card || event.user_id}: ${plainText}, media: ${media != undefined}, reply: ${reply != undefined}`);
+    await dispatchMessage({
+        chatType: 'group',
+        chatId: String(event.group_id),
+        senderId: String(event.user_id),
+        senderName: event.sender?.nickname || event.sender?.card,
+        messageId: String(event.message_id),
+        content: plainText,
+        media,
+        reply,
+        timestamp: event.time * 1000,
+    });
+}
+/**
+ * Handle private message event
+ */
+export async function handlePrivateMessage(event) {
+    const content = await napCatToOpenClawMessage(event.message);
+    const plainText = await contentToPlainText(content);
+    const media = await contextToMedia(content);
+    const reply = await contextToReply(content);
+    log.info('dispatch', `Private message from ${event.sender?.nickname || event.user_id}: ${plainText}, media: ${media != undefined}, reply: ${reply != undefined}`);
+    await dispatchMessage({
+        chatType: 'direct',
+        chatId: String(event.user_id),
+        senderId: String(event.user_id),
+        senderName: event.sender?.nickname,
+        messageId: String(event.message_id),
+        content: plainText,
+        media,
+        reply,
+        timestamp: event.time * 1000,
+    });
+}
+/**
+ * Handle poke event
+ */
+function extractPokeActionText(rawInfo) {
+    if (!rawInfo)
+        return '戳了戳';
+    const actionItem = rawInfo.find(item => item.type === 'nor' && item.txt);
+    return actionItem?.txt || '戳了戳';
+}
+export async function handlePokeEvent(event) {
+    const actionText = extractPokeActionText(event.raw_info);
+    log.info('dispatch', `Poke from ${event.user_id}: ${actionText}`);
+    const pokeMessage = actionText || '戳了戳';
+    const chatType = event.group_id ? 'group' : 'direct';
+    const chatId = String(event.group_id || event.user_id);
+    await dispatchMessage({
+        chatType,
+        chatId,
+        senderId: String(event.user_id),
+        senderName: String(event.user_id),
+        messageId: `poke_${event.user_id}_${Date.now()}`,
+        content: `[动作] ${pokeMessage}`,
+        timestamp: Date.now(),
+    });
+}

package/dist/src/core/request.d.ts

@@ -0,0 +1,26 @@
+import type { GetFileReq, GetFileResp, GetMsgReq, GetMsgResp, NapCatResp, SendMsgReq, SendMsgResp, SetInputStatusReq } from "../types/index.js";
+/**
+ * 事件监听
+ * @param event
+ */
+export declare function eventListener(event: any): Promise<void>;
+/**
+ * 发送消息
+ * @param params
+ */
+export declare function sendMsg(params: SendMsgReq): Promise<NapCatResp<SendMsgResp>>;
+/**
+ * 获取消息
+ * @param params
+ */
+export declare function getMsg(params: GetMsgReq): Promise<NapCatResp<GetMsgResp>>;
+/**
+ * 获取文件
+ * @param params
+ */
+export declare function getFile(params: GetFileReq): Promise<NapCatResp<GetFileResp>>;
+/**
+ * 设置输入状态
+ * @param params
+ */
+export declare function setInputStatus(params: SetInputStatusReq): Promise<NapCatResp<void>>;