evolclaw 2.1.1 → 2.2.0

package/dist/config.js

@@ -15,6 +15,38 @@ function loadClaudeSettings() {
     catch { }
     return {};
 }
+function loadCodexSettings() {
+    try {
+        // Read auth.json for API key
+        const authPath = path.join(os.homedir(), '.codex', 'auth.json');
+        let apiKey;
+        if (fs.existsSync(authPath)) {
+            const auth = JSON.parse(fs.readFileSync(authPath, 'utf-8'));
+            apiKey = auth.OPENAI_API_KEY;
+        }
+        // Read config.toml for model and baseUrl (simple TOML parsing)
+        const configPath = path.join(os.homedir(), '.codex', 'config.toml');
+        let model;
+        let baseUrl;
+        if (fs.existsSync(configPath)) {
+            const content = fs.readFileSync(configPath, 'utf-8');
+            const modelMatch = content.match(/^model\s*=\s*"([^"]+)"/m);
+            if (modelMatch)
+                model = modelMatch[1];
+            // Extract base_url from model_providers section
+            const providerMatch = content.match(/^model_provider\s*=\s*"([^"]+)"/m);
+            if (providerMatch) {
+                const provider = providerMatch[1];
+                const baseUrlMatch = content.match(new RegExp(`\\[model_providers\\.${provider}\\][\\s\\S]*?base_url\\s*=\\s*"([^"]+)"`, 'm'));
+                if (baseUrlMatch)
+                    baseUrl = baseUrlMatch[1];
+            }
+        }
+        return { apiKey, baseUrl, model };
+    }
+    catch { }
+    return {};
+}
 export function resolveAnthropicConfig(config) {
     const settings = loadClaudeSettings();
     // 过滤占位符，视为未配置
@@ -42,6 +74,32 @@ export function resolveAnthropicConfig(config) {
         || undefined;
     return { apiKey, baseUrl, model, effort };
 }
+export function resolveOpenaiConfig(config) {
+    const codexSettings = loadCodexSettings();
+    // 过滤占位符，视为未配置
+    const configApiKey = config.agents?.openai?.apiKey;
+    const isPlaceholderKey = !configApiKey ||
+        configApiKey.includes('your-') ||
+        configApiKey.includes('placeholder');
+    const apiKey = (isPlaceholderKey ? null : configApiKey)
+        || process.env.OPENAI_API_KEY
+        || codexSettings.apiKey;
+    if (!apiKey) {
+        throw new Error('No OpenAI API key found. Set one of: agents.openai.apiKey, env OPENAI_API_KEY, or ~/.codex/auth.json');
+    }
+    // baseUrl 也过滤占位符（与 anthropic 保持一致：只检查默认域名）
+    const configBaseUrl = config.agents?.openai?.baseUrl;
+    const isPlaceholderUrl = configBaseUrl?.includes('api.openai.com');
+    const baseUrl = (isPlaceholderUrl ? null : configBaseUrl)
+        || process.env.OPENAI_BASE_URL
+        || codexSettings.baseUrl
+        || undefined;
+    const model = config.agents?.openai?.model
+        || codexSettings.model
+        || 'gpt-5.2-codex';
+    const reasoning = config.agents?.openai?.reasoning || undefined;
+    return { apiKey, baseUrl, model, reasoning };
+}
 export function loadConfig(configPath = resolvePaths().config) {
     if (!fs.existsSync(configPath)) {
         throw new Error(`Config file not found: ${configPath}`);
@@ -81,10 +139,15 @@ function validateConfig(config) {
             logger.warn('⚠ Feishu appSecret not configured (Feishu channel will be disabled)');
         }
     }
-    if (!config.channels?.aun?.domain)
-        throw new Error('Missing channels.aun.domain');
-    if (!config.channels?.aun?.agentName)
-        throw new Error('Missing channels.aun.agentName');
+    // AUN 配置可选，但如果配置了就要有 domain 和 agentName
+    if (config.channels?.aun?.enabled !== false && config.channels?.aun) {
+        if (!config.channels.aun.domain) {
+            logger.warn('⚠ AUN domain not configured (AUN channel will be disabled)');
+        }
+        if (!config.channels.aun.agentName) {
+            logger.warn('⚠ AUN agentName not configured (AUN channel will be disabled)');
+        }
+    }
     if (!config.projects?.defaultPath)
         throw new Error('Missing projects.defaultPath');
     // WeChat 配置可选，但如果启用了就需要 token
@@ -97,3 +160,38 @@ export function ensureDir(dirPath) {
         fs.mkdirSync(dirPath, { recursive: true });
     }
 }
+// agents.defaultAgent → config key 映射
+const agentKeyMap = { claude: 'anthropic', codex: 'openai' };
+/**
+ * 配置结构完整性校验（不校验凭据有效性）。
+ * 要求 agents/channels/projects 三段同时具备必要的锚点字段。
+ */
+export function validateConfigIntegrity(config) {
+    const reasons = [];
+    // agents
+    const defaultAgent = config.agents?.defaultAgent;
+    if (!defaultAgent) {
+        reasons.push('Missing agents.defaultAgent');
+    }
+    else {
+        const key = agentKeyMap[defaultAgent] || defaultAgent;
+        if (!config.agents?.[key]) {
+            reasons.push(`agents.defaultAgent='${defaultAgent}' but agents.${key} does not exist`);
+        }
+    }
+    // channels
+    const defaultChannel = config.channels?.defaultChannel;
+    if (!defaultChannel) {
+        reasons.push('Missing channels.defaultChannel');
+    }
+    else {
+        if (!config.channels?.[defaultChannel]) {
+            reasons.push(`channels.defaultChannel='${defaultChannel}' but channels.${defaultChannel} does not exist`);
+        }
+    }
+    // projects
+    if (!config.projects?.defaultPath) {
+        reasons.push('Missing projects.defaultPath');
+    }
+    return { valid: reasons.length === 0, reasons };
+}

package/dist/core/adapters/claude-session-file-adapter.js

@@ -0,0 +1,144 @@
+/**
+ * Claude SessionFileAdapter
+ *
+ * Reads Claude Agent SDK session files from ~/.claude/projects/{encodedPath}/{sessionId}.jsonl
+ * and wraps sdkListSessions for name synchronization.
+ */
+import { listSessions as sdkListSessions } from '@anthropic-ai/claude-agent-sdk';
+import { encodePath } from '../../utils/cross-platform.js';
+import { logger } from '../../utils/logger.js';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+export class ClaudeSessionFileAdapter {
+    agentId = 'claude';
+    getSessionFilePath(projectPath, agentSessionId) {
+        const homeDir = os.homedir();
+        const encodedPath = encodePath(projectPath);
+        return path.join(homeDir, '.claude', 'projects', encodedPath, `${agentSessionId}.jsonl`);
+    }
+    checkExists(projectPath, agentSessionId) {
+        const sessionFile = this.getSessionFilePath(projectPath, agentSessionId);
+        return fs.existsSync(sessionFile);
+    }
+    getFileInfo(projectPath, agentSessionId) {
+        const sessionFile = this.getSessionFilePath(projectPath, agentSessionId);
+        if (!fs.existsSync(sessionFile))
+            return { turns: 0 };
+        try {
+            const content = fs.readFileSync(sessionFile, 'utf-8');
+            const lines = content.split('\n').filter(l => l.trim());
+            let turns = 0;
+            let title;
+            for (const line of lines) {
+                const event = JSON.parse(line);
+                if (event.type === 'user' && event.message?.role === 'user') {
+                    const msgContent = event.message.content;
+                    const isToolResult = Array.isArray(msgContent) && msgContent.every((c) => c.type === 'tool_result');
+                    if (!isToolResult) {
+                        turns++;
+                    }
+                }
+                if (event.title && !title) {
+                    title = event.title;
+                }
+                if (event.sessionTitle && !title) {
+                    title = event.sessionTitle;
+                }
+            }
+            return { turns, title };
+        }
+        catch (error) {
+            logger.warn(`[ClaudeAdapter] Failed to read session file info: ${sessionFile}`, error);
+            return { turns: 0 };
+        }
+    }
+    readFirstMessage(projectPath, agentSessionId) {
+        const sessionFile = this.getSessionFilePath(projectPath, agentSessionId);
+        if (!fs.existsSync(sessionFile))
+            return null;
+        try {
+            const content = fs.readFileSync(sessionFile, 'utf-8');
+            const lines = content.split('\n').filter(l => l.trim());
+            for (const line of lines) {
+                const event = JSON.parse(line);
+                if (event.type === 'user' && event.message?.role === 'user') {
+                    const text = this.extractUserMessageText(event.message.content);
+                    if (text)
+                        return text;
+                }
+            }
+        }
+        catch (error) {
+            logger.warn(`[ClaudeAdapter] Failed to read session file: ${sessionFile}`, error);
+        }
+        return null;
+    }
+    readLastUserMessage(projectPath, agentSessionId) {
+        const sessionFile = this.getSessionFilePath(projectPath, agentSessionId);
+        if (!fs.existsSync(sessionFile))
+            return null;
+        try {
+            const content = fs.readFileSync(sessionFile, 'utf-8');
+            const lines = content.split('\n').filter(l => l.trim());
+            let lastMessage = null;
+            for (const line of lines) {
+                const event = JSON.parse(line);
+                if (event.type === 'user' && event.message?.role === 'user') {
+                    lastMessage = this.extractUserMessageText(event.message.content) ?? lastMessage;
+                }
+            }
+            return lastMessage;
+        }
+        catch (error) {
+            logger.warn(`[ClaudeAdapter] Failed to read last message from session file: ${sessionFile}`, error);
+        }
+        return null;
+    }
+    scanCliSessions(projectPath) {
+        const homeDir = os.homedir();
+        const encodedPath = encodePath(projectPath);
+        const sessionDir = path.join(homeDir, '.claude', 'projects', encodedPath);
+        if (!fs.existsSync(sessionDir))
+            return [];
+        const files = fs.readdirSync(sessionDir)
+            .filter(f => f.endsWith('.jsonl'))
+            .filter(f => !f.startsWith('agent-'))
+            .map(f => {
+            const filePath = path.join(sessionDir, f);
+            const stat = fs.statSync(filePath);
+            return { uuid: f.replace('.jsonl', ''), mtime: stat.mtimeMs, size: stat.size };
+        })
+            .filter(f => f.size > 0)
+            .sort((a, b) => b.mtime - a.mtime)
+            .slice(0, 10);
+        return files.map(f => ({ uuid: f.uuid, mtime: f.mtime }));
+    }
+    async listSdkSessions(projectPath) {
+        try {
+            const sessions = await sdkListSessions({ dir: projectPath });
+            return sessions.map(s => ({
+                sessionId: s.sessionId,
+                title: s.customTitle || undefined,
+            }));
+        }
+        catch (error) {
+            logger.debug('[ClaudeAdapter] SDK listSessions failed (non-critical):', error);
+            return [];
+        }
+    }
+    extractUserMessageText(messageContent) {
+        if (typeof messageContent === 'string') {
+            const text = messageContent.trim().replace(/\s+/g, ' ');
+            return text.substring(0, 50) + (text.length > 50 ? '...' : '');
+        }
+        else if (Array.isArray(messageContent)) {
+            const textContent = messageContent.find((c) => c.type === 'text');
+            if (textContent?.text) {
+                const text = textContent.text.trim().replace(/\s+/g, ' ');
+                return text.substring(0, 50) + (text.length > 50 ? '...' : '');
+            }
+        }
+        return null;
+    }
+}

package/dist/core/adapters/codex-session-file-adapter.js

@@ -0,0 +1,196 @@
+/**
+ * Codex SessionFileAdapter
+ *
+ * Reads Codex thread data from ~/.codex/state_*.sqlite (read-only)
+ * and Codex rollout JSONL files for detailed session info.
+ */
+import { DatabaseSync } from 'node:sqlite';
+import { logger } from '../../utils/logger.js';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+export class CodexSessionFileAdapter {
+    agentId = 'codex';
+    db = null;
+    dbInitialized = false;
+    /**
+     * 动态发现最新的 state_*.sqlite 文件
+     * Codex 使用 sqlx 迁移，DB 文件名含版本号（state_5, state_6, ...）
+     */
+    resolveStateDbPath() {
+        const codexHome = path.join(os.homedir(), '.codex');
+        if (!fs.existsSync(codexHome))
+            return null;
+        try {
+            const files = fs.readdirSync(codexHome)
+                .filter(f => /^state_\d+\.sqlite$/.test(f))
+                .sort((a, b) => {
+                const va = parseInt(a.match(/state_(\d+)/)?.[1] || '0');
+                const vb = parseInt(b.match(/state_(\d+)/)?.[1] || '0');
+                return vb - va;
+            });
+            return files.length > 0 ? path.join(codexHome, files[0]) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    getDb() {
+        if (this.dbInitialized)
+            return this.db;
+        this.dbInitialized = true;
+        const dbPath = this.resolveStateDbPath();
+        if (!dbPath)
+            return null;
+        try {
+            this.db = new DatabaseSync(dbPath, { readOnly: true });
+            logger.debug(`[CodexAdapter] Opened state DB: ${dbPath}`);
+        }
+        catch (error) {
+            logger.warn(`[CodexAdapter] Failed to open state DB: ${dbPath}`, error);
+            this.db = null;
+        }
+        return this.db;
+    }
+    checkExists(projectPath, agentSessionId) {
+        const db = this.getDb();
+        if (!db)
+            return false;
+        try {
+            const row = db.prepare('SELECT 1 FROM threads WHERE id = ? AND archived = 0').get(agentSessionId);
+            return !!row;
+        }
+        catch (error) {
+            logger.warn(`[CodexAdapter] checkExists failed:`, error);
+            return false;
+        }
+    }
+    getFileInfo(projectPath, agentSessionId) {
+        const db = this.getDb();
+        if (!db)
+            return { turns: 0 };
+        try {
+            const row = db.prepare('SELECT title, rollout_path FROM threads WHERE id = ?').get(agentSessionId);
+            if (!row)
+                return { turns: 0 };
+            const title = row.title || undefined;
+            const turns = this.countTurnsFromRollout(row.rollout_path);
+            return { turns, title };
+        }
+        catch (error) {
+            logger.warn(`[CodexAdapter] getFileInfo failed:`, error);
+            return { turns: 0 };
+        }
+    }
+    readFirstMessage(projectPath, agentSessionId) {
+        const db = this.getDb();
+        if (!db)
+            return null;
+        try {
+            const row = db.prepare('SELECT first_user_message FROM threads WHERE id = ?').get(agentSessionId);
+            if (!row?.first_user_message)
+                return null;
+            const text = row.first_user_message.trim().replace(/\s+/g, ' ');
+            return text.substring(0, 50) + (text.length > 50 ? '...' : '');
+        }
+        catch (error) {
+            logger.warn(`[CodexAdapter] readFirstMessage failed:`, error);
+            return null;
+        }
+    }
+    readLastUserMessage(projectPath, agentSessionId) {
+        const db = this.getDb();
+        if (!db)
+            return null;
+        try {
+            const row = db.prepare('SELECT rollout_path FROM threads WHERE id = ?').get(agentSessionId);
+            if (!row?.rollout_path || !fs.existsSync(row.rollout_path))
+                return null;
+            const content = fs.readFileSync(row.rollout_path, 'utf-8');
+            const lines = content.split('\n').filter(l => l.trim());
+            let lastMessage = null;
+            for (const line of lines) {
+                try {
+                    const event = JSON.parse(line);
+                    if (event.type === 'event_msg' && event.payload?.type === 'user_message' && event.payload.message) {
+                        const text = event.payload.message.trim().replace(/\s+/g, ' ');
+                        lastMessage = text.substring(0, 50) + (text.length > 50 ? '...' : '');
+                    }
+                }
+                catch { /* skip malformed line */ }
+            }
+            return lastMessage;
+        }
+        catch (error) {
+            logger.warn(`[CodexAdapter] readLastUserMessage failed:`, error);
+            return null;
+        }
+    }
+    scanCliSessions(projectPath) {
+        const db = this.getDb();
+        if (!db)
+            return [];
+        try {
+            const rows = db.prepare('SELECT id, updated_at FROM threads WHERE cwd = ? AND archived = 0 ORDER BY updated_at DESC LIMIT 10').all(projectPath);
+            return rows.map(r => ({
+                uuid: r.id,
+                mtime: r.updated_at, // Codex uses Unix timestamp (seconds)
+            }));
+        }
+        catch (error) {
+            logger.warn(`[CodexAdapter] scanCliSessions failed:`, error);
+            return [];
+        }
+    }
+    async listSdkSessions(projectPath) {
+        const db = this.getDb();
+        if (!db)
+            return [];
+        try {
+            const rows = db.prepare('SELECT id, title FROM threads WHERE cwd = ? AND archived = 0 ORDER BY updated_at DESC').all(projectPath);
+            return rows.map(r => ({
+                sessionId: r.id,
+                title: r.title || undefined,
+            }));
+        }
+        catch (error) {
+            logger.warn(`[CodexAdapter] listSdkSessions failed:`, error);
+            return [];
+        }
+    }
+    close() {
+        if (this.db) {
+            try {
+                this.db.close();
+            }
+            catch { /* ignore close errors */ }
+            this.db = null;
+        }
+        this.dbInitialized = false;
+    }
+    /**
+     * 从 rollout JSONL 文件计算轮数（数 turn_context 行）
+     */
+    countTurnsFromRollout(rolloutPath) {
+        if (!rolloutPath || !fs.existsSync(rolloutPath))
+            return 0;
+        try {
+            const content = fs.readFileSync(rolloutPath, 'utf-8');
+            const lines = content.split('\n').filter(l => l.trim());
+            let turns = 0;
+            for (const line of lines) {
+                try {
+                    const event = JSON.parse(line);
+                    if (event.type === 'turn_context') {
+                        turns++;
+                    }
+                }
+                catch { /* skip malformed line */ }
+            }
+            return turns;
+        }
+        catch {
+            return 0;
+        }
+    }
+}

package/dist/core/agent-loader.js

@@ -0,0 +1,39 @@
+/**
+ * Agent Plugin System
+ *
+ * Provides a lightweight plugin interface for agent integration.
+ */
+import { logger } from '../utils/logger.js';
+/**
+ * Agent Loader
+ *
+ * Manages agent plugin registration and creation.
+ */
+export class AgentLoader {
+    plugins = new Map();
+    register(plugin) {
+        if (this.plugins.has(plugin.name)) {
+            throw new Error(`Agent plugin '${plugin.name}' already registered`);
+        }
+        this.plugins.set(plugin.name, plugin);
+        logger.debug(`Registered agent plugin: ${plugin.name}`);
+    }
+    createAll(config, callbacks) {
+        const instances = [];
+        for (const [name, plugin] of this.plugins) {
+            if (!plugin.isEnabled(config)) {
+                logger.info(`Agent '${name}' is disabled, skipping`);
+                continue;
+            }
+            try {
+                const instance = plugin.createAgent(config, callbacks);
+                instances.push(instance);
+                logger.info(`✓ Agent '${name}' instance created`);
+            }
+            catch (error) {
+                logger.error(`✗ Failed to create agent '${name}':`, error);
+            }
+        }
+        return instances;
+    }
+}

package/dist/core/channel-loader.js

@@ -0,0 +1,60 @@
+/**
+ * Channel Plugin System
+ *
+ * Provides a lightweight plugin interface for channel integration.
+ * Plugins are responsible for creating channel instances only.
+ * The main service (index.ts) handles registration and message flow wiring.
+ */
+import { logger } from '../utils/logger.js';
+/**
+ * Channel Loader
+ *
+ * Manages channel plugin registration and lifecycle.
+ */
+export class ChannelLoader {
+    plugins = new Map();
+    register(plugin) {
+        if (this.plugins.has(plugin.name)) {
+            throw new Error(`Channel plugin '${plugin.name}' already registered`);
+        }
+        this.plugins.set(plugin.name, plugin);
+        logger.debug(`Registered channel plugin: ${plugin.name}`);
+    }
+    async createAll(config) {
+        const instances = [];
+        for (const [name, plugin] of this.plugins) {
+            if (!plugin.isEnabled(config)) {
+                logger.info(`Channel '${name}' is disabled, skipping`);
+                continue;
+            }
+            try {
+                const instance = await plugin.createChannel(config);
+                instances.push(instance);
+                logger.info(`✓ Channel '${name}' instance created`);
+            }
+            catch (error) {
+                logger.error(`✗ Failed to create channel '${name}':`, error);
+            }
+        }
+        return instances;
+    }
+    async connectAll(instances) {
+        const results = await Promise.allSettled(instances.map(async (inst) => {
+            await inst.connect();
+            return inst.adapter.name;
+        }));
+        const connected = results
+            .filter((r) => r.status === 'fulfilled')
+            .map((r) => r.value);
+        const failed = results
+            .filter((r) => r.status === 'rejected')
+            .map((r) => r.reason);
+        if (failed.length > 0) {
+            logger.warn(`Some channels failed to connect:`, failed);
+        }
+        return connected;
+    }
+    async disconnectAll(instances) {
+        await Promise.allSettled(instances.map((inst) => inst.disconnect()));
+    }
+}