evolclaw 2.0.0

package/dist/index.js

@@ -0,0 +1,239 @@
+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 { 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, claudeSessionId) => {
+        await sessionManager.updateClaudeSessionIdBySessionId(sessionId, claudeSessionId);
+    }, anthropic.baseUrl, config);
+    logger.info('✓ Agent runner ready');
+    // 创建消息缓存
+    const messageCache = new MessageCache();
+    logger.info('✓ Message cache initialized');
+    // 定期清理过期消息（每小时）
+    setInterval(() => {
+        messageCache.cleanupExpired();
+    }, 60 * 60 * 1000);
+    // 飞书渠道
+    const feishu = new FeishuChannel({
+        appId: config.feishu.appId,
+        appSecret: config.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 渠道
+    const aun = new AUNChannel({ domain: config.aun.domain, agentName: config.aun.agentName });
+    // 创建命令处理器
+    const cmdHandler = new CommandHandler(sessionManager, agentRunner, config, messageCache);
+    // 创建消息处理器
+    const processor = new MessageProcessor(agentRunner, sessionManager, config, messageCache, (content, channel, channelId, userId) => {
+        const sendFn = async (id, text) => {
+            const fileMarkerPattern = /\[SEND_FILE:([^\]]+)\]/g;
+            if (channel === 'feishu') {
+                const fileMatches = [...text.matchAll(fileMarkerPattern)];
+                for (const match of fileMatches) {
+                    const filePath = match[1].trim();
+                    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 feishu.sendFile(id, absoluteFilePath);
+                    }
+                    catch (error) {
+                        logger.error(`[Feishu] Failed to send file: ${absoluteFilePath}`, error);
+                    }
+                }
+                text = text.replace(fileMarkerPattern, '').trim();
+            }
+            if (text) {
+                if (channel === 'feishu')
+                    await feishu.sendMessage(id, text);
+                else if (channel === 'aun')
+                    await aun.sendMessage(id, text);
+            }
+        };
+        return cmdHandler.handle(content, channel, channelId, sendFn, userId);
+    });
+    // 回填 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 适配器
+    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:/path/to/file.txt] 系统会自动上传并发送。',
+        fileMarkerPattern: /\[SEND_FILE:([^\]]+)\]/g,
+        supportsImages: true,
+    };
+    processor.registerChannel(feishuAdapter, feishuOptions);
+    cmdHandler.registerAdapter(feishuAdapter);
+    // 注册 AUN 适配器
+    const aunAdapter = {
+        name: 'aun',
+        sendText: (channelId, text) => aun.sendMessage(channelId, text),
+    };
+    processor.registerChannel(aunAdapter);
+    cmdHandler.registerAdapter(aunAdapter);
+    // Feishu 消息处理
+    feishu.onMessage(async (chatId, content, images, userId, userName, messageId) => {
+        content = content.trim();
+        // 首次交互自动绑定主人
+        if (userId && !config.owners?.feishu) {
+            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);
+            if (cmdResult !== null) {
+                if (cmdResult) {
+                    try {
+                        await feishu.sendMessage(chatId, cmdResult, { forceText: true });
+                    }
+                    catch (error) {
+                        logger.error('[Feishu] Failed to send command response:', error);
+                    }
+                }
+                return;
+            }
+        }
+        // 获取当前项目路径
+        const session = await sessionManager.getOrCreateSession('feishu', chatId, config.projects?.defaultPath || process.cwd());
+        // 群聊消息添加用户名前缀
+        const chatMode = await feishu.getChatMode(chatId);
+        if (chatMode === 'group' && userName) {
+            content = `[${userName}] ${content}`;
+        }
+        // 普通消息进入队列
+        await messageQueue.enqueue(`feishu-${chatId}`, { channel: 'feishu', channelId: chatId, content, images, timestamp: Date.now(), userId, userName, messageId, isGroup: chatMode === 'group' }, session.projectPath);
+    });
+    // AUN 消息处理
+    aun.onMessage(async (sessionId, content) => {
+        content = content.trim();
+        // 首次交互自动绑定主人
+        if (!config.owners?.aun) {
+            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 = [];
+    try {
+        await feishu.connect();
+        logger.info('✓ Feishu connected');
+        channels.push('Feishu');
+    }
+    catch (error) {
+        logger.warn('⚠ Feishu connection failed (will continue without it)');
+        if (error instanceof Error) {
+            logger.warn(`  Reason: ${error.message}`);
+        }
+    }
+    try {
+        await aun.connect();
+        logger.info('✓ AUN connected');
+        channels.push('AUN');
+    }
+    catch (error) {
+        logger.warn('⚠ AUN 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...');
+        await feishu.disconnect();
+        await aun.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/paths.js

@@ -0,0 +1,45 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+let _root = null;
+export function resolveRoot() {
+    if (_root)
+        return _root;
+    if (process.env.EVOLCLAW_HOME) {
+        _root = process.env.EVOLCLAW_HOME;
+    }
+    else if (fs.existsSync(path.join(process.cwd(), 'data', 'evolclaw.json'))) {
+        _root = process.cwd();
+    }
+    else {
+        _root = path.join(os.homedir(), '.evolclaw');
+    }
+    return _root;
+}
+/** 重置缓存（仅供测试使用） */
+export function _resetRoot() {
+    _root = null;
+}
+export function resolvePaths() {
+    const root = resolveRoot();
+    return {
+        root,
+        config: path.join(root, 'data', 'evolclaw.json'),
+        configSample: path.join(root, 'data', 'evolclaw.sample.json'),
+        db: path.join(root, 'data', 'sessions.db'),
+        pid: path.join(root, 'logs', 'evolclaw.pid'),
+        dataDir: path.join(root, 'data'),
+        logs: path.join(root, 'logs'),
+        lineStats: path.join(root, 'logs', 'line-stats.log'),
+        readySignal: path.join(root, 'logs', 'ready.signal'),
+        selfHealLog: path.join(root, 'logs', 'self-heal.md'),
+    };
+}
+export function ensureDataDirs() {
+    const p = resolvePaths();
+    fs.mkdirSync(p.dataDir, { recursive: true });
+    fs.mkdirSync(p.logs, { recursive: true });
+}
+export function getPackageRoot() {
+    return path.resolve(new URL('.', import.meta.url).pathname, '..');
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/error-utils.js

@@ -0,0 +1,54 @@
+export var ErrorType;
+(function (ErrorType) {
+    ErrorType["SDK_TIMEOUT"] = "sdk_timeout";
+    ErrorType["API_ERROR"] = "api_error";
+    ErrorType["FILE_CORRUPT"] = "file_corrupt";
+    ErrorType["STREAM_ERROR"] = "stream_error";
+    ErrorType["CONTEXT_TOO_LONG"] = "context_too_long";
+    ErrorType["UNKNOWN"] = "unknown";
+})(ErrorType || (ErrorType = {}));
+export function classifyError(error) {
+    const msg = (error?.message || '').toLowerCase();
+    if (msg.includes('上下文过长') || msg.includes('context too long')
+        || msg.includes('context_length_exceeded') || msg.includes('context_compact_failed')) {
+        return ErrorType.CONTEXT_TOO_LONG;
+    }
+    if (msg.includes('timeout') || msg.includes('etimedout')) {
+        return ErrorType.SDK_TIMEOUT;
+    }
+    if (msg.includes('5') && (msg.includes('00') || msg.includes('02') || msg.includes('03') || msg.includes('04'))) {
+        return ErrorType.API_ERROR;
+    }
+    if (msg.includes('enoent') || msg.includes('corrupt') || msg.includes('invalid json')) {
+        return ErrorType.FILE_CORRUPT;
+    }
+    if (msg.includes('stream') || msg.includes('aborted') || msg.includes('interrupted')) {
+        return ErrorType.STREAM_ERROR;
+    }
+    return ErrorType.UNKNOWN;
+}
+export function getErrorMessage(error) {
+    const msg = error?.message || String(error);
+    if (msg.includes('CONTEXT_COMPACT_FAILED')) {
+        return '⚠️ 上下文过长，自动压缩失败，请手动输入 /compact 重试';
+    }
+    if (msg.includes('上下文过长') || msg.includes('context too long') || msg.includes('context_length_exceeded')) {
+        return '⚠️ 上下文过长，自动压缩重试失败，请手动输入 /compact 重试';
+    }
+    if (msg.includes('API Error: 400')) {
+        return '⚠️ 请求格式错误，请检查输入内容';
+    }
+    if (msg.includes('API Error: 500')) {
+        return '⚠️ API 服务暂时不可用，请稍后重试';
+    }
+    if (msg.includes('API Error: 429')) {
+        return '⚠️ 请求过于频繁，请稍后再试';
+    }
+    if (msg.includes('timeout')) {
+        return '⚠️ 请求超时，请重试';
+    }
+    if (msg.includes('permission') || msg.includes('im:resource')) {
+        return '⚠️ 权限不足，请联系管理员配置应用权限';
+    }
+    return '⚠️ 处理消息时出错，请稍后重试';
+}