@cxyhhhhh/openclaw-qqbot 1.6.7-alpha.1

package/dist/src/message-gating.js

@@ -0,0 +1,107 @@
+/**
+ * 群消息门控 — 统一入口。
+ *
+ * 将 ignoreOtherMentions / shouldBlock / mentionGating 三层判断收敛到
+ * 一个纯函数 resolveGroupMessageGate() 中，让 gateway 主流程只关心一个结果。
+ *
+ * 按优先级串行检查：
+ *   1. ignoreOtherMentions — @了其他人但未 @bot → 丢弃（记历史）
+ *   2. shouldBlock         — 未授权控制命令静默拦截
+ *   3. mentionGating       — requireMention 门控 + 命令旁路
+ */
+// ────────────────────── Core Logic ──────────────────────
+/**
+ * 基础 mention 门控纯函数。
+ * effectiveWasMentioned = wasMentioned || implicitMention || shouldBypassMention
+ * shouldSkip = requireMention && canDetectMention && !effectiveWasMentioned
+ */
+function resolveMentionGating(params) {
+    const implicit = params.implicitMention === true;
+    const bypass = params.shouldBypassMention === true;
+    const effectiveWasMentioned = params.wasMentioned || implicit || bypass;
+    const shouldSkip = params.requireMention && params.canDetectMention && !effectiveWasMentioned;
+    return { effectiveWasMentioned, shouldSkip };
+}
+/**
+ * 带命令旁路的 mention 门控。
+ *
+ * shouldBypassMention 条件（全部满足时才旁路）：
+ * 1. requireMention    — 开启了 mention 要求
+ * 2. !wasMentioned     — 没有被直接 mention
+ * 3. !hasAnyMention    — 消息中没有任何 @（防止 @ 其他人的消息误 bypass）
+ * 4. allowTextCommands — 文本命令已启用
+ * 5. commandAuthorized — 发送者有命令权限
+ * 6. hasControlCommand — 消息是合法控制命令
+ */
+function resolveMentionGatingWithBypass(params) {
+    const shouldBypassMention = params.requireMention &&
+        !params.wasMentioned &&
+        !(params.hasAnyMention ?? false) &&
+        params.allowTextCommands &&
+        params.commandAuthorized &&
+        params.hasControlCommand;
+    return {
+        ...resolveMentionGating({
+            requireMention: params.requireMention,
+            canDetectMention: params.canDetectMention,
+            wasMentioned: params.wasMentioned,
+            implicitMention: params.implicitMention,
+            shouldBypassMention,
+        }),
+        shouldBypassMention,
+    };
+}
+// ────────────────────── Unified Gate ──────────────────────
+/**
+ * 群消息统一门控，按优先级串行判定：
+ *
+ *   1. ignoreOtherMentions — @了其他人但未 @bot → drop_other_mention
+ *   2. shouldBlock         — 未授权控制命令      → block_unauthorized_command
+ *   3. mentionGating       — 未满足 @bot 条件    → skip_no_mention
+ *   4. 通过所有检查                              → pass
+ */
+export function resolveGroupMessageGate(params) {
+    const { ignoreOtherMentions, hasAnyMention, wasMentioned, implicitMention, allowTextCommands, isControlCommand, commandAuthorized, requireMention, canDetectMention, } = params;
+    // ── Layer 1: ignoreOtherMentions ──
+    if (ignoreOtherMentions &&
+        hasAnyMention &&
+        !wasMentioned &&
+        !implicitMention) {
+        return {
+            action: "drop_other_mention",
+            effectiveWasMentioned: false,
+            shouldBypassMention: false,
+        };
+    }
+    // ── Layer 2: shouldBlock 未授权控制命令 ──
+    if (allowTextCommands && isControlCommand && !commandAuthorized) {
+        return {
+            action: "block_unauthorized_command",
+            effectiveWasMentioned: false,
+            shouldBypassMention: false,
+        };
+    }
+    // ── Layer 3: mention 门控 + 命令旁路 ──
+    const mentionGate = resolveMentionGatingWithBypass({
+        requireMention,
+        canDetectMention,
+        wasMentioned,
+        implicitMention,
+        hasAnyMention,
+        allowTextCommands,
+        hasControlCommand: isControlCommand,
+        commandAuthorized,
+    });
+    if (mentionGate.shouldSkip) {
+        return {
+            action: "skip_no_mention",
+            effectiveWasMentioned: mentionGate.effectiveWasMentioned,
+            shouldBypassMention: mentionGate.shouldBypassMention,
+        };
+    }
+    return {
+        action: "pass",
+        effectiveWasMentioned: mentionGate.effectiveWasMentioned,
+        shouldBypassMention: mentionGate.shouldBypassMention,
+    };
+}

