evolclaw 2.8.3 → 3.1.0

package/dist/agents/kit-renderer.js

@@ -0,0 +1,281 @@
+import fs from 'fs';
+import path from 'path';
+import { kitsDir, eckDebugDir, resolveRoot } from '../paths.js';
+import { logger } from '../utils/logger.js';
+// ── Param descriptions (for debug output) ──
+const PARAM_DESCRIPTIONS = {
+    EVOLCLAW_HOME: '用户数据根目录',
+    PACKAGE_ROOT: 'evolclaw 包根目录',
+    CURRENT_PROJECT: '当前项目完整路径',
+    selfAid: '当前 agent 的 AID',
+    selfName: '当前 agent 的显示名',
+    hasPersona: '是否有 persona 内容',
+    hasWorkingMemory: '是否有 working memory',
+    peerId: '对端在该渠道的原生 ID',
+    peerKey: '对端跨渠道唯一标识（channel#urlEncode(peerId)）',
+    peerName: '对端显示名',
+    peerRole: '对端角色',
+    groupId: '群组 ID（群聊时）',
+    scene: '场景类型',
+    chatType: '聊天类型',
+    channel: '当前渠道',
+    venueUid: 'venue 唯一标识',
+    project: '当前项目目录名（由 CURRENT_PROJECT 派生）',
+    sessionName: '会话名称',
+    sessionMode: '会话模式',
+    readonly: '是否只读模式',
+    canSendFile: '当前渠道是否支持发文件',
+    capabilities: '渠道能力列表',
+    baseAgent: '当前 base agent 规范值（claude/codex/gemini/hermes）',
+    baseAgentName: '当前 base agent 显示名',
+};
+// ── Cache ──
+let _manifestCache = null;
+const _sessionPathCache = new Map();
+// ── Public API ──
+export function loadKitManifest() {
+    _manifestCache = loadAndMergeManifest();
+    logger.info(`[KitRenderer] Loaded manifest: ${_manifestCache.length} sections`);
+}
+export function invalidateKitCache() {
+    _manifestCache = null;
+    _sessionPathCache.clear();
+}
+export function invalidateSessionCache(sessionId) {
+    _sessionPathCache.delete(sessionId);
+}
+export function renderKitSections(ctx) {
+    if (!_manifestCache)
+        loadKitManifest();
+    const sections = _manifestCache;
+    const fileParts = [];
+    for (const section of sections) {
+        if (section.enabled === false)
+            continue;
+        if (!evaluateWhen(section.when, ctx.vars))
+            continue;
+        const files = loadSectionFiles(section, ctx);
+        if (files.length === 0)
+            continue;
+        for (const [filePath, rawContent] of files) {
+            const content = section.needsInjection ? renderTemplate(rawContent, ctx.vars) : rawContent;
+            if (!content.trim())
+                continue;
+            const label = section.description ? `${section.id} — ${section.description}` : section.id;
+            fileParts.push(`Contenu de ${filePath} (${label}):\n\n${content.trimEnd()}`);
+        }
+    }
+    if (fileParts.length === 0)
+        return '';
+    const body = fileParts.join('\n\n');
+    const output = `<system-reminder>\nEvolClaw Context Kit documents are shown below.\n\n${body}\n\nIMPORTANT: Use this context when it affects the current interaction.\n</system-reminder>`;
+    writeDebugFiles(ctx, output);
+    return output;
+}
+export function cleanEckDebug() {
+    const dir = eckDebugDir();
+    const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+    try {
+        for (const f of fs.readdirSync(dir)) {
+            const fp = path.join(dir, f);
+            try {
+                if (fs.statSync(fp).mtimeMs < cutoff)
+                    fs.unlinkSync(fp);
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* dir doesn't exist yet */ }
+}
+// CHUNK_CONTINUE_2
+// ── Manifest loading ──
+function loadAndMergeManifest() {
+    const kitsPath = path.join(kitsDir(), 'eck_manifest.json');
+    const eckPath = path.join(resolveRoot(), 'eck', 'eck_manifest.json');
+    let base;
+    try {
+        base = JSON.parse(fs.readFileSync(kitsPath, 'utf-8'));
+    }
+    catch (err) {
+        logger.error(`[KitRenderer] Failed to load kits/eck_manifest.json: ${err}`);
+        return [];
+    }
+    if (!fs.existsSync(eckPath)) {
+        return sortSections(base.sections);
+    }
+    try {
+        const override = JSON.parse(fs.readFileSync(eckPath, 'utf-8'));
+        if (override.mode === 'replace') {
+            return sortSections(override.sections);
+        }
+        const merged = new Map();
+        for (const s of base.sections)
+            merged.set(s.id, { ...s });
+        for (const s of override.sections) {
+            const existing = merged.get(s.id);
+            if (existing) {
+                merged.set(s.id, { ...existing, ...s });
+            }
+            else {
+                merged.set(s.id, s);
+            }
+        }
+        return sortSections([...merged.values()]);
+    }
+    catch (err) {
+        logger.warn(`[KitRenderer] Failed to load eck override, using kits only: ${err}`);
+        return sortSections(base.sections);
+    }
+}
+function sortSections(sections) {
+    return sections.slice().sort((a, b) => a.order - b.order);
+}
+// ── Section content loading ──
+function loadSectionFiles(section, ctx) {
+    if (section.type === 'file' && section.file) {
+        const result = loadFileSection(section.file, ctx);
+        return result ? [result] : [];
+    }
+    if (section.type === 'directory' && section.path) {
+        return loadDirectorySection(section.path, section.pattern, ctx);
+    }
+    return [];
+}
+function loadFileSection(filePath, ctx) {
+    const resolved = resolvePath(filePath, ctx);
+    if (!resolved)
+        return null;
+    const sessionCache = getSessionCache(ctx.sessionId);
+    if (sessionCache.has(resolved))
+        return [resolved, sessionCache.get(resolved)];
+    try {
+        const content = fs.readFileSync(resolved, 'utf-8');
+        sessionCache.set(resolved, content);
+        return [resolved, content];
+    }
+    catch {
+        return null;
+    }
+}
+function loadDirectorySection(dirPath, pattern, ctx) {
+    const resolved = resolvePath(dirPath, ctx);
+    if (!resolved)
+        return [];
+    return readDirectoryFiles(resolved, pattern).map(([name, content]) => [path.join(resolved, name), content]);
+}
+// ── Path resolution ──
+function resolvePath(rawPath, ctx) {
+    let resolved = rawPath.replace(/\$([A-Z_]+)/g, (_, name) => {
+        const val = ctx.vars[name];
+        if (val === undefined || val === null || val === false || val === '')
+            return '';
+        return String(val);
+    });
+    resolved = resolved.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+        const val = ctx.vars[key];
+        if (val === undefined || val === null || val === false || val === '')
+            return '';
+        return String(val);
+    });
+    if (!resolved || resolved.includes('$') || resolved.includes('{{'))
+        return null;
+    if (!fs.existsSync(resolved))
+        return null;
+    return resolved;
+}
+// CHUNK_CONTINUE_5
+// ── Directory reading ──
+function readDirectoryFiles(dirPath, pattern) {
+    const glob = pattern || '*.md';
+    try {
+        const files = fs.readdirSync(dirPath)
+            .filter(f => matchGlob(f, glob))
+            .sort();
+        return files.map(f => {
+            const content = fs.readFileSync(path.join(dirPath, f), 'utf-8');
+            return [f, content];
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function matchGlob(filename, pattern) {
+    const regex = pattern
+        .replace(/\./g, '\\.')
+        .replace(/\*/g, '.*')
+        .replace(/\{([^}]+)\}/g, (_, alts) => `(${alts.split(',').join('|')})`);
+    return new RegExp(`^${regex}$`).test(filename);
+}
+// ── When condition evaluation ──
+function evaluateWhen(when, vars) {
+    if (when === 'always')
+        return true;
+    if (when.var !== undefined) {
+        const val = vars[when.var];
+        if (when.eq !== undefined)
+            return val === when.eq;
+        if (when.neq !== undefined)
+            return val !== when.neq;
+        if (when.in !== undefined)
+            return when.in.includes(val);
+        if (when.nin !== undefined)
+            return !when.nin.includes(val);
+    }
+    if (when.any)
+        return when.any.some(k => isTruthy(vars[k]));
+    if (when.all)
+        return when.all.every(k => isTruthy(vars[k]));
+    return true;
+}
+function isTruthy(val) {
+    return val !== undefined && val !== null && val !== false && val !== '' && val !== 0;
+}
+// CHUNK_CONTINUE_6
+// ── Template rendering ──
+function renderTemplate(template, vars) {
+    // Pass 1: conditional sections {{?key=value}}...{{/}} and {{?key}}...{{/}}
+    let result = template.replace(/\{\{\?(\w+)(?:=([^}]*))?\}\}([\s\S]*?)\{\{\/\}\}/g, (_match, key, value, body) => {
+        if (value !== undefined) {
+            return String(vars[key]) === value ? body : '';
+        }
+        return isTruthy(vars[key]) ? body : '';
+    });
+    // Pass 2: variable substitution {{key}}
+    result = result.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
+        const val = vars[key];
+        if (!isTruthy(val))
+            return '';
+        return String(val);
+    });
+    // Pass 3: remove blank lines
+    return result.split('\n').filter(line => line.trim() !== '').join('\n');
+}
+// ── Session cache helper ──
+function getSessionCache(sessionId) {
+    let cache = _sessionPathCache.get(sessionId);
+    if (!cache) {
+        cache = new Map();
+        _sessionPathCache.set(sessionId, cache);
+    }
+    return cache;
+}
+// ── Debug output ──
+function writeDebugFiles(ctx, output) {
+    const now = new Date();
+    const ts = now.toISOString().replace(/[T:.]/g, '-').slice(0, 19);
+    const dir = eckDebugDir();
+    const varsData = {
+        timestamp: now.toISOString(),
+        sessionId: ctx.sessionId,
+        params: Object.entries(ctx.vars)
+            .filter(([, v]) => v !== undefined && v !== null)
+            .map(([name, value]) => ({
+            name,
+            value,
+            description: PARAM_DESCRIPTIONS[name] || '',
+        })),
+    };
+    fs.writeFile(path.join(dir, `vars-${ts}.json`), JSON.stringify(varsData, null, 2), () => { });
+    fs.writeFile(path.join(dir, `context-${ts}.md`), output, () => { });
+}

package/dist/agents/resolve.js

@@ -0,0 +1,134 @@
+/**
+ * Baseagent credential resolvers.
+ *
+ * 输入是 Config 形态（`config.agents.<baseagent>` + override）。启动期由 index.ts
+ * 从 primaryAgent.config.baseagents 构造一个 syntheticConfig 喂入；各 plugin 的
+ * createAgent 也各自构造 syntheticConfig。
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { commandExists } from '../utils/cross-platform.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, override) {
+    const settings = loadClaudeSettings();
+    const isPlaceholder = (v) => !v || v.includes('your-') || v.includes('placeholder');
+    const overrideApiKey = isPlaceholder(override?.apiKey) ? undefined : override?.apiKey;
+    const globalApiKey = isPlaceholder(config.agents?.claude?.apiKey) ? undefined : config.agents?.claude?.apiKey;
+    const apiKey = overrideApiKey
+        || globalApiKey
+        || process.env.ANTHROPIC_AUTH_TOKEN
+        || settings.env?.ANTHROPIC_AUTH_TOKEN;
+    if (!apiKey) {
+        throw new Error('No API key found. Set one of: baseagents.claude.apiKey (per-agent or defaults), env ANTHROPIC_AUTH_TOKEN, or ~/.claude/settings.json env.ANTHROPIC_AUTH_TOKEN');
+    }
+    const isPlaceholderUrl = (v) => !v || v.includes('api.anthropic.com');
+    const overrideBaseUrl = isPlaceholderUrl(override?.baseUrl) ? undefined : override?.baseUrl;
+    const globalBaseUrl = isPlaceholderUrl(config.agents?.claude?.baseUrl) ? undefined : config.agents?.claude?.baseUrl;
+    const baseUrl = overrideBaseUrl
+        || globalBaseUrl
+        || process.env.ANTHROPIC_BASE_URL
+        || settings.env?.ANTHROPIC_BASE_URL;
+    const model = override?.model
+        || config.agents?.claude?.model
+        || settings.model
+        || 'sonnet';
+    const effort = override?.effort
+        || config.agents?.claude?.effort
+        || settings.effortLevel
+        || undefined;
+    const pickExec = (v) => (!v || v.includes('your-') || v.includes('placeholder')) ? undefined : v;
+    const pathToClaudeCodeExecutable = pickExec(override?.pathToClaudeCodeExecutable)
+        || pickExec(config.agents?.claude?.pathToClaudeCodeExecutable);
+    return { apiKey, baseUrl, model, effort, pathToClaudeCodeExecutable };
+}
+function loadCodexSettings() {
+    try {
+        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;
+        }
+        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];
+            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 resolveOpenaiConfig(config, override) {
+    const codexSettings = loadCodexSettings();
+    const isPlaceholder = (v) => !v || v.includes('your-') || v.includes('placeholder');
+    const overrideApiKey = isPlaceholder(override?.apiKey) ? undefined : override?.apiKey;
+    const globalApiKey = isPlaceholder(config.agents?.codex?.apiKey) ? undefined : config.agents?.codex?.apiKey;
+    const apiKey = overrideApiKey
+        || globalApiKey
+        || process.env.OPENAI_API_KEY
+        || codexSettings.apiKey;
+    if (!apiKey) {
+        throw new Error('No OpenAI API key found. Set one of: baseagents.codex.apiKey (per-agent or defaults), env OPENAI_API_KEY, or ~/.codex/auth.json');
+    }
+    const isPlaceholderUrl = (v) => !v || v.includes('api.openai.com');
+    const overrideBaseUrl = isPlaceholderUrl(override?.baseUrl) ? undefined : override?.baseUrl;
+    const globalBaseUrl = isPlaceholderUrl(config.agents?.codex?.baseUrl) ? undefined : config.agents?.codex?.baseUrl;
+    const baseUrl = overrideBaseUrl
+        || globalBaseUrl
+        || process.env.OPENAI_BASE_URL
+        || codexSettings.baseUrl
+        || undefined;
+    const model = override?.model
+        || config.agents?.codex?.model
+        || codexSettings.model
+        || 'gpt-5.2-codex';
+    const effort = override?.effort
+        || override?.reasoning
+        || config.agents?.codex?.effort
+        || config.agents?.codex?.reasoning
+        || undefined;
+    return { apiKey, baseUrl, model, effort };
+}
+export function resolveGoogleConfig(config, override) {
+    const googleCfg = config.agents?.gemini;
+    const isPlaceholder = (v) => !v || v.includes('your-') || v.includes('placeholder');
+    let cliPath = override?.cliPath || googleCfg?.cliPath || '';
+    if (!cliPath) {
+        cliPath = commandExists('gemini') ? 'gemini' : '';
+    }
+    const model = override?.model || googleCfg?.model || 'gemini-2.5-flash';
+    const overrideApiKey = isPlaceholder(override?.apiKey) ? undefined : override?.apiKey;
+    const globalApiKey = isPlaceholder(googleCfg?.apiKey) ? undefined : googleCfg?.apiKey;
+    const apiKey = overrideApiKey
+        || globalApiKey
+        || process.env.GEMINI_API_KEY
+        || process.env.GOOGLE_API_KEY
+        || undefined;
+    const mode = override?.mode || googleCfg?.mode || 'cli';
+    const useVertex = override?.useVertex ?? googleCfg?.useVertex ?? false;
+    const project = override?.project || googleCfg?.project || process.env.GOOGLE_CLOUD_PROJECT || undefined;
+    const location = override?.location || googleCfg?.location || process.env.GOOGLE_CLOUD_LOCATION || 'us-central1';
+    return { cliPath, model, apiKey, mode, useVertex, project, location };
+}

package/dist/aun/aid/agentmd.js

@@ -0,0 +1,186 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { getAunClient } from './client.js';
+export function buildInitialAgentMd(opts) {
+    const agentName = opts.aid.split('.')[0];
+    const agentType = opts.type || 'ai';
+    return `---\naid: "${opts.aid}"\nname: "${agentName}"\ntype: "${agentType}"\nversion: "1.0.0"\ndescription: ""\ntags:\n  - evolclaw\n---\n`;
+}
+/**
+ * Resolve the gateway URL for an AID via .well-known discovery.
+ */
+async function discoverGateway(aid) {
+    try {
+        const resp = await fetch(`https://${aid}/.well-known/aun-gateway`, { redirect: 'follow' });
+        if (!resp.ok)
+            return undefined;
+        const text = await resp.text();
+        try {
+            return JSON.parse(text.trim()).gateways?.[0]?.url ?? text.trim();
+        }
+        catch {
+            return text.trim();
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Obtain cert PEM for an AID: local first, then network.
+ * Persists fetched cert to local for future use.
+ */
+async function obtainCertPem(aid, aunPath, client) {
+    const localCert = path.join(aunPath, 'AIDs', aid, 'public', 'cert.pem');
+    if (fs.existsSync(localCert)) {
+        return fs.readFileSync(localCert, 'utf-8');
+    }
+    // Fetch from network via SDK's _fetchPeerCert (needs gateway)
+    if (client) {
+        try {
+            if (!client._gatewayUrl) {
+                client._gatewayUrl = await discoverGateway(aid);
+            }
+            if (client._gatewayUrl) {
+                const certPem = await client._fetchPeerCert.call(client, aid);
+                // Persist for future use
+                if (certPem) {
+                    const certDir = path.join(aunPath, 'AIDs', aid, 'public');
+                    fs.mkdirSync(certDir, { recursive: true });
+                    fs.writeFileSync(localCert, certPem, 'utf-8');
+                }
+                return certPem;
+            }
+        }
+        catch { /* fall through */ }
+    }
+    return undefined;
+}
+/**
+ * Verify agent.md content using SDK.
+ */
+async function verifyContent(content, aid, certPem, client) {
+    if (!content.includes('AUN-SIGNATURE')) {
+        return { status: 'unsigned' };
+    }
+    if (!certPem) {
+        return { status: 'invalid', reason: 'certificate not available' };
+    }
+    try {
+        const result = await client.auth.verifyAgentMd(content, { aid, certPem });
+        if (result.status === 'verified' || result.verified) {
+            return { status: 'verified' };
+        }
+        return { status: 'invalid', reason: result.reason };
+    }
+    catch (e) {
+        return { status: 'invalid', reason: `verify error: ${String(e.message || e).slice(0, 100)}` };
+    }
+}
+/**
+ * Create a bare AUNClient (no createAid) for read-only operations.
+ */
+async function createBareClient(aunPath) {
+    const { AUNClient } = await import('@agentunion/fastaun');
+    const caCertPath = path.join(aunPath, 'CA', 'root', 'root.crt');
+    const clientOpts = { aun_path: aunPath, debug: false };
+    if (fs.existsSync(caCertPath))
+        clientOpts.root_ca_path = caCertPath;
+    return new AUNClient(clientOpts);
+}
+export async function agentmdGet(aid, opts) {
+    const aunPath = opts?.aunPath ?? path.join(os.homedir(), '.aun');
+    const localPath = path.join(aunPath, 'AIDs', aid, 'agent.md');
+    // === Path A: local agent.md exists ===
+    if (fs.existsSync(localPath)) {
+        const content = fs.readFileSync(localPath, 'utf-8');
+        if (!opts?.withVerification)
+            return content;
+        // Verify local content
+        const client = opts?.client ?? await createBareClient(aunPath);
+        const ownClient = !opts?.client;
+        try {
+            const certPem = await obtainCertPem(aid, aunPath, client);
+            const verification = await verifyContent(content, aid, certPem, client);
+            if (verification.status !== 'invalid') {
+                return { content, verification };
+            }
+            // Fallback: local invalid → try remote
+            try {
+                const remote = await client.auth.downloadAgentMd(aid);
+                if (remote) {
+                    const remoteVerification = await verifyContent(remote, aid, certPem, client);
+                    if (remoteVerification.status === 'verified') {
+                        fs.writeFileSync(localPath, remote, 'utf-8');
+                        return { content: remote, verification: remoteVerification };
+                    }
+                }
+            }
+            catch { /* remote fetch failed, return local invalid result */ }
+            return { content, verification };
+        }
+        finally {
+            if (ownClient)
+                try {
+                    await client.close();
+                }
+                catch { /* ignore */ }
+        }
+    }
+    // === Path B: no local agent.md → download from remote ===
+    const client = opts?.client ?? await createBareClient(aunPath);
+    const ownClient = !opts?.client;
+    try {
+        const raw = await client.auth.downloadAgentMd(aid);
+        if (!opts?.withVerification) {
+            // Persist without verification
+            const aidDir = path.join(aunPath, 'AIDs', aid);
+            fs.mkdirSync(aidDir, { recursive: true });
+            fs.writeFileSync(path.join(aidDir, 'agent.md'), raw, 'utf-8');
+            return raw;
+        }
+        const certPem = await obtainCertPem(aid, aunPath, client);
+        const verification = await verifyContent(raw, aid, certPem, client);
+        // Persist to local
+        const aidDir = path.join(aunPath, 'AIDs', aid);
+        fs.mkdirSync(aidDir, { recursive: true });
+        fs.writeFileSync(path.join(aidDir, 'agent.md'), raw, 'utf-8');
+        return { content: raw, verification };
+    }
+    finally {
+        if (ownClient)
+            try {
+                await client.close();
+            }
+            catch { /* ignore */ }
+    }
+}
+/**
+ * Upload agent.md: auto-sign + upload + sync to local file.
+ */
+export async function agentmdPut(content, opts) {
+    const aunPath = opts.aunPath ?? path.join(os.homedir(), '.aun');
+    const client = opts.client ?? await getAunClient(opts.aid, { aunPath });
+    const ownClient = !opts.client;
+    try {
+        let signed;
+        try {
+            signed = await client.auth.signAgentMd(content);
+        }
+        catch {
+            signed = content;
+        }
+        await client.auth.uploadAgentMd(signed);
+        const aidDir = path.join(aunPath, 'AIDs', opts.aid);
+        fs.mkdirSync(aidDir, { recursive: true });
+        fs.writeFileSync(path.join(aidDir, 'agent.md'), signed, 'utf-8');
+    }
+    finally {
+        if (ownClient)
+            try {
+                await client.close();
+            }
+            catch { /* ignore */ }
+    }
+}