evolclaw 2.0.1 → 2.0.3

package/dist/cli.js

@@ -4,6 +4,8 @@ import { spawn, execFileSync, execFile } from 'child_process';
 import { promisify } from 'util';
 import { resolveRoot, resolvePaths, ensureDataDirs, getPackageRoot } from './paths.js';
 import { cmdInit } from './utils/init.js';
+import { cmdInitWechat } from './utils/init-wechat.js';
+import { cmdInitFeishu } from './utils/init-feishu.js';
 const execFileAsync = promisify(execFile);
 // 清理 Claude Code 环境变量，防止 SDK 认为是嵌套会话
 function cleanEnv() {
@@ -28,47 +30,29 @@ function isRunning(pidFile) {
         return null;
     }
 }
-function killAllInstances() {
-    try {
-        const output = execFileSync('pgrep', ['-f', 'node.*dist/index.js'], { encoding: 'utf-8' }).trim();
-        if (output) {
-            const pids = output.split('\n');
-            console.log(`  Found ${pids.length} running instance(s), stopping them...`);
-            for (const pid of pids) {
-                try {
-                    process.kill(parseInt(pid, 10));
-                }
-                catch { }
-            }
-        }
-    }
-    catch { }
-}
 function rotateLogs(logDir) {
     if (!fs.existsSync(logDir))
         return;
     const MAX_SIZE = 10 * 1024 * 1024; // 10MB
-    for (const file of fs.readdirSync(logDir)) {
-        if (!file.endsWith('.log'))
-            continue;
-        const filePath = path.join(logDir, file);
-        const stat = fs.statSync(filePath);
-        if (stat.size > MAX_SIZE) {
-            const timestamp = new Date().toISOString().replace(/[:.]/g, '').slice(0, 15);
-            const newPath = `${filePath}.${timestamp}`;
-            fs.renameSync(filePath, newPath);
-            console.log(`  Rotated: ${file} -> ${path.basename(newPath)}`);
-        }
-    }
-    // 清理 7 天前的旧日志
     const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
     for (const file of fs.readdirSync(logDir)) {
-        if (!file.includes('.log.'))
-            continue;
         const filePath = path.join(logDir, file);
-        const stat = fs.statSync(filePath);
-        if (stat.mtimeMs < cutoff) {
-            fs.unlinkSync(filePath);
+        if (file.endsWith('.log')) {
+            // 轮转超大日志
+            const stat = fs.statSync(filePath);
+            if (stat.size > MAX_SIZE) {
+                const timestamp = new Date().toISOString().replace(/[:.]/g, '').slice(0, 15);
+                const newPath = `${filePath}.${timestamp}`;
+                fs.renameSync(filePath, newPath);
+                console.log(`  Rotated: ${file} -> ${path.basename(newPath)}`);
+            }
+        }
+        else if (file.includes('.log.')) {
+            // 清理 7 天前的旧日志
+            const stat = fs.statSync(filePath);
+            if (stat.mtimeMs < cutoff) {
+                fs.unlinkSync(filePath);
+            }
         }
     }
 }
@@ -268,72 +252,61 @@ function cmdStart() {
     };
     setTimeout(checkReady, 1000);
 }