package/dist/src/message-queue.d.ts

@@ -0,0 +1,86 @@
+import type { QueueSnapshot } from "./slash-commands.js";
+/**
+ * 消息队列项类型（用于异步处理消息，防止阻塞心跳）
+ */
+export interface QueuedMessage {
+    type: "c2c" | "guild" | "dm" | "group";
+    senderId: string;
+    senderName?: string;
+    content: string;
+    messageId: string;
+    timestamp: string;
+    channelId?: string;
+    guildId?: string;
+    groupOpenid?: string;
+    attachments?: Array<{
+        content_type: string;
+        url: string;
+        filename?: string;
+        voice_wav_url?: string;
+        asr_refer_text?: string;
+    }>;
+    /** 被引用消息的 refIdx（用户引用了哪条历史消息） */
+    refMsgIdx?: string;
+    /** 当前消息自身的 refIdx（供将来被引用） */
+    msgIdx?: string;
+    /** 事件类型（如 GROUP_AT_MESSAGE_CREATE），用于群消息合并时判断是否有 @ */
+    eventType?: string;
+    /** 发送者是否为机器人 */
+    senderIsBot?: boolean;
+    /** @ 提及列表（群消息合并时需要去重合并） */
+    mentions?: Array<{
+        scope?: "all" | "single";
+        id?: string;
+        user_openid?: string;
+        member_openid?: string;
+        username?: string;
+        bot?: boolean;
+        is_you?: boolean;
+    }>;
+    /** 消息场景（来源、扩展字段） */
+    messageScene?: {
+        source?: string;
+        ext?: string[];
+    };
+    /** 群消息合并标记：记录合并了多少条原始消息 */
+    _mergedCount?: number;
+    /** 合并前的原始消息列表（用于 gateway 侧逐条格式化信封） */
+    _mergedMessages?: QueuedMessage[];
+}
+export interface MessageQueueContext {
+    accountId: string;
+    log?: {
+        info: (msg: string) => void;
+        error: (msg: string) => void;
+        debug?: (msg: string) => void;
+    };
+    /** 外部提供的 abort 状态检查 */
+    isAborted: () => boolean;
+    /** 群聊队列上限（默认 50） */
+    groupQueueSize?: number;
+    /** 私聊/DM 队列上限（默认 20） */
+    peerQueueSize?: number;
+    /** 全局队列总量上限（默认 1000） */
+    globalQueueSize?: number;
+    /** 最大并发处理用户数（默认 10） */
+    maxConcurrentUsers?: number;
+}
+export interface MessageQueue {
+    enqueue: (msg: QueuedMessage) => void;
+    startProcessor: (handleMessageFn: (msg: QueuedMessage) => Promise<void>) => void;
+    getSnapshot: (senderPeerId: string) => QueueSnapshot;
+    getMessagePeerId: (msg: QueuedMessage) => string;
+    /** 清空指定用户的排队消息，返回被丢弃的消息数 */
+    clearUserQueue: (peerId: string) => number;
+    /** 立即执行一条消息（绕过队列），用于紧急命令 */
+    executeImmediate: (msg: QueuedMessage) => void;
+}
+/**
+ * 创建按用户并发的消息队列（同用户串行，跨用户并行）
+ *
+ * 内置群消息增强：
+ * - 群聊 / 私聊使用不同队列上限
+ * - 群聊溢出时优先丢弃 bot 消息
+ * - drain 时自动合并群聊排队消息（斜杠命令单独处理）
+ */
+export declare function createMessageQueue(ctx: MessageQueueContext): MessageQueue;

