evolcore 0.0.25 → 0.0.27

package/dist/cli/agent.js

@@ -1,25 +1,31 @@
 import fs from 'fs';
 import path from 'path';
-import { resolvePaths, agentMdPath as getAgentMdPathFromPaths, agentPersonalDir, aunPath as defaultAunPath } from '../paths.js';
+import { SESSION_ID_ENV } from '../product.js';
+import { resolvePaths, agentMdPath as getAgentMdPathFromPaths, agentPersonalDir, agentWelcomePath, aunPath as defaultAunPath } from '../paths.js';
 import { loadDefaults, loadAllAgents, loadAgent, saveAgent, ensureAgentDirSkeleton } from '../config-store.js';
 import { initConfigManager } from '../config/config-manager.js';
 import { resolveConfigCommand } from '../config/resolved-config-op.js';
-import { executeResolvedConfigCommand } from '../config/config-operation-service.js';
+import { executeResolvedConfigCommandAsync } from '../config/config-operation-service.js';
 import { ipcQuery, IpcTransportError } from '../ipc.js';
 import { CONFIG_SCHEMA_VERSION } from '../types.js';
 import { ensureInitialRoleRegistry } from '../config/role-service.js';
 import { agentProjectRootFromDefaults, deriveAgentProjectPath } from '../utils/project-path.js';
 import { isValidChannelName } from '../core/channel-loader.js';
-import { AGENT_DELEGATION_TOKEN_ENV } from '../core/auth/agent-delegation.js';
+import { AGENT_DELEGATION_TOKEN_ENV, readDelegationCredential } from '../core/auth/agent-delegation.js';
 import { readTaskRuntimeContextFromEnv } from './task-context.js';
+import { isValidAid } from '../aun/aid/validation.js';
 import { isHClassPath, isLClassPath, isSameOrDescendant } from '../core/permission/protected-paths.js';
