@izhimu/qq 0.5.1 → 0.6.0

package/dist/src/core/auth.js

@@ -0,0 +1,154 @@
+/**
+ * QQ 频道授权模块
+ *
+ * 使用三明治模式 (Sandwich Pattern) 集成 OpenClaw 原生授权系统:
+ *
+ * 1. 预处理层 (QQ 特有): denyFrom, policy='deny'
+ * 2. SDK 层 (OpenClaw 原生): commands.allowFrom 检查
+ * 3. 后处理层 (QQ 特有): allowFrom 覆盖, policy='allowlist'
+ *
+ * 授权优先级链 (从高到低):
+ * 1. denyFrom - 绝对拒绝
+ * 2. policy='deny' - 频道级全局拒绝
+ * 3. allowFrom - 频道级白名单 (最高优先授权)
+ * 4. commands.allowFrom.qq - 全局 QQ 专属授权
+ * 5. commands.allowFrom["*"] - 全局通配授权
+ * 6. policy='allow' - 频道级全局允许
+ * 7. policy='allowlist' 未匹配 - 拒绝
+ * 8. 默认 - 拒绝
+ */
+import { Logger as log } from "../utils/index.js";
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * 检查发送者是否在 allowFrom 列表中
+ */
+function isSenderInList(senderId, allowFrom) {
+    if (!allowFrom || allowFrom.length === 0)
+        return false;
+    return allowFrom.includes(senderId);
+}
+// ============================================================================
+// Main Function
+// ============================================================================
+/**
+ * 解析 QQ 频道命令授权
+ *
+ * 使用三明治模式整合 QQ 特有配置与 OpenClaw 全局授权系统
+ */
+export function resolveQQCommandAuthorization(params) {
+    const { senderId, qqConfig } = params;
+    // ============================================================
+    // 第一层: 预处理 (QQ 特有的"硬拒绝"规则)
+    // ============================================================
+    // Level 1: denyFrom 黑名单 (绝对拒绝，不可被任何规则覆盖)
+    if (isSenderInList(senderId, qqConfig.denyFrom)) {
+        log.info("auth", `Authorization denied for user ${senderId}: in denyFrom list`);
+        return {
+            providerId: "qq",
+            ownerList: [],
+            senderId,
+            senderIsOwner: false,
+            isAuthorizedSender: false,
+            denialReason: "denyFrom",
+        };
+    }
+    // Level 2: policy='deny' (频道级全局拒绝)
+    if (qqConfig.policy === "deny") {
+        log.info("auth", `Authorization denied for user ${senderId}: channel policy is deny`);
+        return {
+            providerId: "qq",
+            ownerList: [],
+            senderId,
+            senderIsOwner: false,
+            isAuthorizedSender: false,
+            denialReason: "policy_deny",
+        };
+    }
+    // ============================================================
+    // 第二层: 频道级 allowFrom (最高优先级授权)
+    // 这一层优先于 SDK，符合"最小权限原则"
+    // ============================================================
+    // Level 3: 频道级 allowFrom 白名单
+    if (qqConfig.allowFrom?.length && qqConfig.allowFrom.includes(senderId)) {
+        log.debug("auth", `Authorization granted for user ${senderId}: in channel allowFrom`);
+        return {
+            providerId: "qq",
+            ownerList: qqConfig.allowFrom,
+            senderId,
+            senderIsOwner: true,
+            isAuthorizedSender: true,
+            matchedBy: "channel_allowFrom",
+        };
+    }
+    // ============================================================
+    // 第三层: 后处理 (QQ 特有的覆盖规则)
+    // ============================================================
+    // Level 6: policy='allow' (频道级全局允许)
+    if (qqConfig.policy === "allow") {
+        log.debug("auth", `Authorization granted for user ${senderId}: channel policy is allow`);
+        return {
+            providerId: "qq",
+            ownerList: [],
+            senderId,
+            senderIsOwner: false,
+            isAuthorizedSender: true,
+            matchedBy: "policy_allow",
+        };
+    }
+    // Level 7: policy='allowlist' 但未匹配 allowFrom
+    if (qqConfig.policy === "allowlist") {
+        log.info("auth", `Authorization denied for user ${senderId}: not in allowlist`);
+        return {
+            providerId: "qq",
+            ownerList: [],
+            senderId,
+            senderIsOwner: false,
+            isAuthorizedSender: false,
+            denialReason: "not_in_allowlist",
+        };
+    }
+    // Level 8: 默认拒绝
+    log.info("auth", `Authorization denied for user ${senderId}: no matching authorization rule`);
+    return {
+        providerId: "qq",
+        ownerList: [],
+        senderId,
+        senderIsOwner: false,
+        isAuthorizedSender: false,
+        denialReason: "default_deny",
+    };
+}
+// ============================================================================
+// Utility Functions for dispatch.ts
+// ============================================================================
+/**
+ * 默认群组配置（用于私聊场景）
+ */
+const DEFAULT_GROUP_CONFIG = {
+    requireMention: false,
+    requirePoke: false,
+    historyLimit: 20,
+};
+/**
+ * 根据 chatType 获取对应的 QQ 配置
+ * 统一返回 QQGroupConfig 类型，私聊时使用默认值填充群组特有字段
+ */
+export function getQQConfigByChatType(isGroup, groupId, config) {
+    // 私聊：返回 messageDirect + 默认群组配置
+    if (!isGroup) {
+        return {
+            ...DEFAULT_GROUP_CONFIG,
+            ...config.messageDirect,
+        };
+    }
+    // 群聊：检查是否有特定群组配置
+    if (groupId && config.messageGroupsCustom[groupId]) {
+        return {
+            ...config.messageGroup,
+            ...config.messageGroupsCustom[groupId],
+        };
+    }
+    return config.messageGroup;
+}

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