package/dist/src/message-queue.js

@@ -0,0 +1,257 @@
+// ── 消息队列默认配置 ──
+const DEFAULT_GLOBAL_QUEUE_SIZE = 1000;
+const DEFAULT_PER_PEER_QUEUE_SIZE = 20;
+const DEFAULT_GROUP_QUEUE_SIZE = 50;
+const DEFAULT_MAX_CONCURRENT_USERS = 10;
+// ── 群消息合并工具函数 ──
+/** 判断 peerId 是否属于群聊 */
+const isGroupPeer = (peerId) => peerId.startsWith("group:") || peerId.startsWith("guild:");
+/**
+ * 将多条群消息合并为一条，用于群聊场景下排队消息的批量处理。
+ * - content 拼接为多行，每行带发送者前缀
+ * - 附件合并
+ * - messageId / msgIdx / timestamp 取最后一条（用于回复引用）
+ * - mentions 合并去重
+ * - 如果有任意一条 @了你（is_you），合并结果也标记 @你
+ * - senderIsBot 只要有一条不是 bot 就算非 bot
+ */
+function mergeGroupMessages(batch) {
+    if (batch.length === 1)
+        return batch[0];
+    const last = batch[batch.length - 1];
+    const first = batch[0];
+    // 拼接内容：每条消息带发送者前缀
+    const mergedContent = batch
+        .map((m) => {
+        const name = m.senderName ?? m.senderId;
+        return `[${name}]: ${m.content}`;
+    })
+        .join("\n");
+    // 合并附件
+    const mergedAttachments = [];
+    for (const m of batch) {
+        if (m.attachments?.length) {
+            mergedAttachments.push(...m.attachments);
+        }
+    }
+    // 合并 mentions（去重 by member_openid/id）
+    const seenMentionIds = new Set();
+    const mergedMentions = [];
+    let hasAtYouEvent = false;
+    for (const m of batch) {
+        if (m.eventType === "GROUP_AT_MESSAGE_CREATE") {
+            hasAtYouEvent = true;
+        }
+        if (m.mentions) {
+            for (const mt of m.mentions) {
+                const key = mt.member_openid ?? mt.id ?? mt.user_openid ?? "";
+                if (key && seenMentionIds.has(key))
+                    continue;
+                if (key)
+                    seenMentionIds.add(key);
+                mergedMentions.push(mt);
+            }
+        }
+    }
+    // senderIsBot: 只要有一条来自非 bot 用户，就算非 bot
+    const allFromBot = batch.every((m) => m.senderIsBot);
+    return {
+        type: last.type,
+        senderId: last.senderId,
+        senderName: last.senderName,
+        senderIsBot: allFromBot,
+        content: mergedContent,
+        messageId: last.messageId,
+        timestamp: last.timestamp,
+        channelId: last.channelId,
+        guildId: last.guildId,
+        groupOpenid: last.groupOpenid,
+        attachments: mergedAttachments.length > 0 ? mergedAttachments : undefined,
+        refMsgIdx: first.refMsgIdx,
+        msgIdx: last.msgIdx,
+        eventType: hasAtYouEvent ? "GROUP_AT_MESSAGE_CREATE" : last.eventType,
+        mentions: mergedMentions.length > 0 ? mergedMentions : undefined,
+        messageScene: last.messageScene,
+        _mergedCount: batch.length,
+        _mergedMessages: batch.length > 1 ? batch : undefined,
+    };
+}
+/**
+ * 创建按用户并发的消息队列（同用户串行，跨用户并行）
+ *
+ * 内置群消息增强：
+ * - 群聊 / 私聊使用不同队列上限
+ * - 群聊溢出时优先丢弃 bot 消息
+ * - drain 时自动合并群聊排队消息（斜杠命令单独处理）
+ */
+export function createMessageQueue(ctx) {
+    const { accountId, log } = ctx;
+    const globalQueueSize = ctx.globalQueueSize ?? DEFAULT_GLOBAL_QUEUE_SIZE;
+    const peerQueueSize = ctx.peerQueueSize ?? DEFAULT_PER_PEER_QUEUE_SIZE;
+    const groupQueueSize = ctx.groupQueueSize ?? DEFAULT_GROUP_QUEUE_SIZE;
+    const maxConcurrentUsers = ctx.maxConcurrentUsers ?? DEFAULT_MAX_CONCURRENT_USERS;
+    const userQueues = new Map();
+    const activeUsers = new Set();
+    let handleMessageFnRef = null;
+    let totalEnqueued = 0;
+    const getMessagePeerId = (msg) => {
+        if (msg.type === "guild")
+            return `guild:${msg.channelId ?? "unknown"}`;
+        if (msg.type === "group")
+            return `group:${msg.groupOpenid ?? "unknown"}`;
+        return `dm:${msg.senderId}`;
+    };
+    /** 从满队列中淘汰一条消息（群聊优先丢弃 bot 消息，否则丢弃最旧） */
+    const evictOne = (queue, isGroup) => {
+        if (isGroup) {
+            const botIdx = queue.findIndex(m => m.senderIsBot);
+            if (botIdx >= 0)
+                return queue.splice(botIdx, 1)[0];
+        }
+        return queue.shift();
+    };
+    /** 判断消息是否为斜杠指令 */
+    const isSlashCommand = (msg) => (msg.content ?? "").trim().startsWith("/");
+    /** 处理单条消息，捕获异常并记录日志 */
+    const processOne = async (msg, peerId, label) => {
+        try {
+            await handleMessageFnRef(msg);
+            return true;
+        }
+        catch (err) {
+            log?.error(`[qqbot:${accountId}] ${label} error for ${peerId}: ${err}`);
+            return false;
+        }
+    };
+    /** 批量处理群聊排队消息：斜杠指令逐条处理，普通消息合并后处理 */
+    const drainGroupBatch = async (all, peerId) => {
+        const commands = [];
+        const normal = [];
+        for (const m of all) {
+            (isSlashCommand(m) ? commands : normal).push(m);
+        }
+        // 指令消息逐条处理
+        for (const cmd of commands) {
+            log?.info(`[qqbot:${accountId}] Processing command independently for ${peerId}: ${(cmd.content ?? "").trim().slice(0, 50)}`);
+            await processOne(cmd, peerId, "Command processor");
+        }
+        // 普通消息合并后处理
+        if (normal.length > 0) {
+            const merged = mergeGroupMessages(normal);
+            if (normal.length > 1) {
+                log?.info(`[qqbot:${accountId}] Merged ${normal.length} queued group messages for ${peerId} into one`);
+            }
+            await processOne(merged, peerId, `Message processor (merged batch of ${normal.length})`);
+        }
+    };
+    /** 处理指定 peer 队列中的消息（串行） */
+    const drainUserQueue = async (peerId) => {
+        if (activeUsers.has(peerId))
+            return;
+        if (activeUsers.size >= maxConcurrentUsers) {
+            log?.info(`[qqbot:${accountId}] Max concurrent users (${maxConcurrentUsers}) reached, ${peerId} will wait`);
+            return;
+        }
+        const queue = userQueues.get(peerId);
+        if (!queue || queue.length === 0) {
+            userQueues.delete(peerId);
+            return;
+        }
+        activeUsers.add(peerId);
+        const isGroup = isGroupPeer(peerId);
+        try {
+            while (queue.length > 0 && !ctx.isAborted()) {
+                // 群聊排队 > 1 条：批量处理
+                if (isGroup && queue.length > 1 && handleMessageFnRef) {
+                    const all = queue.splice(0, queue.length);
+                    totalEnqueued = Math.max(0, totalEnqueued - all.length);
+                    await drainGroupBatch(all, peerId);
+                    continue;
+                }
+                // 非群聊 或 队列只剩 1 条：逐条处理
+                const msg = queue.shift();
+                totalEnqueued = Math.max(0, totalEnqueued - 1);
+                if (handleMessageFnRef) {
+                    await processOne(msg, peerId, "Message processor");
+                }
+            }
+        }
+        finally {
+            activeUsers.delete(peerId);
+            userQueues.delete(peerId);
+            // 尽量填满并发槽位
+            for (const [waitingPeerId, waitingQueue] of userQueues) {
+                if (activeUsers.size >= maxConcurrentUsers)
+                    break;
+                if (waitingQueue.length > 0 && !activeUsers.has(waitingPeerId)) {
+                    drainUserQueue(waitingPeerId);
+                }
+            }
+        }
+    };
+    const enqueue = (msg) => {
+        const peerId = getMessagePeerId(msg);
+        const isGroup = isGroupPeer(peerId);
+        let queue = userQueues.get(peerId);
+        if (!queue) {
+            queue = [];
+            userQueues.set(peerId, queue);
+        }
+        // 群聊和非群聊使用不同的队列上限
+        const maxSize = isGroup ? groupQueueSize : peerQueueSize;
+        // 队列溢出：淘汰一条旧消息
+        if (queue.length >= maxSize) {
+            const dropped = evictOne(queue, isGroup);
+            totalEnqueued = Math.max(0, totalEnqueued - 1);
+            if (isGroup && dropped?.senderIsBot) {
+                log?.info(`[qqbot:${accountId}] Queue full for ${peerId}, dropping bot message ${dropped.messageId}`);
+            }
+            else {
+                log?.error(`[qqbot:${accountId}] Queue full for ${peerId}, dropping oldest message ${dropped?.messageId}`);
+            }
+        }
+        // 全局总量保护
+        totalEnqueued++;
+        if (totalEnqueued > globalQueueSize) {
+            log?.error(`[qqbot:${accountId}] Global queue limit reached (${totalEnqueued}), message from ${peerId} may be delayed`);
+        }
+        queue.push(msg);
+        log?.debug?.(`[qqbot:${accountId}] Message enqueued for ${peerId}, user queue: ${queue.length}, active users: ${activeUsers.size}`);
+        // 如果该用户没有正在处理的消息，立即启动处理
+        drainUserQueue(peerId);
+    };
+    const startProcessor = (handleMessageFn) => {
+        handleMessageFnRef = handleMessageFn;
+        log?.info(`[qqbot:${accountId}] Message processor started (per-user concurrency, max ${maxConcurrentUsers} users)`);
+    };
+    const getSnapshot = (senderPeerId) => {
+        let totalPending = 0;
+        for (const [, q] of userQueues) {
+            totalPending += q.length;
+        }
+        const senderQueue = userQueues.get(senderPeerId);
+        return {
+            totalPending,
+            activeUsers: activeUsers.size,
+            maxConcurrentUsers,
+            senderPending: senderQueue ? senderQueue.length : 0,
+        };
+    };
+    const clearUserQueue = (peerId) => {
+        const queue = userQueues.get(peerId);
+        if (!queue || queue.length === 0)
+            return 0;
+        const droppedCount = queue.length;
+        queue.length = 0;
+        totalEnqueued = Math.max(0, totalEnqueued - droppedCount);
+        return droppedCount;
+    };
+    const executeImmediate = (msg) => {
+        if (handleMessageFnRef) {
+            handleMessageFnRef(msg).catch(err => {
+                log?.error(`[qqbot:${accountId}] Immediate execution error: ${err}`);
+            });
+        }
+    };
+    return { enqueue, startProcessor, getSnapshot, getMessagePeerId, clearUserQueue, executeImmediate };
+}