+import { findPostBootstrapWelcomeOutbox } from '../core/bootstrap-messages.js';
+import { resolveAgentLifecycle } from '../config/lifecycle.js';
+import { initializationSummary } from './agent-create.js';
+import { parseAgentWelcomeMetadata, readAgentWelcomeTemplate, renderPostBootstrapWelcomeMessage, saveAgentWelcomeTemplate, validateWelcomeTemplate } from '../utils/welcome.js';
 export { agentCreateInteractive, agentCreateNonInteractive, parseAgentOwnerArgs, resolveAgentCreatePlan, validateAgentCreatePlan, validateAgentOwnerOptions, } from './agent-create.js';
 /** Route agent lifecycle commands from a managed task through daemon IPC. */
 export async function runManagedAgentOperation(argv) {
     const sessionId = process.env.EVOLCORE_SESSION_ID;
     if (!sessionId)
         return { ok: false, code: 'MANAGED_ONLY', error: 'agent operation is not running in a managed task' };
-    const delegationToken = process.env[AGENT_DELEGATION_TOKEN_ENV];
+    const delegationToken = readDelegationCredential();
     if (!delegationToken) {
         return { ok: false, code: 'DELEGATION_REQUIRED', error: `${AGENT_DELEGATION_TOKEN_ENV} is not set for the active task` };
     }
@@ -74,6 +80,7 @@ function toAgentListItem(info, stale = false) {
         name: info.name,
         personalName: info.personalName || null,
         status: stale && storedStatus !== 'disabled' && storedStatus !== 'error' ? 'unknown' : storedStatus,
+        lifecycle: info.lifecycle ?? null,
         channels: info.channels || [],
         projectPath: toPosix(info.projectPath || null),
         baseagent: info.baseagent || null,
@@ -158,6 +165,27 @@ export async function agentShow(aid) {
         registry.loadAll();
         const agent = registry.get(aid);
         if (!agent) {
+            const init = initializationSummary(aid);
+            if (init) {
+                return {
+                    ok: true,
+                    aid,
+                    status: 'initializing',
+                    lifecycle: loadAgent(aid)?.lifecycle ?? null,
+                    identity: { name: null, description: null },
+                    config: { baseagent: null, model: null, effort: null, chatmode: null, channels: [] },
+                    connection: null,
+                    sessions: { active: 0, last_activity: null },
+                    paths: {
+                        config: toPosix(path.join(p.agentsDir, aid, 'config.json')),
+                        agent_md: toPosix(getAgentMdPath(aid)),
+                        project: null,
+                        data: toPosix(path.join(p.agentsDir, aid, 'data')),
+                    },
+                    initialization: init,
+                    stale: true,
+                };
+            }
             const allList = registry.list();
             const available = allList.map((i) => i.name).join(', ');
             return { ok: false, error: `Agent "${aid}" not found.${available ? ` Available: ${available}` : ''}` };
@@ -183,6 +211,7 @@ export async function agentShow(aid) {
         ok: true,
         aid,
         status: agentInfo.status || 'unknown',
+        lifecycle: loadAgent(aid)?.lifecycle ?? null,
         identity,
         config: {
             baseagent: agentInfo.baseagent || null,
@@ -202,6 +231,7 @@ export async function agentShow(aid) {
             project: toPosix(agentInfo.projectPath || null),
             data: toPosix(path.join(p.agentsDir, aid, 'data')),
         },
+        ...(initializationSummary(aid) ? { initialization: initializationSummary(aid) } : {}),
         ...(stale ? { stale: true } : {}),
     };
 }
@@ -361,7 +391,7 @@ async function runManagedAgentConfig(args, options) {
     const sessionId = process.env.EVOLCORE_SESSION_ID;
     if (!sessionId || options.trustedLocal)
         return { managed: false };
-    const delegationToken = process.env[AGENT_DELEGATION_TOKEN_ENV];
+    const delegationToken = readDelegationCredential();
     if (!delegationToken) {
         return {
             managed: true,
@@ -390,12 +420,22 @@ async function runManagedAgentConfig(args, options) {
         return { managed: true, error: { ok: false, code: 'DAEMON_UNAVAILABLE', error: 'Unable to connect to the evolcore daemon' } };
     }
 }
-function executeLocalAgentConfig(args) {
+async function executeLocalAgentConfig(args) {
     initConfigManager();
     const resolved = resolveConfigCommand(['config', ...args]);
     if (!resolved.ok)
         return { ok: false, code: resolved.code, error: resolved.reason };
-    return executeResolvedConfigCommand(resolved.command);
+    return executeResolvedConfigCommandAsync(resolved.command, {
+        role: 'owner',
+        roleContext: {
+            self: resolved.command.self || '',
+            actorRole: 'owner',
+            actorRoleSource: 'local-cli',
+            isDaemonOwner: false,
+            fromControlChannel: false,
+            aunAvailable: true,
+        },
+    });
 }
 export async function agentGet(aid, key, options = {}) {
     const managed = await runManagedAgentConfig(['get', key, '--self', aid], options);
@@ -412,7 +452,7 @@ export async function agentGet(aid, key, options = {}) {
         return { ok: false, error: `Agent "${aid}" not found` };
     }
     try {
-        const result = executeLocalAgentConfig(['get', key, '--self', aid]);
+        const result = await executeLocalAgentConfig(['get', key, '--self', aid]);
         return result.ok && result.subcommand === 'get'
             ? { ok: true, aid, key, value: result.value }
             : { ok: false, code: result.ok ? 'UNEXPECTED_RESULT' : result.code, error: result.ok ? 'config get returned an unexpected result' : result.error };
@@ -438,7 +478,7 @@ export async function agentSet(aid, key, rawValue, options = {}) {
     }
     let value;
     try {
-        const result = executeLocalAgentConfig(['set', key, rawValue, '--self', aid]);
+        const result = await executeLocalAgentConfig(['set', key, rawValue, '--self', aid]);
         if (!result.ok)
             return { ok: false, code: result.code, error: result.error };
         if (result.subcommand !== 'set')
@@ -458,7 +498,7 @@ export async function agentSet(aid, key, rawValue, options = {}) {
     return { ok: true, aid, key, value, reloaded };
 }
 export const AGENT_PERSONA_MAX_BYTES = 64 * 1024;
-function validatePersonaContent(content) {
+export function validatePersonaContent(content) {
     if (content.includes('\0'))
         return 'persona 只能包含文本内容';
     if (Buffer.byteLength(content, 'utf8') > AGENT_PERSONA_MAX_BYTES) {
@@ -558,6 +598,78 @@ export async function agentPersona(aid, options = {}) {
         return { ok: false, code: 'WRITE_FAILED', error: e?.message || String(e) };
     }
 }
+/** Read or replace the current Agent's confirmed Bootstrap welcome template. */
+export async function agentWelcome(aid, options = {}) {
+    if (!isValidAid(aid))
+        return { ok: false, code: 'INVALID_ARGS', error: 'Invalid Agent AID' };
+    if (options.text !== undefined) {
+        const validation = validateWelcomeTemplate(options.text);
+        if (!validation.valid)
+            return { ok: false, code: 'INVALID_ARGS', error: validation.errors.join('; ') };
+    }
+    const managedSession = !!process.env[SESSION_ID_ENV] && !options.trustedLocal;
+    const managedArgs = options.text !== undefined
+        ? ['welcome', '--text', options.text]
+        : ['welcome', 'show'];
+    if (managedSession) {
+        if (readTaskRuntimeContextFromEnv()?.selfAid !== aid) {
+            return { ok: false, code: 'SELF_AGENT_REQUIRED', error: 'welcome only targets the current Agent' };
+        }
+        const managed = await runManagedAgentOperation(managedArgs);
+        if (!managed.ok)
+            return managed;
+        return {
+            ok: true,
+            aid,
+            content: managed.content ?? null,
+            ...(managed.path ? { path: managed.path } : {}),
+            ...(managed.saved ? { saved: true } : {}),
+            ...(managed.bytes !== undefined ? { bytes: managed.bytes } : {}),
+            ...(managed.sha256 ? { sha256: managed.sha256 } : {}),
+        };
+    }
+    const config = loadAgent(aid);
+    if (!config)
+        return { ok: false, code: 'NOT_FOUND', error: 'Agent not found' };
+    if (options.text === undefined) {
+        try {
+            return { ok: true, aid, content: readAgentWelcomeTemplate(aid), path: agentWelcomePath(aid) };
+        }
+        catch (e) {
+            return { ok: false, code: 'READ_FAILED', error: e instanceof Error ? e.message : String(e) };
+        }
+    }
+    if (resolveAgentLifecycle(config) !== 'bootstrapping' || config.initialization) {
+        return { ok: false, code: 'INVALID_LIFECYCLE', error: 'welcome can only be saved during conversational Bootstrap' };
+    }
+    try {
+        if (findPostBootstrapWelcomeOutbox(aid, { includeTerminal: true }).length) {
+            if (readAgentWelcomeTemplate(aid) === options.text) {
+                return { ok: true, aid, content: options.text, saved: true, path: agentWelcomePath(aid), bytes: Buffer.byteLength(options.text, 'utf8') };
+            }
+            return { ok: false, code: 'WELCOME_FROZEN', error: 'welcome delivery has already been prepared; resume ready with the saved text' };
+        }
+        const mdPath = getAgentMdPath(aid);
+        const metadata = parseAgentWelcomeMetadata(fs.existsSync(mdPath) ? fs.readFileSync(mdPath, 'utf8') : '');
+        try {
+            for (const owner of config.owners?.length ? config.owners : [aid]) {
+                renderPostBootstrapWelcomeMessage({
+                    template: options.text, agentName: metadata.name || aid.split('.')[0], agentAid: aid,
+                    agentDescription: metadata.description, agentTags: metadata.tags,
+                    ownerAid: owner, ownerName: owner.split('.')[0],
+                });
+            }
+        }
+        catch (error) {
+            return { ok: false, code: 'WELCOME_INVALID', error: error.message };
+        }
+        const saved = saveAgentWelcomeTemplate(aid, options.text);
+        return { ok: true, aid, content: options.text, ...saved, saved: true };
+    }
+    catch (e) {
+        return { ok: false, code: 'WRITE_FAILED', error: e instanceof Error ? e.message : String(e) };
+    }
+}
 /**
  * Add or overwrite a channel instance on a per-agent config.
  *
@@ -693,7 +805,7 @@ export async function agentReady(aid) {
     }
     const p = resolvePaths();
     try {
-        const delegationToken = managedSessionId ? process.env[AGENT_DELEGATION_TOKEN_ENV] : undefined;
+        const delegationToken = managedSessionId ? readDelegationCredential() : undefined;
         if (managedSessionId && !delegationToken) {
             return { ok: false, code: 'DELEGATION_REQUIRED', error: `${AGENT_DELEGATION_TOKEN_ENV} is not set for the active task` };
         }
@@ -703,11 +815,11 @@ export async function agentReady(aid) {
             ...(managedSessionId ? { sessionId: managedSessionId, delegationToken } : {}),
         }, 30_000);
         if (!result)
-            return { ok: false, code: 'DAEMON_UNAVAILABLE', error: 'Unable to connect to the evolcore daemon; agent ready requires daemon IPC' };
+            return { ok: false, code: 'DAEMON_UNAVAILABLE', error: 'Unable to connect to the EvolCore daemon; agent ready requires daemon IPC' };
         if (!result.ok) {
             return { ok: false, code: result.code, error: result.error || 'Failed to complete bootstrap' };
         }
-        return { ok: true, aid, reloaded: true };
+        return { ...result, ok: true, aid, reloaded: result.reloaded === true };
     }
     catch (e) {
         return {