flashclaw 1.0.0

package/dist/index.js

@@ -0,0 +1,1181 @@
+/**
+ * FlashClaw 主入口
+ * ⚡ 闪电龙虾 - 快如闪电的 AI 助手
+ */
+import 'dotenv/config';
+import fs from 'fs';
+import path from 'path';
+import { isIP } from 'net';
+import pino from 'pino';
+import { paths, ensureDirectories, getBuiltinPluginsDir } from './paths.js';
+import { pluginManager } from './plugins/manager.js';
+import { loadFromDir, watchPlugins, stopWatching } from './plugins/loader.js';
+import { getApiClient } from './core/api-client.js';
+import { getMemoryManager } from './core/memory.js';
+import { BOT_NAME, DATA_DIR, MAIN_GROUP_FOLDER, IPC_POLL_INTERVAL, TIMEZONE } from './config.js';
+import { initDatabase, storeMessage, storeChatMetadata, getMessagesSince, getChatHistory, messageExists, getAllTasks, getAllChats } from './db.js';
+import { startSchedulerLoop, stopScheduler } from './task-scheduler.js';
+import { runAgent, writeTasksSnapshot, writeGroupsSnapshot } from './agent-runner.js';
+import { loadJson, saveJson } from './utils.js';
+import { MessageQueue } from './message-queue.js';
+import { isCommand, handleCommand, getCompactSuggestion } from './commands.js';
+import { getSessionStats as getTrackerStats, resetSession as resetTrackerSession, checkCompactThreshold, getContextWindowSize } from './session-tracker.js';
+// ⚡ FlashClaw Logger
+const logger = pino({
+    level: process.env.LOG_LEVEL || 'info',
+    transport: { target: 'pino-pretty', options: { colorize: true } }
+});
+// ==================== 渠道管理 ====================
+/**
+ * 渠道管理器 - 管理所有已启用的通讯渠道插件
+ */
+class ChannelManager {
+    channels = [];
+    enabledPlatforms = [];
+    async initialize() {
+        this.channels = pluginManager.getActiveChannels();
+        this.enabledPlatforms = this.channels.map(c => c.name);
+        if (this.channels.length === 0) {
+            throw new Error('没有启用任何通讯渠道');
+        }
+    }
+    async start(onMessage) {
+        for (const channel of this.channels) {
+            channel.onMessage(onMessage);
+            await channel.start();
+            logger.info({ channel: channel.name }, '⚡ 渠道已启动');
+        }
+    }
+    async sendMessage(chatId, content, platform) {
+        // 如果指定了平台，使用指定的渠道
+        if (platform) {
+            const channel = this.channels.find(c => c.name === platform);
+            if (channel) {
+                return await channel.sendMessage(chatId, content);
+            }
+        }
+        // 否则尝试所有渠道
+        for (const channel of this.channels) {
+            try {
+                return await channel.sendMessage(chatId, content);
+            }
+            catch {
+                continue;
+            }
+        }
+        return { success: false, error: `无法发送消息到 ${chatId}` };
+    }
+    async updateMessage(messageId, content, platform) {
+        // 如果指定了平台，使用指定的渠道
+        if (platform) {
+            const channel = this.channels.find(c => c.name === platform);
+            if (channel?.updateMessage) {
+                await channel.updateMessage(messageId, content);
+                return;
+            }
+        }
+        // 尝试所有支持更新的渠道
+        for (const channel of this.channels) {
+            if (channel.updateMessage) {
+                try {
+                    await channel.updateMessage(messageId, content);
+                    return;
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+    }
+    async deleteMessage(messageId, platform) {
+        if (platform) {
+            const channel = this.channels.find(c => c.name === platform);
+            if (channel?.deleteMessage) {
+                await channel.deleteMessage(messageId);
+                return;
+            }
+        }
+        for (const channel of this.channels) {
+            if (channel.deleteMessage) {
+                try {
+                    await channel.deleteMessage(messageId);
+                    return;
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+    }
+    getEnabledPlatforms() {
+        return this.enabledPlatforms;
+    }
+    getPlatformDisplayName(platform) {
+        const names = {
+            'feishu': '飞书',
+        };
+        return names[platform] || platform;
+    }
+    shouldRespondInGroup(msg) {
+        // 检查是否被 @ 或提到机器人名称
+        const botName = process.env.BOT_NAME || 'FlashClaw';
+        return msg.content.includes(`@${botName}`) ||
+            msg.content.toLowerCase().includes(botName.toLowerCase());
+    }
+}
+// ==================== 全局状态 ====================
+let channelManager;
+let apiClient;
+let memoryManager;
+let sessions = {};
+let registeredGroups = {};
+let lastAgentTimestamp = {};
+let messageQueue;
+let isShuttingDown = false;
+// 消息历史上下文配置
+// 现在由 MemoryManager 基于 token 自动管理，这里只是一个备用限制
+const HISTORY_CONTEXT_LIMIT = 500;
+// "正在思考..." 提示配置
+// 注意：飞书不支持更新普通文本消息，所以默认禁用此功能
+// 如需启用，设置环境变量 THINKING_THRESHOLD_MS=2500（毫秒）
+const THINKING_THRESHOLD_MS = Number(process.env.THINKING_THRESHOLD_MS ?? 0);
+// 直接网页抓取触发（避免模型不触发工具）
+const WEB_FETCH_TOOL_NAME = 'web_fetch';
+const WEB_FETCH_INTENT_RE = /(抓取|获取|读取|访问|打开|爬取|网页|网站|链接|fetch|web)/i;
+const WEB_FETCH_URL_RE = /https?:\/\/[^\s<>()]+/i;
+const WEB_FETCH_DOMAIN_RE = /(?:^|[^A-Za-z0-9.-])((?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,})(:\d{2,5})?(\/[^\s<>()]*)?/i;
+const TRAILING_PUNCT_RE = /[)\],.。，;；!！?？]+$/;
+const MAX_DIRECT_FETCH_CHARS = 4000;
+const MAX_IPC_FILE_BYTES = 1024 * 1024;
+const MAX_IPC_MESSAGE_CHARS = 10000;
+const MAX_IPC_CHAT_ID_CHARS = 256;
+const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+// ==================== 状态管理 ====================
+// 默认的 main 群组配置模板（用于自动注册新会话）
+const DEFAULT_MAIN_GROUP = {
+    name: 'main',
+    folder: MAIN_GROUP_FOLDER,
+    trigger: '@', // 默认 @ 触发
+    added_at: new Date().toISOString()
+};
+function loadState() {
+    const statePath = path.join(DATA_DIR, 'router_state.json');
+    const state = loadJson(statePath, {});
+    lastAgentTimestamp = state.last_agent_timestamp || {};
+    sessions = loadJson(path.join(DATA_DIR, 'sessions.json'), {});
+    registeredGroups = loadJson(path.join(DATA_DIR, 'registered_groups.json'), {});
+    // 确保有 main 群组配置模板（用于自动注册）
+    const hasMainGroup = Object.values(registeredGroups).some(g => g.folder === MAIN_GROUP_FOLDER);
+    if (!hasMainGroup) {
+        // 用占位符 ID 注册 main 模板，实际会话会在收到消息时动态注册
+        registeredGroups['__main_template__'] = DEFAULT_MAIN_GROUP;
+        logger.info('⚡ 已初始化 main 群组模板');
+    }
+    logger.info({ groupCount: Object.keys(registeredGroups).length }, '⚡ 状态已加载');
+}
+function saveState() {
+    saveJson(path.join(DATA_DIR, 'router_state.json'), { last_agent_timestamp: lastAgentTimestamp });
+    saveJson(path.join(DATA_DIR, 'sessions.json'), sessions);
+}
+function registerGroup(chatId, group) {
+    registeredGroups[chatId] = group;
+    saveJson(path.join(DATA_DIR, 'registered_groups.json'), registeredGroups);
+    // 创建群组文件夹
+    const groupDir = path.join(paths.groups(), group.folder);
+    fs.mkdirSync(path.join(groupDir, 'logs'), { recursive: true });
+    logger.info({ chatId, name: group.name, folder: group.folder }, '⚡ 群组已注册');
+}
+/**
+ * 获取可用群组列表
+ */
+function getAvailableGroups() {
+    const chats = getAllChats();
+    const registeredIds = new Set(Object.keys(registeredGroups));
+    return chats
+        .filter(c => c.jid !== '__group_sync__')
+        .map(c => ({
+        jid: c.jid,
+        name: c.name,
+        lastActivity: c.last_message_time,
+        isRegistered: registeredIds.has(c.jid)
+    }));
+}
+// ==================== 消息处理 ====================
+/**
+ * 判断是否应该触发 Agent
+ */
+function shouldTriggerAgent(msg, group) {
+    const isMainGroup = group.folder === MAIN_GROUP_FOLDER;
+    // 主群组响应所有消息
+    if (isMainGroup) {
+        return true;
+    }
+    // 私聊始终响应
+    if (msg.chatType === 'p2p') {
+        return true;
+    }
+    // 群聊：如果有 mentions（被 @），说明渠道插件已经验证过了
+    if (msg.mentions && msg.mentions.length > 0) {
+        return true;
+    }
+    // 群聊使用智能检测（检查消息内容）
+    if (channelManager.shouldRespondInGroup(msg)) {
+        return true;
+    }
+    return false;
+}
+function extractFirstUrl(text) {
+    const match = text.match(WEB_FETCH_URL_RE);
+    if (match) {
+        return match[0].replace(TRAILING_PUNCT_RE, '');
+    }
+    const domainMatch = text.match(WEB_FETCH_DOMAIN_RE);
+    if (!domainMatch)
+        return null;
+    const host = domainMatch[1];
+    const port = domainMatch[2] ?? '';
+    const path = domainMatch[3] ?? '';
+    const candidate = `https://${host}${port}${path}`;
+    return candidate.replace(TRAILING_PUNCT_RE, '');
+}
+function isPrivateIpv4(ip) {
+    const parts = ip.split('.').map((part) => Number(part));
+    if (parts.length !== 4 || parts.some((part) => Number.isNaN(part)))
+        return false;
+    const [a, b] = parts;
+    if (a === 0)
+        return true;
+    if (a === 10)
+        return true;
+    if (a === 127)
+        return true;
+    if (a === 169 && b === 254)
+        return true;
+    if (a === 172 && b >= 16 && b <= 31)
+        return true;
+    if (a === 192 && b === 168)
+        return true;
+    if (a === 100 && b >= 64 && b <= 127)
+        return true;
+    return false;
+}
+function isPrivateIpv6(ip) {
+    const normalized = ip.toLowerCase();
+    if (normalized === '::' || normalized === '::1')
+        return true;
+    if (normalized.startsWith('fe80:'))
+        return true;
+    if (normalized.startsWith('fec0:'))
+        return true;
+    if (normalized.startsWith('fc') || normalized.startsWith('fd'))
+        return true;
+    if (normalized.includes('::ffff:')) {
+        const ipv4Part = normalized.split('::ffff:')[1];
+        if (ipv4Part && isPrivateIpv4(ipv4Part))
+            return true;
+    }
+    return false;
+}
+function isPrivateIp(ip) {
+    const family = isIP(ip);
+    if (family === 4)
+        return isPrivateIpv4(ip);
+    if (family === 6)
+        return isPrivateIpv6(ip);
+    return false;
+}
+function isBlockedHostname(hostname) {
+    const normalized = hostname.trim().toLowerCase();
+    if (normalized === 'localhost')
+        return true;
+    return (normalized.endsWith('.localhost') ||
+        normalized.endsWith('.local') ||
+        normalized.endsWith('.internal'));
+}
+function estimateBase64Bytes(content) {
+    if (!content)
+        return null;
+    const raw = content.startsWith('data:') ? content.split(',')[1] ?? '' : content;
+    const normalized = raw.replace(/\s+/g, '');
+    if (!normalized)
+        return 0;
+    const padding = normalized.endsWith('==') ? 2 : normalized.endsWith('=') ? 1 : 0;
+    return Math.max(0, Math.floor((normalized.length * 3) / 4) - padding);
+}
+function truncateText(text, maxLength) {
+    if (text.length <= maxLength) {
+        return { text, truncated: false };
+    }
+    return { text: `${text.slice(0, maxLength)}\n\n...（内容已截断）`, truncated: true };
+}
+function formatDirectWebFetchResponse(url, result) {
+    if (!result.success) {
+        return `❌ 抓取失败: ${result.error || '未知错误'}`;
+    }
+    const data = result.data;
+    const content = typeof data?.content === 'string'
+        ? data.content
+        : typeof result.data === 'string'
+            ? result.data
+            : JSON.stringify(result.data ?? {}, null, 2);
+    const { text } = truncateText(content, MAX_DIRECT_FETCH_CHARS);
+    const lines = [];
+    lines.push(`✅ 已抓取: ${typeof data?.finalUrl === 'string' ? data.finalUrl : url}`);
+    if (typeof data?.title === 'string' && data.title.trim()) {
+        lines.push(`📝 标题: ${data.title.trim()}`);
+    }
+    if (typeof data?.status === 'number') {
+        lines.push(`📡 状态: ${data.status}`);
+    }
+    if (typeof data?.contentType === 'string') {
+        lines.push(`📄 类型: ${data.contentType}`);
+    }
+    if (typeof data?.bytes === 'number') {
+        lines.push(`📦 大小: ${data.bytes} bytes`);
+    }
+    lines.push('');
+    lines.push(text);
+    return lines.join('\n');
+}
+async function tryHandleDirectWebFetch(msg, group) {
+    const content = msg.content?.trim();
+    if (!content)
+        return false;
+    if (!WEB_FETCH_INTENT_RE.test(content))
+        return false;
+    const url = extractFirstUrl(content);
+    if (!url)
+        return false;
+    let urlObj;
+    try {
+        urlObj = new URL(url);
+    }
+    catch {
+        await sendMessage(msg.chatId, `${BOT_NAME}: URL 格式不合法`, msg.platform);
+        return true;
+    }
+    if (!['http:', 'https:'].includes(urlObj.protocol)) {
+        await sendMessage(msg.chatId, `${BOT_NAME}: 只支持 HTTP/HTTPS 协议`, msg.platform);
+        return true;
+    }
+    const allowPrivate = process.env.WEB_FETCH_ALLOW_PRIVATE === '1';
+    const hostname = urlObj.hostname;
+    if (!allowPrivate && (isBlockedHostname(hostname) || (isIP(hostname) && isPrivateIp(hostname)))) {
+        await sendMessage(msg.chatId, `${BOT_NAME}: 目标地址禁止访问内网`, msg.platform);
+        return true;
+    }
+    const toolInfo = pluginManager.getTool(WEB_FETCH_TOOL_NAME);
+    if (!toolInfo) {
+        await sendMessage(msg.chatId, `${BOT_NAME}: 未检测到 web_fetch 插件，请先安装后再使用。`, msg.platform);
+        return true;
+    }
+    const toolContext = {
+        chatId: msg.chatId,
+        groupId: group.folder,
+        userId: msg.senderId,
+        sendMessage: async (text) => {
+            await sendMessage(msg.chatId, `${BOT_NAME}: ${text}`, msg.platform);
+        }
+    };
+    const normalizedUrl = urlObj.toString();
+    logger.info({ chatId: msg.chatId, url: normalizedUrl }, '⚡ 触发直接网页抓取');
+    let result;
+    try {
+        const { plugin, isMultiTool } = toolInfo;
+        result = isMultiTool
+            ? await plugin.execute(WEB_FETCH_TOOL_NAME, { url: normalizedUrl, allowPrivate }, toolContext)
+            : await plugin.execute({ url: normalizedUrl, allowPrivate }, toolContext);
+    }
+    catch (error) {
+        result = { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+    const response = formatDirectWebFetchResponse(normalizedUrl, result);
+    await sendMessage(msg.chatId, `${BOT_NAME}: ${response}`, msg.platform);
+    return true;
+}
+/**
+ * 处理队列中的消息
+ */
+async function processQueuedMessage(queuedMsg) {
+    const msg = queuedMsg.data;
+    const chatId = msg.chatId;
+    const group = registeredGroups[chatId];
+    logger.info({ chatId, msgId: msg.id }, '>>> 开始处理队列消息');
+    if (!group) {
+        logger.info({ chatId }, '群组未注册，跳过');
+        return;
+    }
+    // 获取自上次交互以来的消息
+    const sinceTimestamp = lastAgentTimestamp[chatId] || '';
+    logger.info({ chatId, sinceTimestamp }, '>>> 查询新消息');
+    const missedMessages = getMessagesSince(chatId, sinceTimestamp, BOT_NAME);
+    logger.info({ chatId, count: missedMessages.length }, '>>> 获取到消息数量');
+    if (missedMessages.length === 0) {
+        logger.info({ chatId, sinceTimestamp }, '无新消息，可能时间戳问题');
+        return;
+    }
+    // 获取历史上下文
+    const historyMessages = getChatHistory(chatId, HISTORY_CONTEXT_LIMIT, sinceTimestamp);
+    const escapeXml = (s) => s
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+    // 构建带历史上下文的 prompt
+    let prompt = '';
+    if (historyMessages.length > 0) {
+        const historyLines = historyMessages.map(m => `<message sender="${escapeXml(m.sender_name)}" time="${m.timestamp}">${escapeXml(m.content)}</message>`);
+        prompt += `<history_context>\n${historyLines.join('\n')}\n</history_context>\n\n`;
+    }
+    const newLines = missedMessages.map(m => `<message sender="${escapeXml(m.sender_name)}" time="${m.timestamp}">${escapeXml(m.content)}</message>`);
+    prompt += `<new_messages>\n${newLines.join('\n')}\n</new_messages>`;
+    // 提取图片附件（只处理当前消息的附件）
+    const imageAttachments = msg.attachments
+        ?.filter(a => a.type === 'image' && a.content)
+        .filter(a => {
+        const size = estimateBase64Bytes(a.content || '');
+        if (size === null)
+            return false;
+        if (size > MAX_IMAGE_BYTES) {
+            logger.warn({ chatId, size }, '附件过大，已忽略');
+            return false;
+        }
+        return true;
+    })
+        .map(a => ({
+        type: 'image',
+        content: a.content,
+        mimeType: a.mimeType
+    })) || [];
+    logger.info({
+        group: group.name,
+        newMessages: missedMessages.length,
+        historyContext: historyMessages.length,
+        platform: msg.platform,
+        imageCount: imageAttachments.length
+    }, '⚡ 处理消息');
+    // "正在思考..." 提示功能
+    let placeholderMessageId;
+    let thinkingDone = false;
+    // 设置定时器，超过阈值时发送"正在思考..."
+    const thinkingTimer = THINKING_THRESHOLD_MS > 0 ? setTimeout(async () => {
+        if (thinkingDone)
+            return;
+        try {
+            const result = await channelManager.sendMessage(chatId, `${BOT_NAME}: 正在思考...`, msg.platform);
+            if (result.success && result.messageId) {
+                placeholderMessageId = result.messageId;
+                logger.debug({ chatId, messageId: placeholderMessageId }, '已发送思考提示');
+            }
+        }
+        catch {
+            // 忽略错误
+        }
+    }, THINKING_THRESHOLD_MS) : null;
+    try {
+        const response = await executeAgent(group, prompt, chatId, {
+            attachments: imageAttachments.length > 0 ? imageAttachments : undefined,
+            userId: msg.senderId // 传递用户 ID 用于用户级别记忆
+        });
+        thinkingDone = true;
+        if (thinkingTimer) {
+            clearTimeout(thinkingTimer);
+        }
+        if (response) {
+            lastAgentTimestamp[chatId] = msg.timestamp;
+            saveState();
+            const finalText = `${BOT_NAME}: ${response}`;
+            // 如果有占位消息，更新它；否则发送新消息
+            if (placeholderMessageId) {
+                try {
+                    await channelManager.updateMessage(placeholderMessageId, finalText, msg.platform);
+                    logger.info({ chatId, messageId: placeholderMessageId }, '⚡ 消息已更新');
+                }
+                catch {
+                    // 更新失败，尝试删除并发送新消息
+                    try {
+                        await channelManager.deleteMessage(placeholderMessageId, msg.platform);
+                    }
+                    catch { }
+                    await sendMessage(chatId, finalText, msg.platform);
+                }
+            }
+            else {
+                await sendMessage(chatId, finalText, msg.platform);
+            }
+            // 检查是否需要提示用户压缩会话（70% 阈值）
+            const usagePercent = checkCompactThreshold(chatId);
+            if (usagePercent !== null) {
+                const stats = getTrackerStats(chatId);
+                if (stats) {
+                    const suggestion = getCompactSuggestion(stats.tokenCount, stats.maxTokens);
+                    await sendMessage(chatId, suggestion, msg.platform);
+                    logger.info({ chatId, usagePercent }, '⚠️ 上下文使用率提示已发送');
+                }
+            }
+        }
+        else if (placeholderMessageId) {
+            // 没有响应，删除占位消息
+            try {
+                await channelManager.deleteMessage(placeholderMessageId, msg.platform);
+            }
+            catch { }
+        }
+    }
+    catch (err) {
+        thinkingDone = true;
+        if (thinkingTimer) {
+            clearTimeout(thinkingTimer);
+        }
+        // 删除占位消息
+        if (placeholderMessageId) {
+            try {
+                await channelManager.deleteMessage(placeholderMessageId, msg.platform);
+            }
+            catch { }
+        }
+        throw err;
+    }
+}
+/**
+ * 处理传入消息
+ */
+async function handleIncomingMessage(msg) {
+    const chatId = msg.chatId;
+    // 存储聊天元数据
+    storeChatMetadata(chatId, msg.timestamp);
+    // 获取群组配置
+    let group = registeredGroups[chatId];
+    // 自动注册新会话（参考 openclaw 的动态 session key 设计）
+    if (!group) {
+        // 查找 main 群组配置作为模板
+        const mainGroup = Object.values(registeredGroups).find(g => g.folder === MAIN_GROUP_FOLDER);
+        if (mainGroup) {
+            // 根据聊天类型生成名称和文件夹
+            const chatName = msg.chatType === 'p2p'
+                ? `私聊-${msg.senderName || chatId.slice(-8)}`
+                : `群聊-${chatId.slice(-8)}`;
+            // 为新会话创建独立的文件夹名称（使用 chatId 后8位确保唯一性）
+            const folderName = msg.chatType === 'p2p'
+                ? `private-${chatId.slice(-8)}`
+                : `group-${chatId.slice(-8)}`;
+            // 创建新的群组配置（使用独立的 folder）
+            const newGroup = {
+                ...mainGroup,
+                name: chatName,
+                folder: folderName,
+                added_at: new Date().toISOString()
+            };
+            // 动态注册此会话
+            registerGroup(chatId, newGroup);
+            // 使用新创建的群组（而不是 mainGroup）
+            group = newGroup;
+            logger.info({
+                chatId,
+                chatType: msg.chatType,
+                name: chatName,
+                folder: folderName
+            }, '⚡ 会话已自动注册');
+        }
+    }
+    if (!group) {
+        logger.debug({ chatId, platform: msg.platform, chatType: msg.chatType }, '未注册的聊天，忽略');
+        return;
+    }
+    // 去重检查
+    if (messageExists(msg.id, chatId)) {
+        logger.debug({ chatId, messageId: msg.id }, '重复消息，忽略');
+        return;
+    }
+    // 存储消息
+    storeMessage({
+        id: msg.id,
+        chatId: chatId,
+        senderId: msg.senderId,
+        senderName: msg.senderName,
+        content: msg.content,
+        timestamp: msg.timestamp,
+        isFromMe: false
+    });
+    // 检查触发条件
+    const shouldTrigger = shouldTriggerAgent(msg, group);
+    logger.info({ chatId, shouldTrigger, chatType: msg.chatType }, '>>> 触发检查');
+    if (!shouldTrigger) {
+        return;
+    }
+    // 检查是否是斜杠命令
+    if (isCommand(msg.content)) {
+        const context = {
+            chatId,
+            userId: msg.senderId,
+            userName: msg.senderName || '用户',
+            platform: msg.platform,
+            getSessionStats: () => {
+                // 获取真实的 token 统计数据
+                const trackerStats = getTrackerStats(chatId);
+                if (trackerStats) {
+                    return {
+                        messageCount: trackerStats.messageCount,
+                        tokenCount: trackerStats.tokenCount,
+                        maxTokens: trackerStats.maxTokens,
+                        model: trackerStats.model,
+                        startedAt: trackerStats.startedAt
+                    };
+                }
+                // 回退到历史记录（服务重启后 tracker 数据会丢失）
+                const history = getChatHistory(chatId, 1000);
+                const model = process.env.AI_MODEL || 'claude-4-5-sonnet-20250929';
+                return {
+                    messageCount: history.length,
+                    tokenCount: 0, // 服务重启后需要重新统计
+                    maxTokens: getContextWindowSize(model),
+                    model,
+                    startedAt: history.length > 0 ? history[0].timestamp : undefined
+                };
+            },
+            resetSession: () => {
+                // 重置会话（清除内存中的 session ID 和 tracker）
+                if (sessions[group.folder]) {
+                    delete sessions[group.folder];
+                }
+                resetTrackerSession(chatId);
+                logger.info({ chatId, folder: group.folder }, '⚡ 会话已重置');
+            },
+            getTasks: () => {
+                // 获取该会话的任务
+                const tasks = getAllTasks();
+                return tasks
+                    .filter(t => t.chat_jid === chatId || group.folder === MAIN_GROUP_FOLDER)
+                    .map(t => ({
+                    id: t.id,
+                    prompt: t.prompt,
+                    scheduleType: t.schedule_type,
+                    nextRun: t.next_run || undefined,
+                    status: t.status
+                }));
+            },
+            compactSession: async () => {
+                // 压缩会话：让 AI 总结当前对话，然后重置会话
+                try {
+                    const summary = await executeAgent(group, '请用 2-3 句话总结我们之前的对话要点，以便我们继续对话时能快速回顾。只输出总结，不要其他内容。', chatId, { userId: msg.senderId });
+                    // 重置会话和 tracker
+                    if (sessions[group.folder]) {
+                        delete sessions[group.folder];
+                    }
+                    resetTrackerSession(chatId);
+                    // 发送压缩完成消息
+                    if (summary) {
+                        await channelManager.sendMessage(chatId, `✅ **会话已压缩**\n\n📝 **对话摘要:**\n${summary}\n\n_上下文已清理，新对话已基于此摘要继续。_`, msg.platform);
+                    }
+                    return summary;
+                }
+                catch (error) {
+                    logger.error({ error, chatId }, '会话压缩失败');
+                    return null;
+                }
+            }
+        };
+        const result = handleCommand(msg.content, context);
+        if (result.isCommand && result.shouldRespond && result.response) {
+            // 发送命令响应
+            await channelManager.sendMessage(chatId, result.response, msg.platform);
+            // 如果是 /compact 命令，执行实际压缩
+            if (msg.content.trim().toLowerCase().startsWith('/compact') ||
+                msg.content.trim() === '/压缩') {
+                context.compactSession?.();
+            }
+            logger.info({ chatId, command: msg.content }, '⚡ 命令已处理');
+            return;
+        }
+    }
+    // 直接抓取网页（避免模型不触发工具）
+    if (await tryHandleDirectWebFetch(msg, group)) {
+        return;
+    }
+    // 添加到消息队列
+    logger.info({ chatId, msgId: msg.id }, '>>> 加入消息队列');
+    await messageQueue.enqueue(chatId, msg.id, msg);
+}
+async function executeAgent(group, prompt, chatId, options) {
+    const isMain = group.folder === MAIN_GROUP_FOLDER;
+    const sessionId = sessions[group.folder];
+    // 更新任务快照
+    const tasks = getAllTasks();
+    writeTasksSnapshot(group.folder, isMain, tasks.map(t => ({
+        id: t.id,
+        groupFolder: t.group_folder,
+        prompt: t.prompt,
+        schedule_type: t.schedule_type,
+        schedule_value: t.schedule_value,
+        status: t.status,
+        next_run: t.next_run
+    })));
+    // 更新可用群组快照
+    const availableGroups = getAvailableGroups();
+    writeGroupsSnapshot(group.folder, isMain, availableGroups, new Set(Object.keys(registeredGroups)));
+    try {
+        const output = await runAgent(group, {
+            prompt,
+            sessionId,
+            groupFolder: group.folder,
+            chatJid: chatId,
+            isMain,
+            userId: options?.userId || chatId, // 用户级别记忆
+            attachments: options?.attachments
+        });
+        if (output.newSessionId) {
+            sessions[group.folder] = output.newSessionId;
+            saveJson(path.join(DATA_DIR, 'sessions.json'), sessions);
+        }
+        if (output.status === 'error') {
+            logger.error({ group: group.name, error: output.error }, 'Agent 错误');
+            return null;
+        }
+        return output.result;
+    }
+    catch (err) {
+        logger.error({ group: group.name, err }, 'Agent 执行失败');
+        return null;
+    }
+}
+// ==================== 消息发送 ====================
+async function sendMessage(chatId, text, platform) {
+    try {
+        await channelManager.sendMessage(chatId, text, platform);
+        logger.info({ chatId, length: text.length, platform }, '⚡ 消息已发送');
+    }
+    catch (err) {
+        logger.error({ chatId, err, platform }, '发送消息失败');
+    }
+}
+// ==================== IPC 处理 ====================
+function quarantineIpcFile(ipcBaseDir, sourceGroup, filePath, reason, err) {
+    const errorDir = path.join(ipcBaseDir, 'errors');
+    const fileName = path.basename(filePath);
+    try {
+        fs.mkdirSync(errorDir, { recursive: true });
+        fs.renameSync(filePath, path.join(errorDir, `${sourceGroup}-${fileName}`));
+    }
+    catch (moveError) {
+        logger.warn({ file: fileName, sourceGroup, moveError }, '隔离 IPC 文件失败');
+        return;
+    }
+    logger.warn({ file: fileName, sourceGroup, reason, err }, 'IPC 文件已隔离');
+}
+function startIpcWatcher() {
+    const ipcBaseDir = path.join(DATA_DIR, 'ipc');
+    fs.mkdirSync(ipcBaseDir, { recursive: true });
+    const processIpcFiles = async () => {
+        let groupFolders;
+        try {
+            groupFolders = fs.readdirSync(ipcBaseDir).filter(f => {
+                const stat = fs.statSync(path.join(ipcBaseDir, f));
+                return stat.isDirectory() && f !== 'errors';
+            });
+        }
+        catch (err) {
+            logger.error({ err }, '读取 IPC 目录失败');
+            setTimeout(processIpcFiles, IPC_POLL_INTERVAL);
+            return;
+        }
+        for (const sourceGroup of groupFolders) {
+            const isMain = sourceGroup === MAIN_GROUP_FOLDER;
+            const messagesDir = path.join(ipcBaseDir, sourceGroup, 'messages');
+            const tasksDir = path.join(ipcBaseDir, sourceGroup, 'tasks');
+            // 处理消息
+            try {
+                if (fs.existsSync(messagesDir)) {
+                    const messageFiles = fs.readdirSync(messagesDir).filter(f => f.endsWith('.json'));
+                    for (const file of messageFiles) {
+                        const filePath = path.join(messagesDir, file);
+                        try {
+                            const stat = fs.statSync(filePath);
+                            if (stat.size > MAX_IPC_FILE_BYTES) {
+                                quarantineIpcFile(ipcBaseDir, sourceGroup, filePath, `IPC 消息文件过大 (${stat.size} bytes)`);
+                                continue;
+                            }
+                            const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                            if (data.type === 'message' && data.chatJid && data.text) {
+                                if (typeof data.chatJid !== 'string' || data.chatJid.length > MAX_IPC_CHAT_ID_CHARS) {
+                                    logger.warn({ sourceGroup }, 'IPC 消息 chatJid 格式不合法');
+                                    fs.unlinkSync(filePath);
+                                    continue;
+                                }
+                                if (typeof data.text !== 'string' || data.text.length > MAX_IPC_MESSAGE_CHARS) {
+                                    logger.warn({ sourceGroup }, 'IPC 消息 text 过长或格式不合法');
+                                    fs.unlinkSync(filePath);
+                                    continue;
+                                }
+                                const targetGroup = registeredGroups[data.chatJid];
+                                if (isMain || (targetGroup && targetGroup.folder === sourceGroup)) {
+                                    await sendMessage(data.chatJid, `${BOT_NAME}: ${data.text}`);
+                                    logger.info({ chatId: data.chatJid, sourceGroup }, 'IPC 消息已发送');
+                                }
+                                else {
+                                    logger.warn({ chatId: data.chatJid, sourceGroup }, '未授权的 IPC 消息被阻止');
+                                }
+                            }
+                            fs.unlinkSync(filePath);
+                        }
+                        catch (err) {
+                            logger.error({ file, sourceGroup, err }, '处理 IPC 消息失败');
+                            quarantineIpcFile(ipcBaseDir, sourceGroup, filePath, '处理 IPC 消息失败', err);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                logger.error({ err, sourceGroup }, '读取 IPC 消息目录失败');
+            }
+            // 处理任务
+            try {
+                if (fs.existsSync(tasksDir)) {
+                    const taskFiles = fs.readdirSync(tasksDir).filter(f => f.endsWith('.json'));
+                    for (const file of taskFiles) {
+                        const filePath = path.join(tasksDir, file);
+                        try {
+                            const stat = fs.statSync(filePath);
+                            if (stat.size > MAX_IPC_FILE_BYTES) {
+                                quarantineIpcFile(ipcBaseDir, sourceGroup, filePath, `IPC 任务文件过大 (${stat.size} bytes)`);
+                                continue;
+                            }
+                            const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                            await processTaskIpc(data, sourceGroup, isMain);
+                            fs.unlinkSync(filePath);
+                        }
+                        catch (err) {
+                            logger.error({ file, sourceGroup, err }, '处理 IPC 任务失败');
+                            quarantineIpcFile(ipcBaseDir, sourceGroup, filePath, '处理 IPC 任务失败', err);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                logger.error({ err, sourceGroup }, '读取 IPC 任务目录失败');
+            }
+        }
+        setTimeout(processIpcFiles, IPC_POLL_INTERVAL);
+    };
+    processIpcFiles();
+    logger.info('⚡ IPC 监听已启动');
+}
+async function processTaskIpc(data, sourceGroup, isMain) {
+    const { createTask, updateTask, deleteTask, getTaskById: getTask } = await import('./db.js');
+    const { CronExpressionParser } = await import('cron-parser');
+    switch (data.type) {
+        case 'schedule_task':
+            if (data.prompt && data.schedule_type && data.schedule_value && data.groupFolder) {
+                const targetGroup = data.groupFolder;
+                if (!isMain && targetGroup !== sourceGroup) {
+                    logger.warn({ sourceGroup, targetGroup }, '未授权的 schedule_task 被阻止');
+                    break;
+                }
+                const targetChatId = Object.entries(registeredGroups).find(([, group]) => group.folder === targetGroup)?.[0];
+                if (!targetChatId) {
+                    logger.warn({ targetGroup }, '无法创建任务：目标群组未注册');
+                    break;
+                }
+                const scheduleType = data.schedule_type;
+                let nextRun = null;
+                if (scheduleType === 'cron') {
+                    try {
+                        const interval = CronExpressionParser.parse(data.schedule_value, { tz: TIMEZONE });
+                        nextRun = interval.next().toISOString();
+                    }
+                    catch {
+                        logger.warn({ scheduleValue: data.schedule_value }, '无效的 cron 表达式');
+                        break;
+                    }
+                }
+                else if (scheduleType === 'interval') {
+                    const ms = parseInt(data.schedule_value, 10);
+                    if (isNaN(ms) || ms <= 0) {
+                        logger.warn({ scheduleValue: data.schedule_value }, '无效的间隔值');
+                        break;
+                    }
+                    nextRun = new Date(Date.now() + ms).toISOString();
+                }
+                else if (scheduleType === 'once') {
+                    const scheduled = new Date(data.schedule_value);
+                    if (isNaN(scheduled.getTime())) {
+                        logger.warn({ scheduleValue: data.schedule_value }, '无效的时间戳');
+                        break;
+                    }
+                    nextRun = scheduled.toISOString();
+                }
+                const taskId = `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                const contextMode = (data.context_mode === 'group' || data.context_mode === 'isolated')
+                    ? data.context_mode
+                    : 'isolated';
+                createTask({
+                    id: taskId,
+                    group_folder: targetGroup,
+                    chat_jid: targetChatId,
+                    prompt: data.prompt,
+                    schedule_type: scheduleType,
+                    schedule_value: data.schedule_value,
+                    context_mode: contextMode,
+                    next_run: nextRun,
+                    status: 'active',
+                    created_at: new Date().toISOString(),
+                    retry_count: 0,
+                    max_retries: data.max_retries ?? 3,
+                    timeout_ms: data.timeout_ms ?? 300000
+                });
+                logger.info({ taskId, sourceGroup, targetGroup, contextMode }, '⚡ 任务已创建');
+            }
+            break;
+        case 'pause_task':
+            if (data.taskId) {
+                const task = getTask(data.taskId);
+                if (task && (isMain || task.group_folder === sourceGroup)) {
+                    updateTask(data.taskId, { status: 'paused' });
+                    logger.info({ taskId: data.taskId, sourceGroup }, '任务已暂停');
+                }
+                else {
+                    logger.warn({ taskId: data.taskId, sourceGroup }, '未授权的任务暂停操作');
+                }
+            }
+            break;
+        case 'resume_task':
+            if (data.taskId) {
+                const task = getTask(data.taskId);
+                if (task && (isMain || task.group_folder === sourceGroup)) {
+                    updateTask(data.taskId, { status: 'active' });
+                    logger.info({ taskId: data.taskId, sourceGroup }, '任务已恢复');
+                }
+                else {
+                    logger.warn({ taskId: data.taskId, sourceGroup }, '未授权的任务恢复操作');
+                }
+            }
+            break;
+        case 'cancel_task':
+            if (data.taskId) {
+                const task = getTask(data.taskId);
+                if (task && (isMain || task.group_folder === sourceGroup)) {
+                    deleteTask(data.taskId);
+                    logger.info({ taskId: data.taskId, sourceGroup }, '任务已取消');
+                }
+                else {
+                    logger.warn({ taskId: data.taskId, sourceGroup }, '未授权的任务取消操作');
+                }
+            }
+            break;
+        case 'register_group':
+            if (!isMain) {
+                logger.warn({ sourceGroup }, '未授权的 register_group 被阻止');
+                break;
+            }
+            if (data.jid && data.name && data.folder && data.trigger) {
+                registerGroup(data.jid, {
+                    name: data.name,
+                    folder: data.folder,
+                    trigger: data.trigger,
+                    added_at: new Date().toISOString(),
+                    agentConfig: data.agentConfig
+                });
+            }
+            else {
+                logger.warn({ data }, '无效的 register_group 请求');
+            }
+            break;
+        default:
+            logger.warn({ type: data.type }, '未知的 IPC 任务类型');
+    }
+}
+// ==================== 启动横幅 ====================
+function displayBanner(enabledPlatforms, groupCount) {
+    const platformsDisplay = enabledPlatforms.map(p => channelManager.getPlatformDisplayName(p)).join(' | ');
+    const banner = `
+\x1b[33m
+  ███████╗██╗      █████╗ ███████╗██╗  ██╗ ██████╗██╗      █████╗ ██╗    ██╗
+  ██╔════╝██║     ██╔══██╗██╔════╝██║  ██║██╔════╝██║     ██╔══██╗██║    ██║
+  █████╗  ██║     ███████║███████╗███████║██║     ██║     ███████║██║ █╗ ██║
+  ██╔══╝  ██║     ██╔══██║╚════██║██╔══██║██║     ██║     ██╔══██║██║███╗██║
+  ██║     ███████╗██║  ██║███████║██║  ██║╚██████╗███████╗██║  ██║╚███╔███╔╝
+  ╚═╝     ╚══════╝╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝ ╚═════╝╚══════╝╚═╝  ╚═╝ ╚══╝╚══╝ 
+\x1b[0m
+\x1b[36m  ⚡ 闪电龙虾 - 快如闪电的 AI 助手\x1b[0m
+
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │                                                                         │
+  │  \x1b[32m✓\x1b[0m 状态: \x1b[32m运行中\x1b[0m                                                        │
+  │  \x1b[32m✓\x1b[0m 模式: \x1b[33mDirect (Claude API)\x1b[0m                                           │
+  │  \x1b[32m✓\x1b[0m 平台: \x1b[36m${platformsDisplay.padEnd(55)}\x1b[0m│
+  │  \x1b[32m✓\x1b[0m 群组: \x1b[33m${String(groupCount).padEnd(55)}\x1b[0m│
+  │                                                                         │
+  │  \x1b[90m所有平台使用 WebSocket 长连接，无需公网服务器\x1b[0m                        │
+  │                                                                         │
+  └─────────────────────────────────────────────────────────────────────────┘
+
+  \x1b[90m按 Ctrl+C 停止服务\x1b[0m
+`;
+    console.log(banner);
+}
+// ==================== 主函数 ====================
+export async function main() {
+    // 确保所有必要目录存在
+    ensureDirectories();
+    // 初始化 API 客户端（全局单例）
+    apiClient = getApiClient();
+    // 初始化记忆管理器（使用全局单例）
+    memoryManager = getMemoryManager();
+    // 初始化数据库（必须在加载插件之前，因为插件可能依赖数据库）
+    initDatabase();
+    logger.info('⚡ 数据库已初始化');
+    // 加载插件（在数据库初始化之后）
+    // 先加载内置插件
+    const builtinPluginsDir = getBuiltinPluginsDir();
+    if (fs.existsSync(builtinPluginsDir)) {
+        logger.info({ dir: builtinPluginsDir }, '⚡ 加载内置插件');
+        await loadFromDir(builtinPluginsDir);
+    }
+    // 再加载用户插件（可覆盖内置插件）
+    const userPluginsDir = paths.userPlugins();
+    if (fs.existsSync(userPluginsDir)) {
+        logger.info({ dir: userPluginsDir }, '⚡ 加载用户插件');
+        await loadFromDir(userPluginsDir);
+    }
+    // 启用热重载 - 只监听用户插件目录
+    if (fs.existsSync(userPluginsDir)) {
+        watchPlugins(userPluginsDir, (event, name) => {
+            logger.info({ event, plugin: name }, '⚡ 插件变化');
+        });
+    }
+    // 初始化渠道管理器
+    channelManager = new ChannelManager();
+    try {
+        await channelManager.initialize();
+    }
+    catch (err) {
+        console.error(`
+\x1b[31m
+  ███████╗██████╗ ██████╗  ██████╗ ██████╗ 
+  ██╔════╝██╔══██╗██╔══██╗██╔═══██╗██╔══██╗
+  █████╗  ██████╔╝██████╔╝██║   ██║██████╔╝
+  ██╔══╝  ██╔══██╗██╔══██╗██║   ██║██╔══██╗
+  ███████╗██║  ██║██║  ██║╚██████╔╝██║  ██║
+  ╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝
+\x1b[0m
+  \x1b[31m✗ 缺少消息平台配置\x1b[0m
+
+  请在 \x1b[33m.env\x1b[0m 中配置飞书:
+
+  \x1b[36m飞书:\x1b[0m
+    FEISHU_APP_ID=cli_xxxxx
+    FEISHU_APP_SECRET=xxxxx
+
+  详见 \x1b[33m.env.example\x1b[0m
+`);
+        process.exit(1);
+    }
+    const enabledPlatforms = channelManager.getEnabledPlatforms();
+    logger.info({ platforms: enabledPlatforms }, '⚡ 渠道管理器已初始化');
+    // 加载状态
+    loadState();
+    // 初始化消息队列
+    messageQueue = new MessageQueue(processQueuedMessage, {
+        maxQueueSize: 100,
+        maxConcurrent: 3,
+        processingTimeout: 300000,
+        maxRetries: 2
+    });
+    messageQueue.start();
+    logger.info('⚡ 消息队列已初始化');
+    // 启动任务调度器
+    startSchedulerLoop({
+        sendMessage: (chatId, text) => sendMessage(chatId, text),
+        registeredGroups: () => registeredGroups,
+        getSessions: () => sessions
+    });
+    // 启动 IPC 监听
+    startIpcWatcher();
+    // 启动所有渠道插件
+    await channelManager.start(handleIncomingMessage);
+    // 显示启动横幅
+    const groupCount = Object.keys(registeredGroups).length;
+    displayBanner(enabledPlatforms, groupCount);
+    logger.info({
+        mode: 'direct',
+        platforms: enabledPlatforms,
+        groups: groupCount
+    }, '⚡ FlashClaw 已启动');
+    // 注册优雅关闭处理
+    setupGracefulShutdown();
+}
+// ==================== 优雅关闭 ====================
+/**
+ * 优雅关闭函数
+ */
+async function gracefulShutdown(signal) {
+    if (isShuttingDown)
+        return;
+    isShuttingDown = true;
+    logger.info({ signal }, '⚡ 收到关闭信号，正在优雅关闭...');
+    try {
+        // 1. 停止接收新消息
+        logger.info('⚡ 停止接收新消息...');
+        await pluginManager.stopAll();
+        // 2. 等待当前任务完成（最多等待 30 秒）
+        logger.info('⚡ 等待当前任务完成...');
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        // 3. 停止消息队列
+        logger.info('⚡ 停止消息队列...');
+        messageQueue?.stop();
+        // 4. 停止任务调度器
+        logger.info('⚡ 停止任务调度器...');
+        stopScheduler();
+        // 5. 停止插件目录监听
+        logger.info('⚡ 停止插件监听...');
+        stopWatching();
+        // 6. 关闭数据库连接
+        logger.info('⚡ 关闭数据库连接...');
+        try {
+            // 访问全局数据库实例
+            if (global.__flashclaw_db) {
+                global.__flashclaw_db.close();
+                global.__flashclaw_db = undefined;
+            }
+        }
+        catch (err) {
+            logger.warn({ err }, '关闭数据库连接时出错');
+        }
+        // 7. 卸载插件
+        logger.info('⚡ 卸载插件...');
+        await pluginManager.clear();
+        // 8. 保存状态
+        logger.info('⚡ 保存状态...');
+        saveState();
+        logger.info('⚡ FlashClaw 已安全关闭');
+        process.exit(0);
+    }
+    catch (error) {
+        logger.error({ error }, '关闭时发生错误');
+        process.exit(1);
+    }
+}
+/**
+ * 设置优雅关闭处理
+ */
+function setupGracefulShutdown() {
+    // 监听关闭信号
+    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+    // 未捕获异常处理
+    process.on('uncaughtException', (err) => {
+        logger.error({ err }, '未捕获异常');
+        gracefulShutdown('uncaughtException').catch(() => {
+            process.exit(1);
+        });
+    });
+    process.on('unhandledRejection', (reason) => {
+        logger.error({ reason }, '未处理的 Promise 拒绝');
+    });
+}
+// 直接运行时启动
+main().catch(err => {
+    logger.error({ err }, '⚡ FlashClaw 启动失败');
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map