evolcore 0.0.1 → 0.0.3

package/dist/core/baseagent-loader.js

@@ -0,0 +1,54 @@
+/**
+ * Agent Plugin System
+ *
+ * Per-EvolAgent runner instantiation: each (EvolAgent × baseagent) gets its
+ * own runner so that runtime state (model/effort/permissionMode/credentials)
+ * is fully isolated.
+ */
+import { logger } from '../utils/logger.js';
+/** Agent Loader — produces one runner per (EvolAgent × baseagent). */
+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}`);
+    }
+    /**
+     * Iterate over all EvolAgents in the registry × all registered plugins.
+     * Each successful (agent, plugin) pair yields one runner instance.
+     */
+    createAll(registry, callbacks) {
+        const instances = [];
+        const allAgents = registry.runnableAgents();
+        for (const agent of allAgents) {
+            instances.push(...this.createForAgent(agent, callbacks));
+        }
+        return instances;
+    }
+    /** Create runners for one EvolAgent, used by runtime hot-load. */
+    createForAgent(agent, callbacks) {
+        const instances = [];
+        for (const [pluginName, plugin] of this.plugins) {
+            if (!plugin.isEnabled(agent)) {
+                logger.debug(`Plugin '${pluginName}' disabled for agent '${agent.name}', skipping`);
+                continue;
+            }
+            try {
+                const instance = plugin.createAgent(agent, callbacks);
+                if (!instance) {
+                    logger.debug(`Plugin '${pluginName}' returned null for agent '${agent.name}', skipping`);
+                    continue;
+                }
+                instances.push(instance);
+                logger.info(`✓ Runner created: agent=${instance.evolagentName} baseagent=${instance.baseagent}`);
+            }
+            catch (error) {
+                logger.error(`✗ Failed to create runner for agent='${agent.name}' baseagent='${pluginName}':`, error);
+            }
+        }
+        return instances;
+    }
+}

package/dist/core/bootstrap-service.js

@@ -0,0 +1,175 @@
+import fs from 'fs';
+import path from 'path';
+import { randomBytes } from 'crypto';
+import { kitsTemplatesDir, agentMdPath } from '../paths.js';
+import { logger } from '../utils/logger.js';
+import { loadAgent, saveAgent } from '../config-store.js';
+import { normalizeAgentLifecycle, withLifecycleForWrite } from '../config/lifecycle.js';
+import { renderTemplate } from '../eck/manifest-engine.js';
+import { activeBaseagent } from './model/config-scope.js';
+import { buildEnvelope } from './message/message-utils.js';
+export class BootstrapService {
+    agentRegistry;
+    eventBus;
+    inFlight = new Set();
+    constructor(agentRegistry, eventBus) {
+        this.agentRegistry = agentRegistry;
+        this.eventBus = eventBus;
+    }
+    async tryStartBootstrap(ctx) {
+        const agent = ctx.agentAid
+            ? this.agentRegistry.get(ctx.agentAid)
+            : this.agentRegistry.resolveByChannel(ctx.channelKey);
+        const aid = agent?.aid || ctx.agentAid;
+        if (!aid)
+            return false;
+        const key = aid;
+        if (this.inFlight.has(key))
+            return false;
+        this.inFlight.add(key);
+        let lifecycleStarted = false;
+        const loadedConfig = agent?.config || loadAgent(aid);
+        if (!loadedConfig) {
+            this.inFlight.delete(key);
+            return false;
+        }
+        const config = normalizeAgentLifecycle(loadedConfig);
+        if (config.lifecycle !== 'created') {
+            this.inFlight.delete(key);
+            return false;
+        }
+        const channelType = ctx.channelType || this.channelTypeFromKey(ctx.channelKey);
+        const recipientId = ctx.recipientId || this.resolveConfiguredRecipient(config, ctx.channelKey, channelType);
+        if (!recipientId) {
+            this.inFlight.delete(key);
+            return false;
+        }
+        if (ctx.recipientId && recipientId !== ctx.recipientId) {
+            this.inFlight.delete(key);
+            return false;
+        }
+        const channelId = ctx.channelId || this.defaultChannelIdForConnection(channelType, recipientId);
+        if (!channelId) {
+            this.inFlight.delete(key);
+            return false;
+        }
+        try {
+            const agentName = this.resolveAgentDisplayName(aid);
+            const baseagent = this.resolveBaseagent(agent, aid);
+            await this.publishAgentMdIfSupported(ctx.adapter, aid, agentName);
+            this.setLifecycle(agent, aid, 'bootstrapping');
+            lifecycleStarted = true;
+            const text = this.renderWelcome({
+                agentAid: aid,
+                agentName,
+                ownerName: ctx.recipientName || recipientId,
+                channel: channelType || ctx.channelKey,
+                baseagent,
+            });
+            await ctx.adapter.send(buildEnvelope({
+                taskId: `bootstrap-${randomBytes(5).toString('hex')}`,
+                channel: ctx.adapter.channelKey || ctx.adapter.channelName,
+                channelId,
+                agentName: aid,
+            }), { kind: 'result.text', text, isFinal: true });
+            this.eventBus.publish({ type: 'agent:bootstrap-started', aid, channel: channelType || ctx.channelKey, timestamp: Date.now() });
+            await this.sendAunBindingCredentialIfSupported(ctx.adapter, recipientId, agentName, baseagent);
+            logger.info(`[Bootstrap] Started for ${aid} via ${ctx.channelKey} (${ctx.source})`);
+            return true;
+        }
+        catch (e) {
+            if (lifecycleStarted) {
+                try {
+                    this.setLifecycle(agent, aid, 'created');
+                }
+                catch (rollbackErr) {
+                    logger.warn(`[Bootstrap] Failed to roll back lifecycle for ${aid}: ${rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr)}`);
+                }
+            }
+            logger.warn(`[Bootstrap] Failed to start for ${aid} via ${ctx.channelKey}: ${e instanceof Error ? e.message : String(e)}`);
+            return false;
+        }
+        finally {
+            this.inFlight.delete(key);
+        }
+    }
+    setLifecycle(agent, aid, lifecycle) {
+        if (agent?.setLifecycle) {
+            agent.setLifecycle(lifecycle);
+            return;
+        }
+        const cfg = loadAgent(aid);
+        if (!cfg)
+            return;
+        saveAgent(withLifecycleForWrite(cfg, lifecycle));
+    }
+    resolveConfiguredRecipient(config, _channelKey, _channelType) {
+        return config.owners?.[0];
+    }
+    defaultChannelIdForConnection(channelType, recipientId) {
+        if (channelType === 'aun')
+            return recipientId;
+        if (channelType === 'feishu')
+            return recipientId;
+        return undefined;
+    }
+    channelTypeFromKey(channelKey) {
+        return this.parseChannelKey(channelKey)?.type;
+    }
+    parseChannelKey(channelKey) {
+        const parts = channelKey.split('#');
+        if (parts.length < 3)
+            return null;
+        return { type: parts[0], name: parts.slice(2).join('#') };
+    }
+    renderWelcome(vars) {
+        const templatePath = path.join(kitsTemplatesDir(), 'bootstrap-welcome.md');
+        const template = fs.existsSync(templatePath)
+            ? fs.readFileSync(templatePath, 'utf-8')
+            : '你好，我是 {{agentName}}。请帮我确认显示名、简介和标签。';
+        return renderTemplate(template, vars).trim();
+    }
+    resolveAgentDisplayName(aid) {
+        try {
+            const content = fs.readFileSync(agentMdPath(aid), 'utf-8');
+            const fm = content.match(/^---\n([\s\S]*?)\n---/)?.[1] || '';
+            const name = fm.match(/^name:\s*["']?(.+?)["']?\s*$/m)?.[1]?.trim();
+            if (name)
+                return name;
+        }
+        catch { }
+        return aid.split('.')[0];
+    }
+    resolveBaseagent(agent, aid) {
+        try {
+            return agent?.baseagent || activeBaseagent(aid);
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    async publishAgentMdIfSupported(adapter, aid, fallbackName) {
+        if (typeof adapter.uploadAgentMd !== 'function')
+            return;
+        const existing = fs.existsSync(agentMdPath(aid)) ? fs.readFileSync(agentMdPath(aid), 'utf-8') : '';
+        const content = existing.trim() || `---\naid: "${aid}"\nname: "${fallbackName}"\ntype: "codeagent"\nversion: "1.0.0"\ndescription: ""\ntags:\n  - evolcore\n  - ai-agent\n---\n`;
+        try {
+            await adapter.uploadAgentMd(content);
+            logger.info(`[Bootstrap] Published agent.md for ${aid}`);
+        }
+        catch (e) {
+            logger.warn(`[Bootstrap] Failed to publish agent.md for ${aid}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    async sendAunBindingCredentialIfSupported(adapter, owner, name, baseagent) {
+        const sendBinding = adapter._sendBindingCredential;
+        if (typeof sendBinding !== 'function')
+            return;
+        try {
+            await sendBinding(owner, name, baseagent);
+        }
+        catch (e) {
+            logger.warn(`[Bootstrap] Binding credential failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+}

package/dist/core/capability/capability-manager.js

@@ -0,0 +1,316 @@
+import { ConfigTarget, read, write } from '../../config/config-manager.js';
+import { ClaudeCapabilityProvider } from './providers/claude-capability-provider.js';
+import { CodexCapabilityProvider } from './providers/codex-capability-provider.js';
+import { GeminiCapabilityProvider } from './providers/gemini-capability-provider.js';
+import { CAPABILITY_TYPES, isCapabilityType, normalizeCapabilityTypeConfig, resolveCapabilityEnabled, } from './types.js';
+const PROVIDERS = {
+    claude: new ClaudeCapabilityProvider(),
+    codex: new CodexCapabilityProvider(),
+    gemini: new GeminiCapabilityProvider(),
+};
+export { CAPABILITY_TYPES, isCapabilityType, resolveCapabilityEnabled };
+function defaultTypeConfig() {
+    return { mode: 'inherit', overrides: {} };
+}
+function resolveBaseagent(input) {
+    return input.baseagent
+        || input.sessionBaseagent
+        || input.config?.active_baseagent
+        || 'claude';
+}
+export function resolveCapabilityContext(input) {
+    const aid = input.aid || input.config?.aid;
+    if (!aid)
+        return { error: '当前 channel 无绑定 agent', code: 'FORBIDDEN' };
+    const projectPath = input.config?.projects?.defaultPath || input.projectPath || input.sessionProjectPath || null;
+    if (!projectPath)
+        return { error: '无法解析当前 agent projectPath', code: 'NO_PROJECT' };
+    return {
+        aid,
+        baseagent: resolveBaseagent(input),
+        projectPath,
+    };
+}
+export function getProvider(baseagent) {
+    return PROVIDERS[baseagent] ?? {
+        baseagent,
+        getSupport: () => ({ mode: 'inherit', canUpdate: false, reason: `baseagent ${baseagent} 尚未支持 capability 管理` }),
+        discover: async () => [],
+    };
+}
+export function getAgentCapabilityConfig(config, baseagent, type) {
+    const root = (config?.capabilities ?? {});
+    return normalizeCapabilityTypeConfig(root[baseagent]?.[type]);
+}
+export function queryCapabilityTypes(ctx, config, onlyType) {
+    const provider = getProvider(ctx.baseagent);
+    const types = onlyType ? [onlyType] : [...CAPABILITY_TYPES];
+    const capabilities = {};
+    for (const type of types) {
+        const policy = getAgentCapabilityConfig(config, ctx.baseagent, type);
+        const support = provider.getSupport(type);
+        capabilities[type] = { ...support, mode: policy.mode };
+    }
+    return {
+        scope: 'project',
+        projectPath: ctx.projectPath,
+        baseagent: ctx.baseagent,
+        capabilities,
+    };
+}
+export async function listCapabilityOptions(ctx, config, type) {
+    const provider = getProvider(ctx.baseagent);
+    const policy = getAgentCapabilityConfig(config, ctx.baseagent, type);
+    const discovered = await provider.discover(ctx, type);
+    return discovered
+        .map(item => ({
+        value: item.id,
+        label: item.label || item.id,
+        desc: item.desc,
+        source: item.source ?? 'unknown',
+        status: item.status,
+        enabled: resolveCapabilityEnabled(policy, item.id),
+        override: policy.overrides[item.id] ?? null,
+        runtimeEnabled: item.runtimeEnabled,
+    }))
+        .sort((a, b) => a.label.localeCompare(b.label));
+}
+function ensureMutableCapabilityConfig(config, baseagent, type) {
+    const root = (config.capabilities ??= {});
+    const base = (root[baseagent] ??= {});
+    const current = normalizeCapabilityTypeConfig(base[type]);
+    base[type] = current;
+    return current;
+}
+export function updateCapabilityPolicy(aid, baseagent, type, value, name) {
+    const provider = getProvider(baseagent);
+    const support = provider.getSupport(type);
+    if (!support.canUpdate) {
+        throw Object.assign(new Error(support.reason || '当前 baseagent 不支持 capability 更新'), { code: 'NOT_SUPPORTED' });
+    }
+    const sel = { self: aid };
+    const config = read(ConfigTarget.Agent, sel) ?? { aid, channels: [] };
+    const target = ensureMutableCapabilityConfig(config, baseagent, type);
+    if (name) {
+        if (value !== 'enabled' && value !== 'disabled' && value !== 'inherit') {
+            throw Object.assign(new Error('单项级 value 只能是 enabled / disabled / inherit'), { code: 'INVALID_ARGS' });
+        }
+        if (value === 'inherit')
+            delete target.overrides[name];
+        else
+            target.overrides[name] = value;
+        write(ConfigTarget.Agent, config, sel);
+        return { type, name, override: value === 'inherit' ? null : value, saved: true };
+    }
+    if (value !== 'inherit' && value !== 'all' && value !== 'none') {
+        throw Object.assign(new Error('类型级 value 只能是 inherit / all / none'), { code: 'INVALID_ARGS' });
+    }
+    target.mode = value;
+    write(ConfigTarget.Agent, config, sel);
+    return { type, mode: value, saved: true };
+}
+function mergeJsonObject(target, source) {
+    for (const [key, value] of Object.entries(source)) {
+        const current = target[key];
+        if (value
+            && typeof value === 'object'
+            && !Array.isArray(value)
+            && current
+            && typeof current === 'object'
+            && !Array.isArray(current)) {
+            target[key] = mergeJsonObject({ ...current }, value);
+        }
+        else {
+            target[key] = value;
+        }
+    }
+    return target;
+}
+function resolveCapabilityIds(policy, catalog) {
+    const ids = new Set();
+    if (policy.mode === 'all') {
+        for (const item of catalog)
+            ids.add(item.id);
+    }
+    else if (policy.mode === 'none') {
+        for (const [id, override] of Object.entries(policy.overrides)) {
+            if (override === 'enabled')
+                ids.add(id);
+        }
+        return [...ids];
+    }
+    else {
+        for (const item of catalog)
+            ids.add(item.id);
+    }
+    for (const [id, override] of Object.entries(policy.overrides)) {
+        if (override === 'enabled')
+            ids.add(id);
+        else
+            ids.delete(id);
+    }
+    if (policy.mode === 'inherit' && Object.keys(policy.overrides).length === 0)
+        return null;
+    return [...ids];
+}
+async function discoverCatalogForPolicy(provider, ctx, config, baseagent) {
+    const catalog = {};
+    for (const type of CAPABILITY_TYPES) {
+        const policy = getAgentCapabilityConfig(config, baseagent, type);
+        if (policy.mode !== 'inherit' || Object.keys(policy.overrides).length > 0) {
+            try {
+                catalog[type] = await provider.discover(ctx, type);
+            }
+            catch {
+                catalog[type] = [];
+            }
+        }
+    }
+    return catalog;
+}
+export async function resolveClaudeCapabilityRunOptionsForProject(config, projectPath, baseagent = 'claude') {
+    const provider = getProvider(baseagent);
+    const ctx = { aid: config?.aid ?? '', baseagent, projectPath };
+    const catalog = {};
+    for (const type of CAPABILITY_TYPES) {
+        const policy = getAgentCapabilityConfig(config, baseagent, type);
+        if (policy.mode !== 'inherit' || Object.keys(policy.overrides).length > 0) {
+            try {
+                catalog[type] = await provider.discover(ctx, type);
+            }
+            catch {
+                catalog[type] = [];
+            }
+        }
+    }
+    return resolveClaudeCapabilityRunOptions(config, baseagent, catalog);
+}
+export function resolveClaudeCapabilityRunOptions(config, baseagent = 'claude', catalog = {}) {
+    const skill = getAgentCapabilityConfig(config, baseagent, 'skill');
+    const mcp = getAgentCapabilityConfig(config, baseagent, 'mcp');
+    const plugin = getAgentCapabilityConfig(config, baseagent, 'plugin');
+    const options = {};
+    const settings = {};
+    const enabledSkills = Object.entries(skill.overrides).filter(([, v]) => v === 'enabled').map(([id]) => id);
+    if (skill.mode === 'all') {
+        options.skills = 'all';
+    }
+    else if (skill.mode === 'none') {
+        options.skills = enabledSkills;
+    }
+    const skillOverrides = {};
+    for (const [id, value] of Object.entries(skill.overrides)) {
+        skillOverrides[id] = value === 'enabled' ? 'on' : 'off';
+    }
+    if (Object.keys(skillOverrides).length > 0)
+        settings.skillOverrides = skillOverrides;
+    const mcpCatalog = catalog.mcp ?? [];
+    const selectedMcpIds = resolveCapabilityIds(mcp, mcpCatalog);
+    const mcpServers = {};
+    const deniedMcpServerIds = new Set();
+    for (const [id, override] of Object.entries(mcp.overrides)) {
+        if (override === 'disabled')
+            deniedMcpServerIds.add(id);
+    }
+    for (const item of mcpCatalog) {
+        const enabled = selectedMcpIds === null
+            ? item.runtimeEnabled !== false
+            : selectedMcpIds.includes(item.id);
+        if (!enabled) {
+            deniedMcpServerIds.add(item.id);
+            continue;
+        }
+        if (!item.data || typeof item.data !== 'object' || Array.isArray(item.data))
+            continue;
+        mcpServers[item.id] = { ...item.data };
+    }
+    if (Object.keys(mcpServers).length > 0)
+        options.mcpServers = mcpServers;
+    if (mcp.mode === 'none') {
+        settings.allowedMcpServers = Object.entries(mcp.overrides)
+            .filter(([, override]) => override === 'enabled')
+            .map(([serverName]) => ({ serverName }));
+    }
+    if (deniedMcpServerIds.size > 0) {
+        settings.deniedMcpServers = [...deniedMcpServerIds].map(serverName => ({ serverName }));
+    }
+    const enabledPlugins = {};
+    if (plugin.mode === 'all') {
+        for (const item of catalog.plugin ?? []) {
+            enabledPlugins[item.id] = true;
+        }
+    }
+    if (plugin.mode === 'none') {
+        for (const item of catalog.plugin ?? []) {
+            enabledPlugins[item.id] = false;
+        }
+    }
+    for (const [id, value] of Object.entries(plugin.overrides)) {
+        enabledPlugins[id] = value === 'enabled';
+    }
+    if (Object.keys(enabledPlugins).length > 0)
+        settings.enabledPlugins = enabledPlugins;
+    if (Object.keys(settings).length > 0)
+        options.settings = settings;
+    return options;
+}
+export async function resolveCodexCapabilityThreadConfigForProject(config, projectPath, baseagent = 'codex') {
+    const provider = getProvider(baseagent);
+    const ctx = { aid: config?.aid ?? '', baseagent, projectPath };
+    const catalog = await discoverCatalogForPolicy(provider, ctx, config, baseagent);
+    return resolveCodexCapabilityThreadConfig(config, baseagent, catalog);
+}
+export function resolveCodexCapabilityThreadConfig(config, baseagent = 'codex', catalog = {}) {
+    const out = {};
+    const skill = getAgentCapabilityConfig(config, baseagent, 'skill');
+    const mcp = getAgentCapabilityConfig(config, baseagent, 'mcp');
+    const plugin = getAgentCapabilityConfig(config, baseagent, 'plugin');
+    const skillEntries = [];
+    const skillCatalog = catalog.skill ?? [];
+    if (skill.mode === 'none') {
+        for (const item of skillCatalog)
+            skillEntries.push({ name: item.id, enabled: false });
+    }
+    for (const [name, override] of Object.entries(skill.overrides)) {
+        const existing = skillEntries.find(entry => entry.name === name);
+        if (existing)
+            existing.enabled = override === 'enabled';
+        else
+            skillEntries.push({ name, enabled: override === 'enabled' });
+    }
+    if (skillEntries.length > 0) {
+        mergeJsonObject(out, { skills: { config: skillEntries } });
+    }
+    const mcpCatalog = catalog.mcp ?? [];
+    const selectedMcpIds = resolveCapabilityIds(mcp, mcpCatalog);
+    if (selectedMcpIds) {
+        const entries = Object.fromEntries(mcpCatalog
+            .filter(item => item.data && typeof item.data === 'object' && !Array.isArray(item.data))
+            .map(item => [item.id, {
+                ...item.data,
+                enabled: selectedMcpIds.includes(item.id),
+            }]));
+        for (const [id, override] of Object.entries(mcp.overrides)) {
+            if (override === 'disabled' && !(id in entries))
+                entries[id] = { enabled: false };
+        }
+        mergeJsonObject(out, { mcp_servers: entries });
+    }
+    const pluginCatalog = catalog.plugin ?? [];
+    const pluginConfig = {};
+    if (plugin.mode === 'all') {
+        for (const item of pluginCatalog)
+            pluginConfig[item.id] = { enabled: true };
+    }
+    else if (plugin.mode === 'none') {
+        for (const item of pluginCatalog)
+            pluginConfig[item.id] = { enabled: false };
+    }
+    for (const [id, override] of Object.entries(plugin.overrides)) {
+        pluginConfig[id] = { enabled: override === 'enabled' };
+    }
+    if (Object.keys(pluginConfig).length > 0) {
+        mergeJsonObject(out, { plugins: pluginConfig });
+    }
+    return out;
+}