@@ -1,10 +1,7 @@
-/**
- * QQ 配置管理
- */
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
-import type { QQConfig } from "../types";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+import type { QQAccount } from "../types";
 import { z } from "zod";
-export declare const CHANNEL_ID = "qq";
+export declare const QQ_CHANNEL = "qq";
 export declare const DEBUG_MODE = false;
 /**
  * 列出所有 QQ 账户ID
@@ -15,7 +12,8 @@ export declare function listQQAccountIds(cfg: OpenClawConfig): string[];
  */
 export declare function resolveQQAccount(params: {
     cfg: OpenClawConfig;
-}): QQConfig;
+    accountId?: string | null;
+}): QQAccount;
 export declare const QQDirectConfigSchema: z.ZodObject<{
     policy: z.ZodDefault<z.ZodEnum<{
         allow: "allow";

package/dist/src/core/config.js

@@ -1,17 +1,14 @@
-/**
- * QQ 配置管理
- */
-import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/core";
 import { z } from "zod";
-export const CHANNEL_ID = "qq";
+export const QQ_CHANNEL = "qq";
 export const DEBUG_MODE = false;
 /**
  * 列出所有 QQ 账户ID
  */
 export function listQQAccountIds(cfg) {
-    const config = cfg.channels?.[CHANNEL_ID];
+    const config = cfg.channels?.[QQ_CHANNEL];
     if (config?.wsUrl) {
-        return [DEFAULT_ACCOUNT_ID];
+        return ["default"];
     }
     return [];
 }
@@ -19,8 +16,9 @@ export function listQQAccountIds(cfg) {
  * 解析 QQ 账户配置
  */
 export function resolveQQAccount(params) {
-    const config = params.cfg.channels?.[CHANNEL_ID];
+    const config = params.cfg.channels?.[QQ_CHANNEL];
     return {
+        accountId: params.accountId ?? DEFAULT_ACCOUNT_ID,
         enabled: config?.enabled !== false,
         wsUrl: config?.wsUrl ?? "",
         token: config?.accessToken ?? "",

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

@@ -3,7 +3,7 @@
  * Handles per-account WebSocket connections with auto-reconnect and heartbeat
  */
 import EventEmitter from 'events';
-import type { NapCatResp, QQConfig, ConnectionStatus, NapCatAction } from '../types';
+import type { NapCatResp, QQAccount, ConnectionStatus, NapCatAction } from '../types';
 /**
  * Connection Manager for a single NapCat account
  */
@@ -14,11 +14,9 @@ export declare class ConnectionManager extends EventEmitter {
     private lastHeartbeatTime;
     private heartbeatCheckTimer?;
     private reconnectTimer?;
-    private totalReconnectAttempts;
     private shouldReconnect;
     private pendingRequests;
-    private healthStatus;
-    constructor(config: QQConfig);
+    constructor(config: QQAccount);
     /**
      * Start the connection
      */
@@ -57,7 +55,6 @@ export declare class ConnectionManager extends EventEmitter {
     private handleClose;
     private handleConnectionFailed;
     private handleResponse;
-    private isNormalClosure;
     private scheduleReconnect;
     private clearReconnectTimer;
     /**
@@ -75,3 +72,7 @@ export declare class ConnectionManager extends EventEmitter {
     isConnected(): boolean;
 }
 export declare function failResp<T>(msg?: string): Promise<NapCatResp<T>>;
+/**
+ * Send API request via current connection
+ */
+export declare function sendRequest<T>(action: NapCatAction, params?: unknown): Promise<NapCatResp<T>>;

package/dist/src/core/connection.js

@@ -4,10 +4,11 @@
  */
 import WebSocket from 'ws';
 import EventEmitter from 'events';
-import { Logger as log, generateEchoId, calculateBackoff, getCloseCodeMessage, } from '../utils/index.js';
-const MAX_RECONNECT_ATTEMPTS = -1;
+import { Logger as log, generateEchoId, getCloseCodeMessage, } from '../utils/index.js';
+import { getConnection } from './runtime.js';
 const REQUEST_TIMEOUT = 30000; // 30 seconds
-const HEARTBEAT_TIMEOUT = 120000; // 120 seconds - time without heartbeat before reconnecting (increased for NapCat compatibility)
+const RECONNECT_INTERVAL = 5000; // 5 seconds - delay between reconnection attempts
+const HEARTBEAT_TIMEOUT = 120000; // 120 seconds - time without heartbeat before reconnecting
 const HEARTBEAT_CHECK_INTERVAL = 60000; // 60 seconds - how often to check for heartbeat timeout
 /**
  * Connection Manager for a single NapCat account
@@ -21,16 +22,9 @@ export class ConnectionManager extends EventEmitter {
     heartbeatCheckTimer;
     // Reconnection
     reconnectTimer;
-    totalReconnectAttempts = 0;
     shouldReconnect = true;
     // Pending requests
     pendingRequests = new Map();
-    // Health status
-    healthStatus = {
-        healthy: false,
-        lastHeartbeatAt: 0,
-        consecutiveFailures: 0,
-    };
     constructor(config) {
         super();
         this.config = config;
@@ -43,7 +37,6 @@ export class ConnectionManager extends EventEmitter {
      */
     async start() {
         if (this.state === 'connected' || this.state === 'connecting') {
-            log.debug('connection', `Already ${this.state}`);
             return;
         }
         this.shouldReconnect = true;
@@ -100,20 +93,6 @@ export class ConnectionManager extends EventEmitter {
             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);
@@ -127,7 +106,6 @@ export class ConnectionManager extends EventEmitter {
         if (this.pendingRequests.size === 0) {
             return;
         }
-        log.debug('connection', `Clearing ${this.pendingRequests.size} pending requests: ${reason}`);
         for (const [_echo, pending] of this.pendingRequests) {
             clearTimeout(pending.timeout);
             pending.reject(new Error(`Connection closed: ${reason}`));
@@ -146,23 +124,10 @@ export class ConnectionManager extends EventEmitter {
             const elapsed = Date.now() - this.lastHeartbeatTime;
             if (elapsed > HEARTBEAT_TIMEOUT && this.isConnected()) {
                 log.warn('connection', `Heartbeat timeout (${elapsed}ms since last heartbeat), reconnecting...`);
-                this.healthStatus = {
-                    healthy: false,
-                    lastHeartbeatAt: this.lastHeartbeatTime,
-                    consecutiveFailures: this.healthStatus.consecutiveFailures + 1,
-                };
-                this.emit('heartbeat', this.healthStatus);
                 // Close connection and trigger immediate reconnect
                 this.setState('disconnected');
                 this.close('Heartbeat timeout').then(() => {
                     if (this.shouldReconnect) {
-                        // Increment total reconnect attempts
-                        this.totalReconnectAttempts++;
-                        // Emit reconnecting event for external status updates
-                        this.emit('reconnecting', {
-                            reason: 'heartbeat-timeout',
-                            totalAttempts: this.totalReconnectAttempts,
-                        });
                         this.connect().catch(error => {
                             log.error('connection', `Reconnect failed:`, error);
                         });
@@ -170,7 +135,6 @@ export class ConnectionManager extends EventEmitter {
                 });
             }
         }, HEARTBEAT_CHECK_INTERVAL);
-        log.debug('connection', 'Started heartbeat timeout detection');
     }
     /**
      * Stop heartbeat timeout detection
@@ -179,7 +143,6 @@ export class ConnectionManager extends EventEmitter {
         if (this.heartbeatCheckTimer) {
             clearInterval(this.heartbeatCheckTimer);
             this.heartbeatCheckTimer = undefined;
-            log.debug('connection', 'Stopped heartbeat timeout detection');
         }
     }
     /**
@@ -226,9 +189,7 @@ export class ConnectionManager extends EventEmitter {
             // 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);
@@ -239,19 +200,10 @@ export class ConnectionManager extends EventEmitter {
      */
     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) {
@@ -266,7 +218,7 @@ export class ConnectionManager extends EventEmitter {
         if (this.ws === null) {
             return;
         }
-        if (this.shouldReconnect && !this.isNormalClosure(code)) {
+        if (this.shouldReconnect) {
             this.scheduleReconnect();
         }
         else {
@@ -298,10 +250,6 @@ export class ConnectionManager extends EventEmitter {
         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
@@ -310,24 +258,16 @@ export class ConnectionManager extends EventEmitter {
         if (!this.shouldReconnect) {
             return;
         }
-        if (MAX_RECONNECT_ATTEMPTS != -1 && this.totalReconnectAttempts >= 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.totalReconnectAttempts);
-        log.info('connection', `Scheduling reconnect in ${delayMs}ms (attempt ${this.totalReconnectAttempts + 1}/${MAX_RECONNECT_ATTEMPTS})`);
+        log.info('connection', `Scheduling reconnect in ${RECONNECT_INTERVAL}ms`);
         this.clearReconnectTimer();
         this.reconnectTimer = setTimeout(async () => {
-            this.totalReconnectAttempts++;
             try {
                 await this.connect();
             }
             catch (error) {
                 log.error('connection', `Reconnect failed:`, error);
             }
-        }, delayMs);
+        }, RECONNECT_INTERVAL);
     }
     clearReconnectTimer() {
         if (this.reconnectTimer) {
@@ -366,7 +306,6 @@ export class ConnectionManager extends EventEmitter {
             };
             try {
                 this.ws?.send(JSON.stringify(request));
-                log.debug('connection', `Sent request: ${action} (echo: ${echo})`);
             }
             catch (error) {
                 this.pendingRequests.delete(echo);
@@ -394,9 +333,7 @@ export class ConnectionManager extends EventEmitter {
         return {
             state: this.state,
             lastConnected: this.lastHeartbeatTime || undefined,
-            lastAttempted: this.totalReconnectAttempts > 0 ? Date.now() : undefined,
             error: this.state === 'failed' ? 'Connection failed' : undefined,
-            reconnectAttempts: this.totalReconnectAttempts > 0 ? this.totalReconnectAttempts : undefined,
         };
     }
     // ==========================================================================
@@ -416,3 +353,13 @@ export async function failResp(msg = '') {
         msg
     });
 }
+/**
+ * Send API request via current connection
+ */
+export async function sendRequest(action, params) {
+    const connection = getConnection();
+    if (!connection) {
+        return failResp();
+    }
+    return connection.sendRequest(action, params);
+}

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

@@ -1,54 +1,7 @@
-/**
- * Message Dispatch Module
- * Handles routing and dispatching incoming messages to the AI
- */
-import type { DispatchMessageParams } from '../types';
-/**
- * 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>;
+import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk/core";
+import type { QQAccount, InboundMessage } from '../types';
+export declare function createInboundHandler(params: {
+    cfg: OpenClawConfig;
+    account: QQAccount;
+    runtime: PluginRuntime;
+}): (msg: InboundMessage) => Promise<void>;