evolclaw 2.1.2 → 2.3.0

package/dist/config.js

@@ -2,7 +2,8 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import { logger } from './utils/logger.js';
-import { resolvePaths } from './paths.js';
+import { resolvePaths, getPackageRoot as _getPackageRoot } from './paths.js';
+import { commandExists } from './utils/cross-platform.js';
 // Re-export path utilities for backward compatibility
 export { resolveRoot, resolvePaths, ensureDataDirs, getPackageRoot } from './paths.js';
 function loadClaudeSettings() {
@@ -15,6 +16,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,9 +75,95 @@ 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 effort = config.agents?.openai?.effort || config.agents?.openai?.reasoning || undefined;
+    return { apiKey, baseUrl, model, effort };
+}
+export function resolveGoogleConfig(config) {
+    const googleCfg = config.agents?.google;
+    // CLI path: config → which gemini
+    let cliPath = googleCfg?.cliPath || '';
+    if (!cliPath) {
+        cliPath = commandExists('gemini') ? 'gemini' : '';
+    }
+    // Model: config → default
+    const model = googleCfg?.model || 'gemini-2.5-flash';
+    // API key: config → env (optional, CLI has OAuth)
+    const configApiKey = googleCfg?.apiKey;
+    const isPlaceholder = !configApiKey || configApiKey.includes('your-') || configApiKey.includes('placeholder');
+    const apiKey = (isPlaceholder ? undefined : configApiKey)
+        || process.env.GEMINI_API_KEY
+        || process.env.GOOGLE_API_KEY
+        || undefined;
+    const mode = googleCfg?.mode || 'cli';
+    const useVertex = googleCfg?.useVertex || false;
+    const project = googleCfg?.project || process.env.GOOGLE_CLOUD_PROJECT || undefined;
+    const location = googleCfg?.location || process.env.GOOGLE_CLOUD_LOCATION || 'us-central1';
+    return { cliPath, model, apiKey, mode, useVertex, project, location };
+}
 export function loadConfig(configPath = resolvePaths().config) {
     if (!fs.existsSync(configPath)) {
-        throw new Error(`Config file not found: ${configPath}`);
+        // Try to recover from backup files
+        const dataDir = path.dirname(configPath);
+        const backupPath = path.join(dataDir, 'evolclaw.backup.json');
+        if (fs.existsSync(backupPath)) {
+            logger.warn(`Config file missing, restoring from backup: ${backupPath}`);
+            fs.copyFileSync(backupPath, configPath);
+        }
+        else {
+            // Look for timestamped backups (evolclaw-YYYYMMDD-HHMMSS.json)
+            const timestampedBackups = fs.existsSync(dataDir)
+                ? fs.readdirSync(dataDir)
+                    .filter(f => /^evolclaw-\d{8}-\d{6}\.json$/.test(f))
+                    .sort()
+                    .reverse()
+                : [];
+            if (timestampedBackups.length > 0) {
+                const latest = path.join(dataDir, timestampedBackups[0]);
+                logger.warn(`Config file missing, restoring from timestamped backup: ${latest}`);
+                fs.copyFileSync(latest, configPath);
+            }
+            else {
+                // Create minimal config from sample
+                const samplePath = path.join(_getPackageRoot(), 'data', 'evolclaw.sample.json');
+                if (fs.existsSync(samplePath)) {
+                    logger.warn(`Config file missing, creating from sample: ${samplePath}`);
+                    const sample = JSON.parse(fs.readFileSync(samplePath, 'utf-8'));
+                    // Set a usable defaultPath
+                    const defaultProjectDir = path.join(os.homedir(), 'evolclaw-project');
+                    sample.projects.defaultPath = defaultProjectDir;
+                    if (!fs.existsSync(defaultProjectDir)) {
+                        fs.mkdirSync(defaultProjectDir, { recursive: true });
+                    }
+                    fs.writeFileSync(configPath, JSON.stringify(sample, null, 2), 'utf-8');
+                }
+                else {
+                    throw new Error(`Config file not found: ${configPath}`);
+                }
+            }
+        }
     }
     const content = fs.readFileSync(configPath, 'utf-8');
     const config = JSON.parse(content);
@@ -54,42 +173,140 @@ export function loadConfig(configPath = resolvePaths().config) {
 export function saveConfig(config, configPath = resolvePaths().config) {
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
 }
-export function getOwner(config, channel) {
-    const ch = config.channels?.[channel];
-    return ch?.owner;
+// ── Channel instance normalization ──
+export const channelTypes = ['feishu', 'wechat', 'aun'];
+/**
+ * Normalize a channel config value (single object, array, or undefined) into an array
+ * where every element has a `name` field.
+ * - undefined → []
+ * - single object → [{ ...obj, name: obj.name ?? defaultName }]
+ * - array → passthrough (names must already be present)
+ */
+export function normalizeChannelInstances(cfg, defaultName) {
+    if (cfg === undefined || cfg === null)
+        return [];
+    if (Array.isArray(cfg)) {
+        return cfg;
+    }
+    return [{ ...cfg, name: cfg.name ?? defaultName }];
 }
-export function setOwner(config, channel, userId, configPath = resolvePaths().config) {
+/**
+ * Validate that all channel instance names are unique across all channel types.
+ * Throws if duplicate names are found.
+ */
+export function validateChannelInstanceNames(config) {
+    const seen = new Map(); // name → channel type
+    for (const type of channelTypes) {
+        const instances = normalizeChannelInstances(config.channels?.[type], type);
+        for (const inst of instances) {
+            const prev = seen.get(inst.name);
+            if (prev !== undefined) {
+                throw new Error(`Duplicate channel instance name "${inst.name}" (found in ${prev} and ${type})`);
+            }
+            seen.set(inst.name, type);
+        }
+    }
+}
+export function getOwner(config, channelOrType) {
+    for (const type of channelTypes) {
+        const raw = config.channels?.[type];
+        const instances = normalizeChannelInstances(raw, type);
+        // 按实例名查找
+        const found = instances.find((inst) => inst.name === channelOrType);
+        if (found)
+            return found.owner;
+        // 按 channelType 查找：返回该类型下第一个有 owner 的实例
+        if (type === channelOrType) {
+            for (const inst of instances) {
+                if (inst.owner)
+                    return inst.owner;
+            }
+        }
+    }
+    return undefined;
+}
+export function setOwner(config, instanceName, userId, configPath = resolvePaths().config) {
     if (!config.channels)
         config.channels = {};
     const channels = config.channels;
-    if (!channels[channel])
-        channels[channel] = {};
-    channels[channel].owner = userId;
-    saveConfig(config, configPath);
+    for (const type of channelTypes) {
+        const raw = channels[type];
+        if (raw === undefined)
+            continue;
+        if (Array.isArray(raw)) {
+            const inst = raw.find((item) => item.name === instanceName);
+            if (inst) {
+                inst.owner = userId;
+                saveConfig(config, configPath);
+                return;
+            }
+        }
+        else {
+            // Single-object form: match if name matches (or defaults to type name)
+            const effectiveName = raw.name ?? type;
+            if (effectiveName === instanceName) {
+                raw.owner = userId;
+                saveConfig(config, configPath);
+                return;
+            }
+        }
+    }
+    // Fallback: if instanceName matches a channel type with no config, create it
+    if (channelTypes.includes(instanceName)) {
+        channels[instanceName] = { owner: userId };
+        saveConfig(config, configPath);
+        return;
+    }
 }
-export function isOwner(config, channel, userId) {
-    return getOwner(config, channel) === userId;
+export function isOwner(config, channelOrType, userId) {
+    // 按实例名精确匹配
+    if (getOwner(config, channelOrType) === userId)
+        return true;
+    // 按 channelType 匹配：检查该类型下所有实例
+    for (const type of channelTypes) {
+        if (type !== channelOrType)
+            continue;
+        const raw = config.channels?.[type];
+        const instances = normalizeChannelInstances(raw, type);
+        for (const inst of instances) {
+            if (inst.owner === userId)
+                return true;
+        }
+    }
+    return false;
 }
 function validateConfig(config) {
     // anthropic 部分不再强制校验，由 resolveAnthropicConfig() 处理
-    // Feishu 配置可选，但如果配置了就要完整
-    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)');
+    // Feishu 配置可选，但如果配置了就要完整（支持 array / object 两种格式）
+    const feishuInstances = normalizeChannelInstances(config.channels?.feishu, 'feishu');
+    for (const inst of feishuInstances) {
+        const label = feishuInstances.length > 1 ? ` [${inst.name}]` : '';
+        if (!inst.appId || inst.appId.startsWith('YOUR_')) {
+            logger.warn(`⚠ Feishu${label} appId not configured (Feishu channel will be disabled)`);
         }
-        if (!config.channels.feishu.appSecret || config.channels.feishu.appSecret.startsWith('YOUR_')) {
-            logger.warn('⚠ Feishu appSecret not configured (Feishu channel will be disabled)');
+        if (!inst.appSecret || inst.appSecret.startsWith('YOUR_')) {
+            logger.warn(`⚠ Feishu${label} appSecret not configured (Feishu channel will be disabled)`);
+        }
+    }
+    // AUN 配置可选，但如果配置了就要有 aid（支持 array / object 两种格式）
+    const aunInstances = normalizeChannelInstances(config.channels?.aun, 'aun');
+    for (const inst of aunInstances) {
+        if (inst.enabled === false)
+            continue;
+        const label = aunInstances.length > 1 ? ` [${inst.name}]` : '';
+        if (!inst.aid) {
+            logger.warn(`⚠ AUN${label} aid not configured (AUN 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');
     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)');
+    // WeChat 配置可选，但如果启用了就需要 token（支持 array / object 两种格式）
+    const wechatInstances = normalizeChannelInstances(config.channels?.wechat, 'wechat');
+    for (const inst of wechatInstances) {
+        if (inst.enabled && !inst.token) {
+            const label = wechatInstances.length > 1 ? ` [${inst.name}]` : '';
+            logger.warn(`⚠ WeChat${label} enabled but token not configured (WeChat channel will be disabled)`);
+        }
     }
 }
 export function ensureDir(dirPath) {
@@ -97,3 +314,38 @@ export function ensureDir(dirPath) {
         fs.mkdirSync(dirPath, { recursive: true });
     }
 }
+// agents.defaultAgent → config key 映射
+const agentKeyMap = { claude: 'anthropic', codex: 'openai', gemini: 'google' };
+/**
+ * 配置结构完整性校验（不校验凭据有效性）。
+ * 要求 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/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,67 @@
+/**
+ * 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 {
+                if (plugin.createChannels) {
+                    const channelInstances = await plugin.createChannels(config);
+                    instances.push(...channelInstances);
+                    logger.info(`✓ Channel '${name}' created ${channelInstances.length} instance(s)`);
+                }
+                else {
+                    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.channelName;
+        }));
+        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()));
+    }
+}