evolclaw 2.0.7 → 2.1.1

package/dist/index.js.bak

@@ -0,0 +1,340 @@
+import { loadConfig, ensureDataDirs, resolvePaths, resolveAnthropicConfig } from './config.js';
+import { SessionManager } from './core/session-manager.js';
+import { AgentRunner } from './core/agent-runner.js';
+import { FeishuChannel } from './channels/feishu.js';
+import { AUNChannel } from './channels/aun.js';
+import { WechatChannel } from './channels/wechat.js';
+import { MessageProcessor } from './core/message-processor.js';
+import { MessageQueue } from './core/message-queue.js';
+import { MessageCache } from './core/message-cache.js';
+import { CommandHandler } from './core/command-handler.js';
+import { logger } from './utils/logger.js';
+import path from 'path';
+import fs from 'fs';
+async function main() {
+    // 过滤飞书 SDK 的 info 日志
+    const originalLog = console.log;
+    const originalInfo = console.info;
+    const filter = (...args) => {
+        const firstArg = String(args[0] || '');
+        return firstArg.includes('[info]') || firstArg.includes('[ws]');
+    };
+    console.log = (...args) => {
+        if (filter(...args))
+            return;
+        originalLog(...args);
+    };
+    console.info = (...args) => {
+        if (filter(...args))
+            return;
+        originalInfo(...args);
+    };
+    logger.info('EvolClaw starting...');
+    // 确保数据目录存在
+    ensureDataDirs();
+    // 加载配置
+    const config = loadConfig();
+    const anthropic = resolveAnthropicConfig(config);
+    logger.info('✓ Config loaded (API keys hidden)');
+    if (anthropic.baseUrl) {
+        logger.info(`✓ Using custom API base URL: ${anthropic.baseUrl}`);
+    }
+    // 初始化数据库
+    const sessionManager = new SessionManager();
+    logger.info('✓ Database initialized');
+    // 初始化 Agent Runner（带持久化回调）
+    const agentRunner = new AgentRunner(anthropic.apiKey, anthropic.model, async (sessionId, agentSessionId) => {
+        await sessionManager.updateAgentSessionIdBySessionId(sessionId, agentSessionId);
+    }, anthropic.baseUrl, config);
+    if (anthropic.effort) {
+        agentRunner.setEffort(anthropic.effort);
+    }
+    logger.info('✓ Agent runner ready');
+    // 创建消息缓存
+    const messageCache = new MessageCache();
+    logger.info('✓ Message cache initialized');
+    // 定期清理过期消息（每小时）
+    setInterval(() => {
+        messageCache.cleanupExpired();
+    }, 60 * 60 * 1000);
+    // 飞书渠道（条件初始化）
+    let feishu = null;
+    if (config.channels?.feishu?.enabled !== false && config.channels?.feishu?.appId) {
+        feishu = new FeishuChannel({
+            appId: config.channels.feishu.appId,
+            appSecret: config.channels.feishu.appSecret,
+            db: sessionManager.getDatabase()
+        });
+        // 设置项目路径提供器
+        feishu.onProjectPathRequest(async (chatId) => {
+            const session = await sessionManager.getOrCreateSession('feishu', chatId, config.projects?.defaultPath || process.cwd());
+            return path.isAbsolute(session.projectPath)
+                ? session.projectPath
+                : path.resolve(process.cwd(), session.projectPath);
+        });
+    }
+    // AUN 渠道（条件初始化）
+    let aun = null;
+    if (config.channels?.aun?.enabled !== false && config.channels?.aun?.domain) {
+        aun = new AUNChannel({ domain: config.channels.aun.domain, agentName: config.channels.aun.agentName });
+    }
+    // 创建命令处理器
+    const cmdHandler = new CommandHandler(sessionManager, agentRunner, config, messageCache);
+    // 创建消息处理器
+    const processor = new MessageProcessor(agentRunner, sessionManager, config, messageCache, (content, channel, channelId, userId, threadId) => {
+        const sendFn = async (id, text, opts) => {
+            const adapter = cmdHandler.getAdapter(channel);
+            if (!adapter)
+                return;
+            // 文件标记处理（通过 adapter.sendFile 能力判断，不按渠道名分支）
+            if (adapter.sendFile) {
+                const fileMarkerPattern = /\[SEND_FILE:([^\]]+)\]/g;
+                const fileMatches = [...text.matchAll(fileMarkerPattern)];
+                for (const match of fileMatches) {
+                    const filePath = match[1].trim();
+                    // 跳过占位符/代码片段中的伪路径
+                    if (!filePath || /[\\[\]{}*+?|^$]/.test(filePath))
+                        continue;
+                    const session = await sessionManager.getActiveSession(channel, channelId);
+                    const projectPath = session?.projectPath || process.cwd();
+                    const absoluteFilePath = path.isAbsolute(filePath) ? filePath : path.join(projectPath, filePath);
+                    try {
+                        await adapter.sendFile(id, absoluteFilePath);
+                    }
+                    catch (error) {
+                        logger.error(`[${channel}] Failed to send file: ${absoluteFilePath}`, error);
+                    }
+                }
+                text = text.replace(fileMarkerPattern, '').trim();
+            }
+            if (text) {
+                await adapter.sendText(id, text, opts);
+            }
+        };
+        return cmdHandler.handle(content, channel, channelId, sendFn, userId, threadId);
+    });
+    // 回填 processor 和 messageQueue 的引用
+    cmdHandler.setProcessor(processor);
+    // 设置 compact 开始回调
+    agentRunner.setCompactStartCallback((sessionId) => {
+        processor.handleCompactStart();
+    });
+    // 创建消息队列
+    const messageQueue = new MessageQueue(async (message) => {
+        await processor.processMessage(message);
+    });
+    // 设置中断回调
+    messageQueue.setInterruptCallback(async (sessionKey) => {
+        await agentRunner.interrupt(sessionKey);
+    });
+    // 回填 messageQueue 引用
+    cmdHandler.setMessageQueue(messageQueue);
+    // 注册 Feishu 适配器（如果已初始化）
+    if (feishu) {
+        const feishuAdapter = {
+            name: 'feishu',
+            sendText: (channelId, text, options) => feishu.sendMessage(channelId, text, options),
+            sendFile: (channelId, filePath) => feishu.sendFile(channelId, filePath),
+            isGroupChat: (channelId) => feishu.getChatMode(channelId).then(m => m === 'group'),
+        };
+        const feishuOptions = {
+            systemPromptAppend: '[重要系统功能] 你可以通过飞书发送文件给用户。方法：在响应中使用 [SEND_FILE:文件路径] 标记。示例：文件已准备好！[SEND_FILE:./report.txt] 路径支持相对路径（相对项目目录）或绝对路径。系统会自动上传并发送。',
+            fileMarkerPattern: /\[SEND_FILE:([^\]]+)\]/g,
+            supportsImages: true,
+        };
+        processor.registerChannel(feishuAdapter, feishuOptions);
+        cmdHandler.registerAdapter(feishuAdapter);
+    }
+    // 注册 AUN 适配器（如果已初始化）
+    if (aun) {
+        const aunAdapter = {
+            name: 'aun',
+            sendText: (channelId, text) => aun.sendMessage(channelId, text),
+        };
+        processor.registerChannel(aunAdapter);
+        cmdHandler.registerAdapter(aunAdapter);
+    }
+    // ── WeChat 渠道（条件初始化）──
+    let wechat = null;
+    if (config.channels?.wechat?.enabled && config.channels?.wechat?.token) {
+        wechat = new WechatChannel({
+            baseUrl: config.channels.wechat.baseUrl || 'https://ilinkai.weixin.qq.com',
+            token: config.channels.wechat.token,
+        });
+        // 设置项目路径提供器（用于接收文件保存）
+        wechat.onProjectPathRequest(async (channelId) => {
+            const session = await sessionManager.getOrCreateSession('wechat', channelId, config.projects?.defaultPath || process.cwd());
+            return path.isAbsolute(session.projectPath)
+                ? session.projectPath
+                : path.resolve(process.cwd(), session.projectPath);
+        });
+        const wechatAdapter = {
+            name: 'wechat',
+            sendText: (channelId, text) => wechat.sendMessage(channelId, text),
+            sendFile: (channelId, filePath) => wechat.sendFile(channelId, filePath),
+        };
+        const wechatOptions = {
+            systemPromptAppend: '[系统功能] 你可以发送文件给用户。方法：在响应中使用 [SEND_FILE:文件路径] 标记。示例：文件已准备好！[SEND_FILE:./report.txt]',
+            fileMarkerPattern: /\[SEND_FILE:([^\]]+)\]/g,
+        };
+        processor.registerChannel(wechatAdapter, wechatOptions);
+        cmdHandler.registerAdapter(wechatAdapter);
+        // Session 过期通知（通过 Feishu 等其他渠道告知用户）
+        wechat.onSessionExpiredNotify(async (message) => {
+            // 尝试通过已注册的 Feishu owner 通知
+            const feishuOwner = config.channels?.feishu?.owner;
+            if (feishuOwner) {
+                try {
+                    // Feishu owner ID 是 open_id，但 sendMessage 需要 chat_id
+                    // 这里只记日志，因为 owner 的 chat_id 需要从 session 中获取
+                    logger.warn(`[WeChat] ${message}`);
+                }
+                catch { }
+            }
+            else {
+                logger.warn(`[WeChat] ${message}`);
+            }
+        });
+        wechat.onMessage(async (channelId, content, userId, images) => {
+            content = content.trim();
+            // 首次交互自动绑定主人
+            if (userId && !config.channels?.wechat?.owner) {
+                const { setOwner } = await import('./config.js');
+                setOwner(config, 'wechat', userId);
+                logger.info(`[Owner] Auto-bound WeChat owner: ${userId}`);
+            }
+            // 命令快速路径
+            if (cmdHandler.isCommand(content)) {
+                const cmdResult = await cmdHandler.handle(content, 'wechat', channelId, undefined, userId);
+                if (cmdResult !== null) {
+                    if (cmdResult) {
+                        try {
+                            await wechat.sendMessage(channelId, cmdResult);
+                        }
+                        catch (error) {
+                            logger.error('[WeChat] Failed to send command response:', error);
+                        }
+                    }
+                    return;
+                }
+            }
+            // 获取当前项目路径
+            const session = await sessionManager.getOrCreateSession('wechat', channelId, config.projects?.defaultPath || process.cwd());
+            // 普通消息进入队列
+            await messageQueue.enqueue(`wechat-${channelId}`, { channel: 'wechat', channelId, content, images, timestamp: Date.now(), userId }, session.projectPath);
+        });
+    }
+    // Feishu 消息处理
+    if (feishu) {
+        feishu.onMessage(async ({ channelId: chatId, content: rawContent, images, userId, userName, messageId, mentions, threadId, rootId }) => {
+            let content = rawContent.trim();
+            // 首次交互自动绑定主人
+            if (userId && !config.channels?.feishu?.owner) {
+                const { setOwner } = await import('./config.js');
+                setOwner(config, 'feishu', userId);
+                logger.info(`[Owner] Auto-bound owner: ${userName} (${userId})`);
+            }
+            // 命令立即处理，不进入队列
+            if (cmdHandler.isCommand(content)) {
+                const cmdResult = await cmdHandler.handle(content, 'feishu', chatId, undefined, userId, threadId);
+                if (cmdResult !== null) {
+                    if (cmdResult) {
+                        try {
+                            await feishu.sendMessage(chatId, cmdResult, { forceText: true, replyToMessageId: rootId, replyInThread: true });
+                        }
+                        catch (error) {
+                            logger.error('[Feishu] Failed to send command response:', error);
+                        }
+                    }
+                    return;
+                }
+            }
+            // 获取当前项目路径（话题会话自动创建，携带 metadata）
+            const metadata = rootId ? { feishu: { rootId } } : undefined;
+            const session = await sessionManager.getOrCreateSession('feishu', chatId, config.projects?.defaultPath || process.cwd(), threadId, metadata);
+            // 群聊消息添加用户名前缀
+            const chatMode = await feishu.getChatMode(chatId);
+            if (chatMode === 'group' && userName) {
+                content = `[${userName}] ${content}`;
+            }
+            // 普通消息进入队列（使用 session.id 作为 key，话题间可并行）
+            await messageQueue.enqueue(session.id, { channel: 'feishu', channelId: chatId, content, images, timestamp: Date.now(), userId, userName, messageId, isGroup: chatMode === 'group', mentions, threadId }, session.projectPath);
+        });
+    }
+    // AUN 消息处理
+    if (aun) {
+        aun.onMessage(async (sessionId, content) => {
+            content = content.trim();
+            // 首次交互自动绑定主人
+            if (!config.channels?.aun?.owner) {
+                const { setOwner } = await import('./config.js');
+                setOwner(config, 'aun', sessionId);
+                logger.info(`[Owner] Auto-bound AUN owner: ${sessionId}`);
+            }
+            // 命令立即处理，不进入队列
+            if (cmdHandler.isCommand(content)) {
+                const cmdResult = await cmdHandler.handle(content, 'aun', sessionId, undefined, sessionId);
+                if (cmdResult) {
+                    await aun.sendMessage(sessionId, cmdResult);
+                    return;
+                }
+            }
+            // 获取当前项目路径
+            const session = await sessionManager.getOrCreateSession('aun', sessionId, config.projects?.defaultPath || process.cwd());
+            // 普通消息进入队列
+            await messageQueue.enqueue(`aun-${sessionId}`, { channel: 'aun', channelId: sessionId, content, timestamp: Date.now(), userId: sessionId }, session.projectPath);
+        });
+    }
+    // 连接渠道
+    const channels = [];
+    const channelInstances = [
+        ...(feishu ? [{ name: 'Feishu', instance: feishu, timeout: 5000 }] : []),
+        ...(aun ? [{ name: 'AUN', instance: aun }] : []),
+        ...(wechat ? [{ name: 'WeChat', instance: wechat }] : []),
+    ];
+    for (const { name, instance, timeout } of channelInstances) {
+        try {
+            if (timeout) {
+                await Promise.race([
+                    instance.connect(),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('Connection timeout')), timeout))
+                ]);
+            }
+            else {
+                await instance.connect();
+            }
+            logger.info(`✓ ${name} connected`);
+            channels.push(name);
+        }
+        catch (error) {
+            logger.warn(`⚠ ${name} connection failed (will continue without it)`);
+            if (error instanceof Error) {
+                logger.warn(`  Reason: ${error.message}`);
+            }
+        }
+    }
+    logger.info(`\n🚀 EvolClaw is running with ${channels.length} channel(s): ${channels.join(', ')}\n`);
+    // 写入 ready 信号，供 restart-monitor 检测启动成功
+    const readySignalPath = resolvePaths().readySignal;
+    fs.writeFileSync(readySignalPath, String(Date.now()));
+    logger.info(`✓ Ready signal written: ${readySignalPath}`);
+    // 优雅关闭
+    const shutdown = async () => {
+        logger.info('\n\nShutting down gracefully...');
+        if (feishu)
+            await feishu.disconnect();
+        if (aun)
+            await aun.disconnect();
+        if (wechat)
+            await wechat.disconnect();
+        sessionManager.close();
+        logger.info('✓ Shutdown complete');
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+main().catch((error) => {
+    logger.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/utils/session-file-health.js

@@ -16,9 +16,9 @@ async function fileExists(filePath) {
 /**
  * 检查会话文件健康度
  */
-export async function checkSessionFileHealth(projectPath, claudeSessionId) {
+export async function checkSessionFileHealth(projectPath, agentSessionId) {
     const issues = [];
-    const sessionFile = path.join(projectPath, '.claude', `${claudeSessionId}.jsonl`);
+    const sessionFile = path.join(projectPath, '.claude', `${agentSessionId}.jsonl`);
     // 检查文件是否存在
     if (!(await fileExists(sessionFile))) {
         // 新会话没有文件是正常的
@@ -60,7 +60,8 @@ export async function checkSessionFileHealth(projectPath, claudeSessionId) {
  */
 export async function backupClaudeDir(projectPath) {
     const claudeDir = path.join(projectPath, '.claude');
-    const backupDir = path.join(claudeDir, `backup-${Date.now()}`);
+    const dirName = path.basename(claudeDir);
+    const backupDir = path.join(path.dirname(claudeDir), `${dirName}-backup-${Date.now()}`);
     await fs.cp(claudeDir, backupDir, { recursive: true });
     logger.info(`[SessionFileHealth] Backup created: ${backupDir}`);
     return backupDir;

package/dist/utils/stream-flusher.js

@@ -1,4 +1,19 @@
-import { logger } from './logger.js';
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../paths.js';
+// 诊断日志（按需启用，通过 config.debug.flusherDiag 控制）
+let diagStream = null;
+function getDiagStream() {
+    if (!diagStream) {
+        const logDir = resolvePaths().logs;
+        diagStream = fs.createWriteStream(path.join(logDir, 'flusher-diag.log'), { flags: 'a' });
+    }
+    return diagStream;
+}
+function diag(instanceId, action, meta = {}) {
+    const line = JSON.stringify({ ts: new Date().toISOString(), id: instanceId, action, ...meta });
+    getDiagStream().write(line + '\n');
+}
 /**
  * 流式输出缓冲器
  * 按时间窗口批量推送文本和活动事件
@@ -12,6 +27,7 @@ import { logger } from './logger.js';
  *   - 下限：interval（额定值）
  *   - 上限：interval * 2.5
  */
+let instanceCounter = 0;
 export class StreamFlusher {
     send;
     interval;
@@ -24,19 +40,27 @@ export class StreamFlusher {
     fileMarkerPattern;
     flushCount = 0;
     messageTimestamps = [];
-    constructor(send, interval = 4000, fileMarkerPattern) {
+    instanceId;
+    createTime = Date.now();
+    diagEnabled;
+    constructor(send, interval = 4000, fileMarkerPattern, diagEnabled = false) {
         this.send = send;
         this.interval = interval;
         this.fileMarkerPattern = fileMarkerPattern;
+        this.diagEnabled = diagEnabled;
+        this.instanceId = `F${++instanceCounter}`;
+        if (this.diagEnabled)
+            diag(this.instanceId, 'created', { interval });
     }
     addText(text) {
         this.buffer += text;
         this.allText += text;
         this.messageTimestamps.push(Date.now());
+        if (this.diagEnabled)
+            diag(this.instanceId, 'addText', { len: text.length, preview: text.substring(0, 60), bufLen: this.buffer.length, actCount: this.activities.length });
         this.scheduleFlush();
     }
     addTextBlock(text) {
-        // 用于 assistant 事件的完整文本块，需要换行分隔
         if (this.buffer && !this.buffer.endsWith('\n')) {
             this.buffer += '\n\n';
             this.allText += '\n\n';
@@ -44,79 +68,69 @@ export class StreamFlusher {
         this.buffer += text;
         this.allText += text;
         this.messageTimestamps.push(Date.now());
+        if (this.diagEnabled)
+            diag(this.instanceId, 'addTextBlock', { len: text.length, preview: text.substring(0, 60), bufLen: this.buffer.length });
         this.scheduleFlush();
     }
     addActivity(desc) {
         this.activities.push(desc);
         this.messageTimestamps.push(Date.now());
+        if (this.diagEnabled)
+            diag(this.instanceId, 'addActivity', { desc: desc.substring(0, 80), actCount: this.activities.length });
         this.scheduleFlush();
     }
-    /** 当前 buffer 中是否有待发送内容 */
     hasContent() {
         return this.buffer.length > 0 || this.activities.length > 0;
     }
-    /** 是否曾经发送过任何内容 */
     hasSentContent() {
         return this.sentContent;
     }
-    /** 获取完整累积文本（用于文件标记提取） */
     getFinalText() {
         return this.allText;
     }
-    /** 获取当前未发送的剩余文本 */
     getRemainingText() {
         return this.buffer;
     }
-    /** 从当前 buffer 中移除匹配的模式 */
     stripFromBuffer(pattern) {
         this.buffer = this.buffer.replace(pattern, '').trim();
     }
     scheduleFlush() {
-        if (this.timer)
+        if (this.timer) {
+            if (this.diagEnabled)
+                diag(this.instanceId, 'scheduleFlush:skip', { reason: 'timer_exists' });
             return;
-        // 计算目标延迟
+        }
         let targetDelay;
         if (this.flushCount === 0) {
-            // 第1次：立即发送
             targetDelay = 0;
         }
         else if (this.flushCount <= 3) {
-            // 第2-4次：半延迟
             targetDelay = Math.ceil(this.interval / 2);
         }
         else if (this.messageTimestamps.length >= 5) {
-            // 第5次起：动态自适应
             targetDelay = this.calculateDynamicDelay();
         }
         else {
-            // 样本不足，使用额定延迟
             targetDelay = this.interval;
         }
         const elapsed = Date.now() - this.lastFlush;
         const delay = Math.max(0, targetDelay - elapsed);
+        if (this.diagEnabled)
+            diag(this.instanceId, 'scheduleFlush:set', { flushCount: this.flushCount, targetDelay, elapsed, actualDelay: delay });
         this.timer = setTimeout(() => this.flush(), delay);
     }
-    /**
-     * 计算动态延迟
-     * 基于最近10条消息的平均间隔
-     */
     calculateDynamicDelay() {
-        // 取最近10条（或实际条数）
         const recent = this.messageTimestamps.slice(-10);
-        // 计算平均间隔
         const intervals = [];
         for (let i = 1; i < recent.length; i++) {
             intervals.push(recent[i] - recent[i - 1]);
         }
-        if (intervals.length === 0) {
+        if (intervals.length === 0)
             return this.interval;
-        }
         const avgInterval = intervals.reduce((a, b) => a + b) / intervals.length;
-        // 动态延迟 = 平均间隔 * 3
         let dynamicDelay = avgInterval * 3;
-        // 边界限制
-        const minDelay = this.interval; // 下限：额定值
-        const maxDelay = this.interval * 2.5; // 上限：额定值 * 2.5
+        const minDelay = this.interval;
+        const maxDelay = this.interval * 2.5;
         return Math.max(minDelay, Math.min(maxDelay, dynamicDelay));
     }
     async flush(isFinal) {
@@ -133,15 +147,11 @@ export class StreamFlusher {
             output += this.buffer;
             this.buffer = '';
         }
-        // 移除文件标记（如果配置了）
         if (output && this.fileMarkerPattern) {
-            const before = output;
             output = output.replace(this.fileMarkerPattern, '').trim();
-            if (before !== output) {
-                logger.debug('[StreamFlusher] Removed file markers, before length:', before.length, 'after:', output.length);
-            }
         }
-        logger.debug('[StreamFlusher] flush called, output length:', output.length, 'isEmpty:', !output, 'preview:', output.substring(0, 100));
+        if (this.diagEnabled)
+            diag(this.instanceId, 'flush', { isFinal, outputLen: output.length, flushCount: this.flushCount, sinceLastFlush: Date.now() - this.lastFlush, preview: output.substring(0, 80) });
         if (output) {
             await this.send(output, isFinal);
             this.sentContent = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evolclaw",
-  "version": "2.0.7",
+  "version": "2.1.1",
   "description": "Lightweight AI Agent gateway connecting Claude Agent SDK to messaging channels (Feishu, ACP) with multi-project session management",
   "type": "module",
   "main": "dist/index.js",