evolclaw 2.0.0

package/dist/config.js

@@ -0,0 +1,81 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { logger } from './utils/logger.js';
+import { resolvePaths } from './paths.js';
+// Re-export path utilities for backward compatibility
+export { resolveRoot, resolvePaths, ensureDataDirs, getPackageRoot } from './paths.js';
+function loadClaudeSettings() {
+    try {
+        const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+        if (fs.existsSync(settingsPath)) {
+            return JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        }
+    }
+    catch { }
+    return {};
+}
+export function resolveAnthropicConfig(config) {
+    const settings = loadClaudeSettings();
+    const apiKey = config.anthropic?.apiKey
+        || 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');
+    }
+    const baseUrl = config.anthropic?.baseUrl
+        || process.env.ANTHROPIC_BASE_URL
+        || settings.env?.ANTHROPIC_BASE_URL;
+    const model = config.anthropic?.model
+        || settings.model
+        || 'sonnet';
+    return { apiKey, baseUrl, model };
+}
+export function loadConfig(configPath = resolvePaths().config) {
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`Config file not found: ${configPath}`);
+    }
+    const content = fs.readFileSync(configPath, 'utf-8');
+    const config = JSON.parse(content);
+    validateConfig(config);
+    return config;
+}
+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];
+}
+export function setOwner(config, channel, userId, configPath = resolvePaths().config) {
+    if (!config.owners) {
+        config.owners = {};
+    }
+    config.owners[channel] = userId;
+    saveConfig(config, configPath);
+}
+export function isOwner(config, channel, userId) {
+    return config.owners?.[channel] === userId;
+}
+function validateConfig(config) {
+    // anthropic 部分不再强制校验，由 resolveAnthropicConfig() 处理
+    // Feishu 配置可选，但如果配置了就要完整
+    if (config.feishu) {
+        if (!config.feishu.appId || config.feishu.appId.startsWith('YOUR_')) {
+            logger.warn('⚠ Feishu appId not configured (Feishu channel will be disabled)');
+        }
+        if (!config.feishu.appSecret || config.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.projects?.defaultPath)
+        throw new Error('Missing projects.defaultPath');
+}
+export function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}

package/dist/core/agent-runner.js