package/dist/src/onboarding.d.ts

@@ -0,0 +1,10 @@
+/**
+ * QQBot CLI Onboarding Adapter
+ *
+ * 提供 openclaw onboard 命令的交互式配置支持
+ */
+import type { ChannelOnboardingAdapter } from "openclaw/plugin-sdk";
+/**
+ * QQBot Onboarding Adapter
+ */
+export declare const qqbotOnboardingAdapter: ChannelOnboardingAdapter;

package/dist/src/onboarding.js

@@ -0,0 +1,203 @@
+import { DEFAULT_ACCOUNT_ID, listQQBotAccountIds, resolveQQBotAccount } from "./config.js";
+/**
+ * 解析默认账户 ID
+ */
+function resolveDefaultQQBotAccountId(cfg) {
+    const ids = listQQBotAccountIds(cfg);
+    return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+/**
+ * QQBot Onboarding Adapter
+ */
+export const qqbotOnboardingAdapter = {
+    channel: "qqbot",
+    getStatus: async (ctx) => {
+        const cfg = ctx.cfg;
+        const configured = listQQBotAccountIds(cfg).some((accountId) => {
+            const account = resolveQQBotAccount(cfg, accountId);
+            return Boolean(account.appId && account.clientSecret);
+        });
+        return {
+            channel: "qqbot",
+            configured,
+            statusLines: [`QQ Bot: ${configured ? "已配置" : "需要 AppID 和 ClientSecret"}`],
+            selectionHint: configured ? "已配置" : "支持 QQ 群聊和私聊（流式消息）",
+            quickstartScore: configured ? 1 : 20,
+        };
+    },
+    configure: async (ctx) => {
+        const cfg = ctx.cfg;
+        const prompter = ctx.prompter;
+        const accountOverrides = ctx.accountOverrides;
+        const shouldPromptAccountIds = ctx.shouldPromptAccountIds;
+        const qqbotOverride = accountOverrides?.qqbot?.trim();
+        const defaultAccountId = resolveDefaultQQBotAccountId(cfg);
+        let accountId = qqbotOverride ?? defaultAccountId;
+        // 是否需要提示选择账户
+        if (shouldPromptAccountIds && !qqbotOverride) {
+            const existingIds = listQQBotAccountIds(cfg);
+            if (existingIds.length > 1) {
+                accountId = await prompter.select({
+                    message: "选择 QQBot 账户",
+                    options: existingIds.map((id) => ({
+                        value: id,
+                        label: id === DEFAULT_ACCOUNT_ID ? "默认账户" : id,
+                    })),
+                    initialValue: accountId,
+                });
+            }
+        }
+        let next = cfg;
+        const resolvedAccount = resolveQQBotAccount(next, accountId);
+        const accountConfigured = Boolean(resolvedAccount.appId && resolvedAccount.clientSecret);
+        const allowEnv = accountId === DEFAULT_ACCOUNT_ID;
+        const envAppId = typeof process !== "undefined" ? process.env?.QQBOT_APP_ID?.trim() : undefined;
+        const envSecret = typeof process !== "undefined" ? process.env?.QQBOT_CLIENT_SECRET?.trim() : undefined;
+        const canUseEnv = allowEnv && Boolean(envAppId && envSecret);
+        const hasConfigCredentials = Boolean(resolvedAccount.config.appId && resolvedAccount.config.clientSecret);
+        let appId = null;
+        let clientSecret = null;
+        // 显示帮助
+        if (!accountConfigured) {
+            await prompter.note([
+                "1) 打开 QQ 开放平台: https://q.qq.com/",
+                "2) 创建机器人应用，获取 AppID 和 ClientSecret",
+                "3) 在「开发设置」中添加沙箱成员（测试阶段）",
+                "4) 你也可以设置环境变量 QQBOT_APP_ID 和 QQBOT_CLIENT_SECRET",
+                "",
+                "文档: https://bot.q.qq.com/wiki/",
+                "",
+                "此版本支持流式消息发送！",
+            ].join("\n"), "QQ Bot 配置");
+        }
+        // 检测环境变量
+        if (canUseEnv && !hasConfigCredentials) {
+            const keepEnv = await prompter.confirm({
+                message: "检测到环境变量 QQBOT_APP_ID 和 QQBOT_CLIENT_SECRET，是否使用？",
+                initialValue: true,
+            });
+            if (keepEnv) {
+                next = {
+                    ...next,
+                    channels: {
+                        ...next.channels,
+                        qqbot: {
+                            ...(next.channels?.qqbot || {}),
+                            enabled: true,
+                            allowFrom: resolvedAccount.config?.allowFrom ?? ["*"],
+                        },
+                    },
+                };
+            }
+            else {
+                // 手动输入
+                appId = String(await prompter.text({
+                    message: "请输入 QQ Bot AppID",
+                    placeholder: "例如: 102146862",
+                    initialValue: resolvedAccount.appId || undefined,
+                    validate: (value) => (value?.trim() ? undefined : "AppID 不能为空"),
+                })).trim();
+                clientSecret = String(await prompter.text({
+                    message: "请输入 QQ Bot ClientSecret",
+                    placeholder: "你的 ClientSecret",
+                    validate: (value) => (value?.trim() ? undefined : "ClientSecret 不能为空"),
+                })).trim();
+            }
+        }
+        else if (hasConfigCredentials) {
+            // 已有配置
+            const keep = await prompter.confirm({
+                message: "QQ Bot 已配置，是否保留当前配置？",
+                initialValue: true,
+            });
+            if (!keep) {
+                appId = String(await prompter.text({
+                    message: "请输入 QQ Bot AppID",
+                    placeholder: "例如: 102146862",
+                    initialValue: resolvedAccount.appId || undefined,
+                    validate: (value) => (value?.trim() ? undefined : "AppID 不能为空"),
+                })).trim();
+                clientSecret = String(await prompter.text({
+                    message: "请输入 QQ Bot ClientSecret",
+                    placeholder: "你的 ClientSecret",
+                    validate: (value) => (value?.trim() ? undefined : "ClientSecret 不能为空"),
+                })).trim();
+            }
+        }
+        else {
+            // 没有配置，需要输入
+            appId = String(await prompter.text({
+                message: "请输入 QQ Bot AppID",
+                placeholder: "例如: 102146862",
+                initialValue: resolvedAccount.appId || undefined,
+                validate: (value) => (value?.trim() ? undefined : "AppID 不能为空"),
+            })).trim();
+            clientSecret = String(await prompter.text({
+                message: "请输入 QQ Bot ClientSecret",
+                placeholder: "你的 ClientSecret",
+                validate: (value) => (value?.trim() ? undefined : "ClientSecret 不能为空"),
+            })).trim();
+        }
+        // 默认允许所有人执行命令（用户无感知）
+        const allowFrom = resolvedAccount.config?.allowFrom ?? ["*"];
+        // 应用配置（markdownSupport 默认开启，如需关闭可用 set-markdown.sh）
+        if (appId && clientSecret) {
+            const existingQQBot = next.channels?.qqbot || {};
+            // 保留已有的 markdownSupport 设置，新装默认 true
+            const markdownSupport = existingQQBot.markdownSupport ?? true;
+            if (accountId === DEFAULT_ACCOUNT_ID) {
+                next = {
+                    ...next,
+                    channels: {
+                        ...next.channels,
+                        qqbot: {
+                            ...existingQQBot,
+                            enabled: true,
+                            appId,
+                            clientSecret,
+                            markdownSupport,
+                            allowFrom,
+                        },
+                    },
+                };
+            }
+            else {
+                const existingAccounts = (next.channels?.qqbot?.accounts || {});
+                const existingAccount = existingAccounts[accountId] || {};
+                const acctMarkdown = existingAccount.markdownSupport ?? true;
+                next = {
+                    ...next,
+                    channels: {
+                        ...next.channels,
+                        qqbot: {
+                            ...existingQQBot,
+                            enabled: true,
+                            accounts: {
+                                ...existingAccounts,
+                                [accountId]: {
+                                    ...existingAccount,
+                                    enabled: true,
+                                    appId,
+                                    clientSecret,
+                                    markdownSupport: acctMarkdown,
+                                    allowFrom,
+                                },
+                            },
+                        },
+                    },
+                };
+            }
+        }
+        return { success: true, cfg: next, accountId };
+    },
+    disable: (cfg) => {
+        const config = cfg;
+        return {
+            ...config,
+            channels: {
+                ...config.channels,
+                qqbot: { ...(config.channels?.qqbot || {}), enabled: false },
+            },
+        };
+    },
+};