evolclaw 2.2.0 → 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() {
@@ -97,12 +98,72 @@ export function resolveOpenaiConfig(config) {
     const model = config.agents?.openai?.model
         || codexSettings.model
         || 'gpt-5.2-codex';
-    const reasoning = config.agents?.openai?.reasoning || undefined;
-    return { apiKey, baseUrl, model, reasoning };
+    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);
@@ -112,47 +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 配置可选，但如果配置了就要有 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)');
+    // 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.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) {
@@ -161,7 +315,7 @@ export function ensureDir(dirPath) {
     }
 }
 // agents.defaultAgent → config key 映射
-const agentKeyMap = { claude: 'anthropic', codex: 'openai' };
+const agentKeyMap = { claude: 'anthropic', codex: 'openai', gemini: 'google' };
 /**
  * 配置结构完整性校验（不校验凭据有效性）。
  * 要求 agents/channels/projects 三段同时具备必要的锚点字段。

package/dist/core/channel-loader.js

@@ -28,9 +28,16 @@ export class ChannelLoader {
                 continue;
             }
             try {
-                const instance = await plugin.createChannel(config);
-                instances.push(instance);
-                logger.info(`✓ Channel '${name}' instance created`);
+                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);
@@ -41,7 +48,7 @@ export class ChannelLoader {
     async connectAll(instances) {
         const results = await Promise.allSettled(instances.map(async (inst) => {
             await inst.connect();
-            return inst.adapter.name;
+            return inst.adapter.channelName;
         }));
         const connected = results
             .filter((r) => r.status === 'fulfilled')