@@ -0,0 +1,326 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { ensureDir } from '../config.js';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { MessageStream } from './message-stream.js';
+import { logger } from '../utils/logger.js';
+import { canUseTool } from '../utils/permission.js';
+export class AgentRunner {
+    apiKey;
+    model;
+    baseUrl;
+    config;
+    activeSessions = new Map();
+    activeStreams = new Map();
+    onSessionIdUpdate;
+    onCompactStart;
+    constructor(apiKey, model, onSessionIdUpdate, baseUrl, config) {
+        this.apiKey = apiKey;
+        this.model = model || 'sonnet';
+        this.baseUrl = baseUrl;
+        this.config = config;
+        this.onSessionIdUpdate = onSessionIdUpdate;
+    }
+    setModel(model) {
+        this.model = model;
+    }
+    getModel() {
+        return this.model;
+    }
+    setCompactStartCallback(callback) {
+        this.onCompactStart = callback;
+    }
+    async runQuery(sessionId, prompt, projectPath, initialClaudeSessionId, images, systemPromptAppend, sessionManager) {
+        ensureDir(projectPath);
+        ensureDir(path.join(projectPath, '.claude'));
+        // 优先使用传入的 claudeSessionId（从数据库恢复），否则使用内存中的
+        let claudeSessionId = initialClaudeSessionId || this.activeSessions.get(sessionId);
+        // 检查是否在安全模式
+        let skipResume = false;
+        if (sessionManager) {
+            const health = await sessionManager.getHealthStatus(sessionId);
+            if (health.safeMode) {
+                // 安全模式：不使用 resume，每次都是新对话
+                claudeSessionId = undefined;
+                skipResume = true;
+                logger.warn(`[AgentRunner] Safe mode enabled for ${sessionId}, not resuming session`);
+            }
+        }
+        // 验证会话文件是否存在且有效（仅在非安全模式且有 claudeSessionId 时）
+        if (claudeSessionId && !skipResume) {
+            const homeDir = os.homedir();
+            const encodedPath = projectPath.replace(/\//g, '-');
+            const sessionFile = path.join(homeDir, '.claude', 'projects', encodedPath, `${claudeSessionId}.jsonl`);
+            let isValid = false;
+            if (fs.existsSync(sessionFile)) {
+                try {
+                    const content = fs.readFileSync(sessionFile, 'utf-8');
+                    const lines = content.split('\n').filter(l => l.trim());
+                    // 查找第一个包含 sessionId 和 version 的行（跳过 queue-operation）
+                    for (const line of lines) {
+                        try {
+                            const data = JSON.parse(line);
+                            if (data.sessionId && data.version) {
+                                isValid = true;
+                                break;
+                            }
+                        }
+                        catch { }
+                    }
+                    if (!isValid) {
+                        logger.warn(`[AgentRunner] Session file missing session data: ${sessionFile}`);
+                    }
+                }
+                catch (error) {
+                    logger.warn(`[AgentRunner] Session file corrupted: ${sessionFile}`);
+                }
+            }
+            if (!isValid) {
+                logger.warn(`[AgentRunner] Invalid session file, starting new session`);
+                claudeSessionId = undefined;
+                this.activeSessions.delete(sessionId);
+                if (this.onSessionIdUpdate) {
+                    this.onSessionIdUpdate(sessionId, '');
+                }
+            }
+        }
+        // PreCompact Hook - 在压缩开始时触发
+        const preCompactHook = async () => {
+            if (this.onCompactStart) {
+                this.onCompactStart(sessionId);
+            }
+            return {};
+        };
+        // PreToolUse Hook - 工具执行前安全检查
+        const preToolUseHook = async (input) => {
+            const result = await canUseTool(input.tool_name, input.tool_input || {});
+            if (result.behavior === 'deny') {
+                // 使用 decision: 'block' 来拒绝工具执行
+                return {
+                    decision: 'block',
+                    reason: result.message
+                };
+            }
+            return {};
+        };
+        const useSettingSources = this.config?.sdk?.useSettingSources !== false;
+        const enableSummaries = this.config?.sdk?.agentProgressSummaries !== false;
+        // 公共 options（新旧模式共用）
+        const commonOptions = {
+            cwd: projectPath,
+            model: this.model,
+            canUseTool,
+            permissionMode: 'default',
+            persistSession: true,
+            hooks: {
+                PreCompact: [{ matcher: '.*', hooks: [preCompactHook] }],
+                PreToolUse: [{ matcher: '.*', hooks: [preToolUseHook] }]
+            },
+            ...(enableSummaries ? { agentProgressSummaries: true } : {}),
+            stderr: (msg) => {
+                if (msg.includes('[ERROR]') || msg.includes('[WARN]') || msg.includes('Stream started')) {
+                    logger.info(`[Claude-stderr] ${msg.trim()}`);
+                }
+                else {
+                    logger.debug(`[Claude-stderr] ${msg.trim()}`);
+                }
+            },
+            env: {
+                ...process.env,
+                ANTHROPIC_AUTH_TOKEN: this.apiKey,
+                PATH: process.env.PATH,
+                DISABLE_AUTOUPDATER: '1',
+                ...(this.baseUrl ? { ANTHROPIC_BASE_URL: this.baseUrl } : {})
+            }
+        };
+        const createQuery = (promptInput, resumeSessionId) => {
+            if (useSettingSources) {
+                // 新方式：SDK 自动加载 CLAUDE.md 和 MCP 配置
+                return query({
+                    prompt: promptInput,
+                    options: {
+                        ...commonOptions,
+                        settingSources: ['project', 'user'],
+                        systemPrompt: {
+                            type: 'preset',
+                            preset: 'claude_code',
+                            ...(systemPromptAppend ? { append: systemPromptAppend } : {})
+                        },
+                        ...(resumeSessionId ? { resume: resumeSessionId } : {}),
+                    }
+                });
+            }
+            else {
+                // 旧方式：手动加载 CLAUDE.md 和 MCP 配置（保留用于回滚）
+                const globalClaudeMd = (() => {
+                    try {
+                        const globalPath = path.join(os.homedir(), '.claude', 'CLAUDE.md');
+                        if (fs.existsSync(globalPath)) {
+                            return fs.readFileSync(globalPath, 'utf-8').trim();
+                        }
+                    }
+                    catch { }
+                    return '';
+                })();
+                const projectClaudeMds = [
+                    path.join(projectPath, 'CLAUDE.md'),
+                    path.join(projectPath, '.claude', 'CLAUDE.md'),
+                ].map(p => {
+                    try {
+                        return fs.existsSync(p) ? fs.readFileSync(p, 'utf-8').trim() : '';
+                    }
+                    catch {
+                        return '';
+                    }
+                }).filter(Boolean);
+                const globalMcpServers = (() => {
+                    try {
+                        const mcpPath = path.join(os.homedir(), '.claude', 'mcp.json');
+                        if (fs.existsSync(mcpPath)) {
+                            const config = JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
+                            return config.mcpServers || {};
+                        }
+                    }
+                    catch { }
+                    return {};
+                })();
+                const fullAppend = [...projectClaudeMds, globalClaudeMd, systemPromptAppend].filter(Boolean).join('\n\n');
+                return query({
+                    prompt: promptInput,
+                    options: {
+                        ...commonOptions,
+                        ...(resumeSessionId ? { resume: resumeSessionId } : {}),
+                        ...(Object.keys(globalMcpServers).length > 0 ? { mcpServers: globalMcpServers } : {}),
+                        ...(fullAppend ? {
+                            systemPrompt: {
+                                type: 'preset',
+                                preset: 'claude_code',
+                                append: fullAppend
+                            }
+                        } : {}),
+                    }
+                });
+            }
+        };
+        let lastError;
+        for (let attempt = 0; attempt < 3; attempt++) {
+            try {
+                let queryStream;
+                if (images && images.length > 0) {
+                    logger.debug('[AgentRunner] Creating query with images, images:', images.length);
+                    logger.debug('[AgentRunner] Skipping resume for image message to avoid history conflict');
+                    const stream = new MessageStream();
+                    stream.push(prompt, images);
+                    stream.end();
+                    queryStream = createQuery(stream);
+                }
+                else {
+                    logger.debug('[AgentRunner] Creating query with text only, claudeSessionId:', initialClaudeSessionId);
+                    queryStream = createQuery(prompt, claudeSessionId);
+                }
+                this.activeStreams.set(sessionId, queryStream);
+                return queryStream;
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < 2) {
+                    await new Promise(resolve => setTimeout(resolve, (attempt + 1) * 1000));
+                }
+            }
+        }
+        throw lastError;
+    }
+    async interrupt(sessionId) {
+        const stream = this.activeStreams.get(sessionId);
+        if (stream && 'interrupt' in stream && typeof stream.interrupt === 'function') {
+            await stream.interrupt();
+            this.activeStreams.delete(sessionId);
+            logger.info(`[AgentRunner] Interrupted session: ${sessionId}`);
+        }
+    }
+    registerStream(key, stream) {
+        this.activeStreams.set(key, stream);
+    }
+    cleanupStream(sessionId) {
+        this.activeStreams.delete(sessionId);
+    }
+    updateSessionId(sessionId, claudeSessionId) {
+        logger.info(`[AgentRunner] updateSessionId called: sessionId=${sessionId}, claudeSessionId=${claudeSessionId}`);
+        this.activeSessions.set(sessionId, claudeSessionId);
+        if (this.onSessionIdUpdate) {
+            this.onSessionIdUpdate(sessionId, claudeSessionId);
+        }
+    }
+    /**
+     * 主动压缩会话上下文
+     */
+    async compactSession(sessionId, claudeSessionId, projectPath) {
+        try {
+            logger.info(`[AgentRunner] Compacting session: ${claudeSessionId}`);
+            const stream = query({
+                prompt: '/compact',
+                options: {
+                    cwd: projectPath,
+                    model: this.model,
+                    resume: claudeSessionId,
+                    maxTurns: 1,
+                    permissionMode: 'default',
+                    env: {
+                        ...process.env,
+                        ANTHROPIC_AUTH_TOKEN: this.apiKey,
+                        DISABLE_AUTOUPDATER: '1',
+                        ...(this.baseUrl ? { ANTHROPIC_BASE_URL: this.baseUrl } : {})
+                    }
+                }
+            });
+            for await (const event of stream) {
+                if (event.type === 'system' && event.subtype === 'compact_boundary') {
+                    logger.info(`[AgentRunner] Compact completed, pre_tokens: ${event.compact_metadata?.pre_tokens}`);
+                    return true;
+                }
+            }
+            return true; // 正常结束也算成功
+        }
+        catch (error) {
+            logger.error('[AgentRunner] Compact failed:', error);
+            return false;
+        }
+    }
+    /**
+     * 通过 SDK /clear 命令清空会话历史
+     */
+    async clearSession(claudeSessionId, projectPath) {
+        try {
+            logger.info(`[AgentRunner] Clearing session via SDK: ${claudeSessionId}`);
+            const stream = query({
+                prompt: '/clear',
+                options: {
+                    cwd: projectPath,
+                    model: this.model,
+                    resume: claudeSessionId,
+                    maxTurns: 1,
+                    permissionMode: 'default',
+                    env: {
+                        ...process.env,
+                        ANTHROPIC_AUTH_TOKEN: this.apiKey,
+                        DISABLE_AUTOUPDATER: '1',
+                        ...(this.baseUrl ? { ANTHROPIC_BASE_URL: this.baseUrl } : {})
+                    }
+                }
+            });
+            for await (const event of stream) {
+                logger.debug(`[AgentRunner] Clear event: type=${event.type}, subtype=${event.subtype || 'none'}`);
+            }
+            return true;
+        }
+        catch (error) {
+            logger.error('[AgentRunner] Clear session failed:', error);
+            return false;
+        }
+    }
+    async closeSession(sessionId) {
+        this.activeSessions.delete(sessionId);
+        this.activeStreams.delete(sessionId);
+    }
+}