-function cmdStop() {
-    const p = resolvePaths();
-    const pid = isRunning(p.pid);
-    if (!pid) {
-        console.log('⚠ EvolClaw is not running');
+/**
+ * 停止进程并等待退出，返回 Promise
+ */
+async function stopAndWait(pidFile) {
+    const pid = isRunning(pidFile);
+    if (!pid)
         return;
-    }
     console.log(`🛑 Stopping EvolClaw (PID: ${pid})...`);
     process.kill(pid);
-    let waited = 0;
-    const check = setInterval(() => {
-        waited++;
-        try {
-            process.kill(pid, 0);
-        }
-        catch {
-            clearInterval(check);
-            try {
-                fs.unlinkSync(p.pid);
-            }
-            catch { }
-            console.log('✓ EvolClaw stopped');
-            return;
-        }
-        if (waited >= 10) {
-            clearInterval(check);
-            try {
-                process.kill(pid, 9);
-            }
-            catch { }
-            try {
-                fs.unlinkSync(p.pid);
-            }
-            catch { }
-            console.log('✓ EvolClaw stopped (forced)');
-        }
-    }, 1000);
-}
-function cmdRestart() {
-    console.log('🔄 Restarting EvolClaw...');
-    const p = resolvePaths();
-    const pid = isRunning(p.pid);
-    if (pid) {
-        process.kill(pid);
+    await new Promise((resolve) => {
         let waited = 0;
-        while (waited < 10) {
+        const check = setInterval(() => {
+            waited++;
             try {
                 process.kill(pid, 0);
-                execFileSync('sleep', ['1']);
-                waited++;
             }
             catch {
-                break;
+                clearInterval(check);
+                try {
+                    fs.unlinkSync(pidFile);
+                }
+                catch { }
+                console.log('✓ EvolClaw stopped');
+                resolve();
+                return;
             }
-        }
-        if (waited >= 10) {
-            try {
-                process.kill(pid, 9);
+            if (waited >= 10) {
+                clearInterval(check);
+                try {
+                    process.kill(pid, 9);
+                }
+                catch { }
+                try {
+                    fs.unlinkSync(pidFile);
+                }
+                catch { }
+                console.log('✓ EvolClaw stopped (forced)');
+                resolve();
             }
-            catch { }
-        }
-        try {
-            fs.unlinkSync(p.pid);
-        }
-        catch { }
+        }, 1000);
+    });
+}
+async function cmdStop() {
+    const p = resolvePaths();
+    const pid = isRunning(p.pid);
+    if (!pid) {
+        console.log('⚠ EvolClaw is not running');
+        return;
     }
+    await stopAndWait(p.pid);
+}
+async function cmdRestart() {
+    console.log('🔄 Restarting EvolClaw...');
+    const p = resolvePaths();
+    await stopAndWait(p.pid);
     setTimeout(() => cmdStart(), 1000);
 }
 async function cmdStatus() {
@@ -368,58 +341,71 @@ async function cmdStatus() {
                 'SELECT count(*) FROM sessions; SELECT count(*) FROM sessions WHERE is_active=1; SELECT count(DISTINCT channel_id) FROM sessions; SELECT count(DISTINCT project_path) FROM sessions;'
             ], { encoding: 'utf-8' }).trim().split('\n');
             if (output.length >= 4) {
-                console.log(`  会话总数: ${output[0]} (活跃: ${output[1]})`);
-                console.log(`  独立会话: ${output[2]} 个`);
-                console.log(`  涉及项目: ${output[3]} 个`);
+                console.log(`  Total sessions: ${output[0]} (active: ${output[1]})`);
+                console.log(`  Unique chats: ${output[2]}`);
+                console.log(`  Projects: ${output[3]}`);
             }
         }
         catch { }
     }
-    // 渠道配置状态
+    // Channel configuration status
     if (fs.existsSync(p.config)) {
         console.log('');
-        console.log('🔌 渠道配置:');
+        console.log('🔌 Channels:');
         try {
             const config = JSON.parse(fs.readFileSync(p.config, 'utf-8'));
-            if (config.feishu?.appId && config.feishu?.appSecret) {
-                // 验证飞书凭证连通性
+            if (config.channels?.feishu?.appId && config.channels?.feishu?.appSecret) {
+                // Verify Feishu credentials connectivity
                 try {
                     const lark = await import('@larksuiteoapi/node-sdk');
-                    const client = new lark.Client({ appId: config.feishu.appId, appSecret: config.feishu.appSecret });
+                    const client = new lark.Client({ appId: config.channels.feishu.appId, appSecret: config.channels.feishu.appSecret });
                     const res = await client.auth.tenantAccessToken.internal({
-                        data: { app_id: config.feishu.appId, app_secret: config.feishu.appSecret },
+                        data: { app_id: config.channels.feishu.appId, app_secret: config.channels.feishu.appSecret },
                     });
                     if (res.code === 0) {
-                        console.log(`  飞书: ✓ 已连接 (App ID: ${config.feishu.appId.slice(0, 8)}...)`);
+                        console.log(`  Feishu: ✓ Connected (App ID: ${config.channels.feishu.appId.slice(0, 8)}...)`);
                     }
                     else {
-                        console.log(`  飞书: ✗ 连接拒绝 (${res.msg})`);
+                        console.log(`  Feishu: ✗ Connection refused (${res.msg})`);
                     }
                 }
                 catch (e) {
                     const msg = e.message || '';
                     if (msg.includes('ETIMEDOUT') || msg.includes('ENETUNREACH') || msg.includes('ENOTFOUND')) {
-                        console.log('  飞书: ✗ 连接超时（网络不可达）');
+                        console.log('  Feishu: ✗ Connection timeout (network unreachable)');
                     }
                     else {
-                        console.log(`  飞书: ✗ 连接失败 (${msg.slice(0, 80)})`);
+                        console.log(`  Feishu: ✗ Connection failed (${msg.slice(0, 80)})`);
                     }
                 }
             }
             else {
-                console.log('  飞书: - 未配置');
+                console.log('  Feishu: - Not configured');
+            }
+            if (config.channels?.wechat?.token) {
+                const tokenPreview = config.channels.wechat.token.slice(0, 20);
+                console.log(`  WeChat: ✓ Configured (Token: ${tokenPreview}...)`);
+            }
+            else {
+                console.log('  WeChat: - Not configured');
             }
-            if (config.aun?.domain && config.aun?.agentName) {
-                console.log(`  AUN: ✓ 已配置 (${config.aun.agentName}@${config.aun.domain})`);
+            // Check AUN with placeholder detection
+            const aunDomain = config.channels?.aun?.domain;
+            const aunAgent = config.channels?.aun?.agentName;
+            const isAunPlaceholder = !aunDomain || !aunAgent ||
+                aunDomain.includes('your-') || aunDomain.includes('placeholder') ||
+                aunAgent.includes('your-') || aunAgent.includes('placeholder');
+            if (aunDomain && aunAgent && !isAunPlaceholder) {
+                console.log(`  AUN: ✓ Configured (${aunAgent}@${aunDomain})`);
             }
             else {
-                console.log('  AUN: - 未配置');
+                console.log('  AUN: - Not configured');
             }
-            if (config.anthropic?.model) {
-                console.log(`  模型: ${config.anthropic.model}`);
+            if (config.agents?.anthropic?.model) {
+                console.log(`  Model: ${config.agents.anthropic.model}`);
             }
             if (config.projects?.defaultPath) {
-                console.log(`  默认项目: ${config.projects.defaultPath}`);
+                console.log(`  Default project: ${config.projects.defaultPath}`);
             }
         }
         catch { }
@@ -508,16 +494,16 @@ async function cmdRestartMonitor() {
     if (started) {
         log('✓ Service restarted successfully');
         archiveSelfHealLog(p, log);
-        await notifyFeishu(p, pendingInfo, '✅ 服务重启成功！', log);
+        await notifyChannel(p, pendingInfo, '✅ 服务重启成功！', log);
         cleanupPendingFile(pendingFile, log);
         process.exit(0);
     }
     // 启动失败，进入 self-heal 循环
     log('❌ Service failed to start, entering self-heal loop');
-    await notifyFeishu(p, pendingInfo, '⚠️ 服务启动失败，正在尝试自动修复...', log);
+    await notifyChannel(p, pendingInfo, '⚠️ 服务启动失败，正在尝试自动修复...', log);
     for (let attempt = 1; attempt <= MAX_HEAL_ATTEMPTS; attempt++) {
         log(`Self-heal attempt ${attempt}/${MAX_HEAL_ATTEMPTS}`);
-        await notifyFeishu(p, pendingInfo, `🔧 自动修复中（第 ${attempt}/${MAX_HEAL_ATTEMPTS} 次）...`, log);
+        await notifyChannel(p, pendingInfo, `🔧 自动修复中（第 ${attempt}/${MAX_HEAL_ATTEMPTS} 次）...`, log);
         // 调用 claude CLI 修复
         const healed = await invokeClaude(p, attempt, MAX_HEAL_ATTEMPTS, log);
         if (!healed) {
@@ -529,7 +515,7 @@ async function cmdRestartMonitor() {
         if (started) {
             log(`✓ Self-heal succeeded on attempt ${attempt}`);
             archiveSelfHealLog(p, log);
-            await notifyFeishu(p, pendingInfo, `✅ 自愈成功！（第 ${attempt} 次修复后恢复）`, log);
+            await notifyChannel(p, pendingInfo, `✅ 自愈成功！（第 ${attempt} 次修复后恢复）`, log);
             cleanupPendingFile(pendingFile, log);
             process.exit(0);
         }
@@ -537,7 +523,7 @@ async function cmdRestartMonitor() {
     }
     // 全部失败
     log(`❌ All ${MAX_HEAL_ATTEMPTS} self-heal attempts failed`);
-    await notifyFeishu(p, pendingInfo, `❌ ${MAX_HEAL_ATTEMPTS} 次自动修复均失败，需要人工介入。\n修复记录：${p.selfHealLog}`, log);
+    await notifyChannel(p, pendingInfo, `❌ ${MAX_HEAL_ATTEMPTS} 次自动修复均失败，需要人工介入。\n修复记录：${p.selfHealLog}`, log);
     cleanupPendingFile(pendingFile, log);
     process.exit(1);
 }
@@ -678,35 +664,95 @@ function archiveSelfHealLog(p, log) {
     log(`Archived self-heal log to ${archivePath}`);
 }
 /**
- * 通过 Feishu API 发送通知（轻量级，不依赖 FeishuChannel）
+ * 通过对应渠道 API 发送通知（轻量级，不依赖 Channel 实例）
+ * 支持 feishu / wechat，根据 pendingInfo.channel 路由
  */
-async function notifyFeishu(p, pendingInfo, message, log) {
-    if (!pendingInfo || pendingInfo.channel !== 'feishu')
+async function notifyChannel(p, pendingInfo, message, log) {
+    if (!pendingInfo)
         return;
-    try {
-        const configPath = path.join(p.dataDir, 'evolclaw.json');
-        if (!fs.existsSync(configPath))
-            return;
-        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-        if (!config.feishu?.appId || !config.feishu?.appSecret)
-            return;
-        const lark = await import('@larksuiteoapi/node-sdk');
-        const client = new lark.Client({
-            appId: config.feishu.appId,
-            appSecret: config.feishu.appSecret,
-        });
-        await client.im.message.create({
-            params: { receive_id_type: 'chat_id' },
-            data: {
-                receive_id: pendingInfo.channelId,
-                msg_type: 'text',
-                content: JSON.stringify({ text: message }),
-            },
-        });
-        log(`Feishu notification sent: ${message.slice(0, 50)}`);
+    const configPath = path.join(p.dataDir, 'evolclaw.json');
+    if (!fs.existsSync(configPath))
+        return;
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    if (pendingInfo.channel === 'feishu') {
+        try {
+            if (!config.channels?.feishu?.appId || !config.channels?.feishu?.appSecret)
+                return;
+            const lark = await import('@larksuiteoapi/node-sdk');
+            const client = new lark.Client({
+                appId: config.channels.feishu.appId,
+                appSecret: config.channels.feishu.appSecret,
+            });
+            await client.im.message.create({
+                params: { receive_id_type: 'chat_id' },
+                data: {
+                    receive_id: pendingInfo.channelId,
+                    msg_type: 'text',
+                    content: JSON.stringify({ text: message }),
+                },
+            });
+            log(`Feishu notification sent: ${message.slice(0, 50)}`);
+        }
+        catch (error) {
+            log(`Feishu notification failed: ${error.message?.slice(0, 200) || error}`);
+        }
     }
-    catch (error) {
-        log(`Feishu notification failed: ${error.message?.slice(0, 200) || error}`);
+    else if (pendingInfo.channel === 'wechat') {
+        try {
+            if (!config.channels?.wechat?.token)
+                return;
+            const crypto = await import('node:crypto');
+            const baseUrl = (config.channels.wechat.baseUrl || 'https://ilinkai.weixin.qq.com').replace(/\/$/, '');
+            const token = config.channels.wechat.token;
+            // 读取缓存的 context_token
+            const syncBufPath = path.join(p.dataDir, 'wechat-context-tokens.json');
+            let contextToken;
+            try {
+                if (fs.existsSync(syncBufPath)) {
+                    const tokens = JSON.parse(fs.readFileSync(syncBufPath, 'utf-8'));
+                    contextToken = tokens[pendingInfo.channelId];
+                }
+            }
+            catch { }
+            if (!contextToken) {
+                log(`WeChat notification skipped: no context_token for ${pendingInfo.channelId}`);
+                return;
+            }
+            const uint32 = crypto.randomBytes(4).readUInt32BE(0);
+            const wechatUin = Buffer.from(String(uint32), 'utf-8').toString('base64');
+            const body = JSON.stringify({
+                msg: {
+                    from_user_id: '',
+                    to_user_id: pendingInfo.channelId,
+                    client_id: `evolclaw-restart:${Date.now()}`,
+                    message_type: 2,
+                    message_state: 2,
+                    item_list: [{ type: 1, text_item: { text: message } }],
+                    context_token: contextToken,
+                },
+                base_info: { channel_version: '1.0.0' },
+            });
+            const res = await fetch(`${baseUrl}/ilink/bot/sendmessage`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'AuthorizationType': 'ilink_bot_token',
+                    'Authorization': `Bearer ${token.trim()}`,
+                    'X-WECHAT-UIN': wechatUin,
+                    'Content-Length': String(Buffer.byteLength(body, 'utf-8')),
+                },
+                body,
+            });
+            if (res.ok) {
+                log(`WeChat notification sent: ${message.slice(0, 50)}`);
+            }
+            else {
+                log(`WeChat notification failed: HTTP ${res.status}`);
+            }
+        }
+        catch (error) {
+            log(`WeChat notification failed: ${error.message?.slice(0, 200) || error}`);
+        }
     }
 }
 // ==================== Main ====================
@@ -714,16 +760,24 @@ export async function main(args) {
     const cmd = args[0] || 'start';
     switch (cmd) {
         case 'init':
-            await cmdInit();
+            if (args[1] === 'wechat') {
+                await cmdInitWechat();
+            }
+            else if (args[1] === 'feishu') {
+                await cmdInitFeishu();
+            }
+            else {
+                await cmdInit();
+            }
             break;
         case 'start':
             cmdStart();
             break;
         case 'stop':
-            cmdStop();
+            await cmdStop();
             break;
         case 'restart':
-            cmdRestart();
+            await cmdRestart();
             break;
         case 'status':
             await cmdStatus();
@@ -738,12 +792,14 @@ export async function main(args) {
             console.log(`Usage: evolclaw {init|start|stop|restart|status|logs}
 
 Commands:
-  init      创建配置文件 (${resolvePaths().config})
-  start     启动服务 (默认)
-  stop      停止服务
-  restart   重启服务
-  status    查看状态
-  logs      查看日志 (tail -f)
+  init          创建配置文件 (${resolvePaths().config})
+  init wechat   微信扫码登录并写入配置
+  init feishu   飞书扫码登录并写入配置
+  start         启动服务 (默认)
+  stop          停止服务
+  restart       重启服务
+  status        查看状态
+  logs          查看日志 (tail -f)
 
 Environment:
   EVOLCLAW_HOME   数据目录 (默认: ~/.evolclaw)

package/dist/config.js

@@ -17,16 +17,24 @@ function loadClaudeSettings() {
 }
 export function resolveAnthropicConfig(config) {
     const settings = loadClaudeSettings();
-    const apiKey = config.anthropic?.apiKey
+    // 过滤占位符，视为未配置
+    const configApiKey = config.agents?.anthropic?.apiKey;
+    const isPlaceholderKey = !configApiKey ||
+        configApiKey.includes('your-') ||
+        configApiKey.includes('placeholder');
+    const apiKey = (isPlaceholderKey ? null : configApiKey)
         || process.env.ANTHROPIC_AUTH_TOKEN
         || settings.env?.ANTHROPIC_AUTH_TOKEN;
     if (!apiKey) {
-        throw new Error('No API key found. Set one of: config.anthropic.apiKey, env ANTHROPIC_AUTH_TOKEN, or ~/.claude/settings.json env.ANTHROPIC_AUTH_TOKEN');
+        throw new Error('No API key found. Set one of: agents.anthropic.apiKey, env ANTHROPIC_AUTH_TOKEN, or ~/.claude/settings.json env.ANTHROPIC_AUTH_TOKEN');
     }
-    const baseUrl = config.anthropic?.baseUrl
+    // baseUrl 也过滤占位符
+    const configBaseUrl = config.agents?.anthropic?.baseUrl;
+    const isPlaceholderUrl = configBaseUrl?.includes('api.anthropic.com');
+    const baseUrl = (isPlaceholderUrl ? null : configBaseUrl)
         || process.env.ANTHROPIC_BASE_URL
         || settings.env?.ANTHROPIC_BASE_URL;
-    const model = config.anthropic?.model
+    const model = config.agents?.anthropic?.model
         || settings.model
         || 'sonnet';
     return { apiKey, baseUrl, model };
@@ -44,35 +52,42 @@ export function saveConfig(config, configPath = resolvePaths().config) {
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
 }
 export function getOwner(config, channel) {
-    return config.owners?.[channel];
+    const ch = config.channels?.[channel];
+    return ch?.owner;
 }
 export function setOwner(config, channel, userId, configPath = resolvePaths().config) {
-    if (!config.owners) {
-        config.owners = {};
-    }
-    config.owners[channel] = userId;
+    if (!config.channels)
+        config.channels = {};
+    const channels = config.channels;
+    if (!channels[channel])
+        channels[channel] = {};
+    channels[channel].owner = userId;
     saveConfig(config, configPath);
 }
 export function isOwner(config, channel, userId) {
-    return config.owners?.[channel] === userId;
+    return getOwner(config, channel) === userId;
 }
 function validateConfig(config) {
     // anthropic 部分不再强制校验，由 resolveAnthropicConfig() 处理
     // Feishu 配置可选，但如果配置了就要完整
-    if (config.feishu) {
-        if (!config.feishu.appId || config.feishu.appId.startsWith('YOUR_')) {
+    if (config.channels?.feishu) {
+        if (!config.channels.feishu.appId || config.channels.feishu.appId.startsWith('YOUR_')) {
             logger.warn('⚠ Feishu appId not configured (Feishu channel will be disabled)');
         }
-        if (!config.feishu.appSecret || config.feishu.appSecret.startsWith('YOUR_')) {
+        if (!config.channels.feishu.appSecret || config.channels.feishu.appSecret.startsWith('YOUR_')) {
             logger.warn('⚠ Feishu appSecret not configured (Feishu channel will be disabled)');
         }
     }
-    if (!config.aun?.domain)
-        throw new Error('Missing aun.domain');
-    if (!config.aun?.agentName)
-        throw new Error('Missing aun.agentName');
+    if (!config.channels?.aun?.domain)
+        throw new Error('Missing channels.aun.domain');
+    if (!config.channels?.aun?.agentName)
+        throw new Error('Missing channels.aun.agentName');
     if (!config.projects?.defaultPath)
         throw new Error('Missing projects.defaultPath');
+    // WeChat 配置可选，但如果启用了就需要 token
+    if (config.channels?.wechat?.enabled && !config.channels?.wechat?.token) {
+        logger.warn('⚠ WeChat enabled but token not configured (WeChat channel will be disabled)');
+    }
 }
 export function ensureDir(dirPath) {
     if (!fs.existsSync(dirPath)) {