evolcore 0.0.29 → 0.0.30

package/dist/core/agent-ipc-registration.js

@@ -0,0 +1,409 @@
+import fs from 'fs';
+import path from 'path';
+import { loadDaemonConfig } from '../config-store.js';
+import { parseAgentWelcomeArgs, parseInitializationArgs, resolveInitializationPlan, } from '../cli/agent-create.js';
+import { trustedExecutionIdentityInput } from './auth/agent-delegation.js';
+import { authorizeOperation, buildAuthSubject } from './auth/auth-gateway.js';
+import { authorizationDenialData } from './auth/authorization-denial.js';
+import { parsePeerKey } from './relation/peer-identity.js';
+import { isHClassPath, isLClassPath, isSameOrDescendant } from './permission/protected-paths.js';
+export function registerAgentOperationExecutor({ ipcServer, sessionManager, agentDelegationRegistry, eventBus, responseEngine, handoffRuntime, agentApplicationService, agentInitializationService, }) {
+    ipcServer.setAgentOperationExecutor(async (argv, sessionId, delegationToken, delegationCommandHash) => {
+        const fail = (code, error, reasonCode) => ({
+            ok: false,
+            code,
+            error,
+            ...(reasonCode ? { data: authorizationDenialData(reasonCode) } : {}),
+        });
+        if (!Array.isArray(argv) || argv[0] !== 'agent')
+            return fail('INVALID_REQUEST', 'agent.op requires an agent command');
+        const sub = argv[1];
+        if (!sub)
+            return fail('INVALID_ARGS', 'missing agent subcommand');
+        const value = (flag) => {
+            const index = argv.indexOf(flag);
+            return index >= 0 && index + 1 < argv.length && !argv[index + 1].startsWith('--') ? argv[index + 1] : undefined;
+        };
+        const taskSession = await sessionManager.getSessionById(sessionId);
+        const delegation = agentDelegationRegistry.validate(delegationToken, sessionId, delegationCommandHash);
+        if (!delegation.ok)
+            return fail(delegation.code, delegation.reason);
+        if (!taskSession || taskSession.selfAID !== delegation.grant.selfAid) {
+            return fail('INVALID_DELEGATION', 'delegation does not match the current session');
+        }
+        const taskAid = delegation.grant.selfAid;
+        let welcomeArgs;
+        if (sub === 'welcome') {
+            try {
+                welcomeArgs = parseAgentWelcomeArgs(argv.slice(2));
+            }
+            catch (error) {
+                return fail('INVALID_ARGS', error.message);
+            }
+            if (delegation.grant.chatType !== 'private')
+                return fail('NOT_ALLOWED', 'welcome requires a private conversation');
+        }
+        const targetAid = sub === 'list'
+            ? undefined
+            : sub === 'persona'
+                ? taskAid
+                : sub === 'welcome'
+                    ? taskAid
+                    : sub === 'show'
+                        ? (argv[2] && !argv[2].startsWith('--') ? argv[2] : taskAid)
+                        : sub === 'reload'
+                            ? (argv[2] && !argv[2].startsWith('--') ? argv[2] : undefined)
+                            : (argv[2] && !argv[2].startsWith('--') ? argv[2] : undefined);
+        const operation = sub === 'list' ? 'agent.list'
+            : sub === 'show' ? 'agent.show'
+                : sub === 'persona' ? 'agent.persona'
+                    : sub === 'welcome' ? 'agent.welcome'
+                        : sub === 'initialize' || (sub === 'new' && argv.includes('--initialize')) ? 'agent.initialize'
+                            : sub === 'new' ? 'agent.create'
+                                : sub === 'enable' ? 'agent.enable'
+                                    : sub === 'disable' ? 'agent.disable'
+                                        : sub === 'reload' ? 'agent.reload'
+                                            : sub === 'delete' ? 'agent.delete' : undefined;
+        if (!operation)
+            return fail('INVALID_ARGS', `unsupported managed agent command: ${sub}`);
+        if (sub === 'new' && !argv.includes('--non-interactive') && !argv.includes('--initialize')) {
+            return fail('MANAGED_NON_INTERACTIVE_REQUIRED', 'interactive Agent creation is unavailable in a managed task', 'MANAGED_NON_INTERACTIVE_REQUIRED');
+        }
+        if (sub === 'delete' && argv.includes('--purge') && !argv.includes('--confirm-purge')) {
+            return fail('PURGE_CONFIRMATION_REQUIRED', 'agent delete --purge requires explicit --confirm-purge', 'PURGE_CONFIRMATION_REQUIRED');
+        }
+        let conversationId;
+        try {
+            conversationId = parsePeerKey(delegation.grant.peerKey).channelId;
+        }
+        catch {
+            return fail('INVALID_DELEGATION', 'delegation contains an invalid relation key');
+        }
+        const subject = buildAuthSubject({
+            selfAid: taskAid,
+            actorId: delegation.grant.actorId,
+            channel: delegation.grant.channel,
+            channelType: delegation.grant.channelType,
+            channelId: conversationId,
+            chatType: delegation.grant.chatType,
+            conversationId,
+            processOwners: loadDaemonConfig().owners ?? [],
+            ...trustedExecutionIdentityInput(delegation.grant),
+        });
+        const decision = authorizeOperation({
+            source: 'agent-tool',
+            subject,
+            intent: {
+                operation,
+                scope: operation === 'agent.show' || operation === 'agent.persona' || operation === 'agent.welcome'
+                    ? 'agent'
+                    : operation === 'agent.reload' && targetAid
+                        ? 'agent'
+                        : 'control',
+                source: 'agent-tool',
+                args: {
+                    self: taskAid,
+                    aid: targetAid ?? taskAid,
+                    taskAgentAid: taskAid,
+                    targetAgentAid: targetAid ?? taskAid,
+                    ...(welcomeArgs ? { action: welcomeArgs.action } : {}),
+                },
+            },
+            auditMetadata: { taskId: delegation.grant.taskId, messageId: delegation.grant.messageId },
+        });
+        if (!decision.allow) {
+            const reasonCode = decision.command?.reasonCode;
+            return fail(decision.code, decision.reason, reasonCode);
+        }
+        const { execAgentAction, execAgentOptions, execAgentQuery } = await import('./command/agent-control.js');
+        if (operation === 'agent.list') {
+            const result = await execAgentOptions({ options: 'all' }, agentApplicationService);
+            if ('error' in result)
+                return fail(result.code, result.error);
+            const agents = Array.isArray(result.data?.agents) ? result.data.agents.map((agent) => ({
+                aid: agent.aid,
+                name: agent.name,
+                personalName: agent.personalName ?? null,
+                status: agent.status,
+                channels: Array.isArray(agent.channels) ? agent.channels : [],
+                projectPath: null,
+                baseagent: agent.baseagent ?? null,
+                model: agent.model ?? null,
+                lastActivity: agent.lastActivity ?? null,
+            })) : [];
+            return { ok: true, result: { ok: true, agents, redacted: true } };
+        }
+        if (operation === 'agent.show') {
+            const result = await execAgentQuery({ aid: targetAid }, agentApplicationService);
+            if ('error' in result)
+                return fail(result.code, result.error);
+            const agent = result.data ?? {};
+            return { ok: true, result: {
+                    ok: true,
+                    aid: agent.aid,
+                    status: agent.status,
+                    lifecycle: agent.lifecycle ?? null,
+                    identity: agent.identity ?? { name: null, description: null },
+                    config: {
+                        baseagent: agent.config?.baseagent ?? null,
+                        model: agent.config?.model ?? null,
+                        effort: agent.config?.effort ?? null,
+                        chatmode: agent.config?.chatmode ?? null,
+                        channels: Array.isArray(agent.config?.channels) ? agent.config.channels : [],
+                    },
+                    connection: agent.connection ?? null,
+                    sessions: agent.sessions ?? { active: 0, last_activity: null },
+                    paths: subject.dataScope === 'daemon'
+                        ? (agent.paths ?? { config: null, agent_md: null, project: null, data: null })
+                        : { config: null, agent_md: null, project: null, data: null },
+                    ...(subject.dataScope === 'daemon' ? {} : { redacted: true }),
+                    ...(agent.createProgress ? { createProgress: agent.createProgress } : {}),
+                    ...(agent.initialization ? { initialization: agent.initialization } : {}),
+                } };
+        }
+        if (operation === 'agent.persona') {
+            const rawPersonaArgs = argv.slice(2);
+            const hasFormatSuffix = rawPersonaArgs.length >= 2
+                && rawPersonaArgs.at(-2) === '--format'
+                && rawPersonaArgs.at(-1) === 'json';
+            const personaArgs = hasFormatSuffix ? rawPersonaArgs.slice(0, -2) : rawPersonaArgs;
+            if (!hasFormatSuffix && rawPersonaArgs.includes('--format')) {
+                return fail('INVALID_ARGS', 'persona 仅支持末尾的 --format json');
+            }
+            if (personaArgs.length === 2 && personaArgs[0] === '--file') {
+                return fail('INVALID_ARGS', '托管 persona --file 必须由 CLI 读取后作为文本提交');
+            }
+            const wantsShow = personaArgs.length === 1 && personaArgs[0] === 'show';
+            const text = personaArgs.length === 2 && personaArgs[0] === '--text'
+                ? personaArgs[1]
+                : undefined;
+            if (!wantsShow && !(personaArgs.length === 2 && personaArgs[0] === '--text')) {
+                return fail('INVALID_ARGS', '用法: ec agent persona show | --text <text>');
+            }
+            if (text === undefined && !wantsShow)
+                return fail('INVALID_ARGS', 'persona --text 缺少参数');
+            const { agentPersona } = await import('../cli/agent.js');
+            const result = await agentPersona(taskAid, wantsShow ? { trustedLocal: true } : { text, trustedLocal: true });
+            if (!result.ok)
+                return fail(result.code ?? 'INTERNAL', result.error);
+            return { ok: true, result: {
+                    ok: true,
+                    aid: taskAid,
+                    content: result.content,
+                    ...(result.saved ? { saved: true } : {}),
+                } };
+        }
+        if (operation === 'agent.welcome') {
+            if (subject.role !== 'owner' && !(welcomeArgs?.action === 'show' && subject.role === 'admin')) {
+                return fail('NOT_ALLOWED', 'welcome requires the current Agent Owner (admin may read)');
+            }
+            const { agentWelcome } = await import('../cli/agent.js');
+            const result = await agentWelcome(taskAid, { text: welcomeArgs?.text, trustedLocal: true });
+            if (!result.ok)
+                return fail(result.code ?? 'INTERNAL', result.error);
+            return { ok: true, result: {
+                    ok: true,
+                    aid: taskAid,
+                    content: result.content,
+                    ...(result.path ? { path: result.path } : {}),
+                    ...(result.saved ? { saved: true } : {}),
+                    ...(result.bytes !== undefined ? { bytes: result.bytes } : {}),
+                    ...(result.sha256 ? { sha256: result.sha256 } : {}),
+                } };
+        }
+        if (operation === 'agent.initialize') {
+            try {
+                const parsed = parseInitializationArgs(argv.slice(1));
+                const actor = delegation.grant.actorId;
+                if (parsed.resume)
+                    return { ok: true, result: agentInitializationService.resume(parsed.aid, actor) };
+                const createPermission = authorizeOperation({
+                    source: 'agent-tool', subject,
+                    intent: { operation: 'agent.create', scope: 'control', source: 'agent-tool', args: { aid: parsed.aid } },
+                    auditMetadata: { taskId: delegation.grant.taskId, messageId: delegation.grant.messageId },
+                });
+                if (!createPermission.allow)
+                    return fail(createPermission.code, createPermission.reason);
+                if (!argv.includes('--owner') && !argv.includes('--owners'))
+                    return fail('INITIALIZE_OWNER_MISMATCH', 'Explicit Owner required');
+                const plan = resolveInitializationPlan(argv.slice(1));
+                if (plan.avatarFile?.startsWith('attachment:')) {
+                    const { readRelationAttachment } = await import('../utils/media-cache.js');
+                    plan.avatarFile = readRelationAttachment(taskAid, delegation.grant.peerKey, plan.avatarFile.slice('attachment:'.length)).attachment.filePath;
+                }
+                else if (plan.avatarFile) {
+                    const session = await sessionManager.getSessionById(sessionId);
+                    const candidate = path.resolve(plan.avatarFile);
+                    const roots = [session?.projectPath, delegation.grant.sessionRuntimeDir]
+                        .filter((root) => !!root && path.isAbsolute(root))
+                        .map(root => fs.realpathSync(root));
+                    const real = fs.realpathSync(candidate);
+                    if (!roots.some(root => isSameOrDescendant(real, root)) || isHClassPath(real) || isLClassPath(real)) {
+                        return fail('AVATAR_INVALID', '--avatar-file must be a current project/TMPDIR file or authorized relation attachment');
+                    }
+                    plan.avatarFile = real;
+                }
+                if (!plan.owners.includes(actor))
+                    return fail('INITIALIZE_OWNER_MISMATCH', 'The authenticated requesting Owner must be retained');
+                return { ok: true, result: agentInitializationService.start(plan, actor, parsed.dryRun) };
+            }
+            catch (error) {
+                return fail(error.code ?? 'INVALID_ARGS', error.message);
+            }
+        }
+        if (operation === 'agent.create') {
+            const aid = argv[2] && !argv[2].startsWith('--') ? argv[2] : undefined;
+            if (!aid)
+                return fail('INVALID_ARGS', 'ec agent new requires an AID');
+            const { agentCreateNonInteractive, resolveAgentCreatePlan, validateAgentCreatePlan, parseAgentOwnerArgs, parseAgentTags } = await import('../cli/agent-create.js');
+            let ownerOptions;
+            try {
+                ownerOptions = parseAgentOwnerArgs(argv);
+            }
+            catch (error) {
+                return fail('INVALID_ARGS', error instanceof Error ? error.message : String(error));
+            }
+            let tags;
+            try {
+                tags = parseAgentTags(value('--tags'));
+            }
+            catch (error) {
+                return fail('INVALID_ARGS', error instanceof Error ? error.message : String(error));
+            }
+            const plan = resolveAgentCreatePlan({
+                aid,
+                project: value('--project'),
+                baseagent: value('--baseagent'),
+                ...ownerOptions,
+                handoff: value('--handoff'),
+                name: value('--name'),
+                description: value('--description'),
+                type: value('--type'),
+                tags,
+                avatarFile: value('--avatar-file'),
+                avatarUrl: value('--avatar-url'),
+                force: argv.includes('--force'),
+            });
+            const validationError = validateAgentCreatePlan(plan);
+            if (validationError)
+                return fail('INVALID_ARGS', validationError);
+            if (argv.includes('--handoff')) {
+                if (!delegation.grant.messageId)
+                    return fail('INVALID_ARGS', '--handoff requires an originating message');
+                if (!plan.handoff?.trim())
+                    return fail('INVALID_ARGS', '--handoff requires non-empty context');
+                if ((plan.owners?.[0] ?? plan.owner) !== taskAid) {
+                    return fail('INVALID_ARGS', '--handoff requires the creating Agent to be the first Owner');
+                }
+                if (plan.configExists)
+                    return fail('INVALID_ARGS', '--handoff requires a new Agent');
+            }
+            if (argv.includes('--dry-run'))
+                return { ok: true, result: { ok: true, dryRun: true, plan } };
+            let handoffId;
+            if (plan.handoff) {
+                try {
+                    const created = await handoffRuntime.createOutbound({
+                        selfAid: taskAid,
+                        to: aid,
+                        originSessionId: sessionId,
+                        originMessageId: delegation.grant.messageId,
+                        payload: { type: 'text', text: plan.handoff },
+                        encrypt: true,
+                        targetChatType: 'private',
+                        explicitReturnPolicy: 'required',
+                        contextOnly: true,
+                        originAuthorization: {
+                            actorId: delegation.grant.actorId,
+                            channelKey: delegation.grant.channel,
+                            channelType: delegation.grant.channelType,
+                            chatType: delegation.grant.chatType,
+                            peerKey: delegation.grant.peerKey,
+                        },
+                        causation: responseEngine.getTaskRuntimeContext(sessionId)?.causation,
+                    });
+                    handoffId = created.handoff?.handoff_id;
+                    if (!handoffId)
+                        return fail('INVALID_ARGS', '--handoff requires a different target session');
+                }
+                catch (error) {
+                    return fail('HANDOFF_PREPARE_FAILED', error instanceof Error ? error.message : String(error));
+                }
+            }
+            const createOptions = {
+                aid: plan.aid,
+                project: plan.project,
+                baseagent: plan.baseagent,
+                owner: plan.owner,
+                owners: plan.owners,
+                name: plan.name,
+                description: plan.description,
+                type: plan.type,
+                tags: plan.tags,
+                force: argv.includes('--force'),
+                avatarFile: value('--avatar-file'),
+                avatarUrl: value('--avatar-url'),
+            };
+            if (createOptions.avatarFile) {
+                try {
+                    if (createOptions.avatarFile.startsWith('attachment:')) {
+                        const { readRelationAttachment } = await import('../utils/media-cache.js');
+                        const source = readRelationAttachment(taskAid, delegation.grant.peerKey, createOptions.avatarFile.slice('attachment:'.length));
+                        createOptions.avatarFile = source.attachment.filePath;
+                    }
+                    else {
+                        const session = await sessionManager.getSessionById(sessionId);
+                        const candidate = path.resolve(createOptions.avatarFile);
+                        const roots = [session?.projectPath, delegation.grant.sessionRuntimeDir]
+                            .filter((root) => !!root && path.isAbsolute(root))
+                            .map(root => fs.realpathSync(root));
+                        const real = fs.realpathSync(candidate);
+                        if (!roots.some(root => isSameOrDescendant(real, root)) || isHClassPath(real) || isLClassPath(real)) {
+                            return fail('AVATAR_INVALID', '--avatar-file must be a current project/TMPDIR file or authorized relation attachment');
+                        }
+                        createOptions.avatarFile = real;
+                    }
+                }
+                catch (error) {
+                    return fail('AVATAR_INVALID', error instanceof Error ? error.message : String(error));
+                }
+            }
+            try {
+                const result = agentApplicationService
+                    ? await agentApplicationService.create(createOptions)
+                    : await agentCreateNonInteractive(createOptions);
+                if (!result.ok) {
+                    if (handoffId)
+                        handoffRuntime.store.discard(taskAid, handoffId, 'operation_failed');
+                    return fail(result.code ?? 'INTERNAL', result.error);
+                }
+                return { ok: true, result: { ...result, configPath: '[redacted]', ...(handoffId ? { handoff_id: handoffId } : {}) } };
+            }
+            catch (error) {
+                if (handoffId)
+                    handoffRuntime.store.discard(taskAid, handoffId, 'operation_failed');
+                return fail('INTERNAL', error instanceof Error ? error.message : String(error));
+            }
+        }
+        if (operation === 'agent.delete') {
+            const result = agentApplicationService
+                ? await agentApplicationService.delete(targetAid ?? '', argv.includes('--purge'))
+                : await (async () => {
+                    const { agentDelete } = await import('../cli/agent.js');
+                    return await agentDelete(targetAid ?? '', argv.includes('--purge'));
+                })();
+            return 'error' in result ? fail(result.code ?? 'INTERNAL', result.error) : { ok: true, result };
+        }
+        if (operation === 'agent.reload' && !targetAid) {
+            const result = agentApplicationService
+                ? await agentApplicationService.reload()
+                : await (async () => {
+                    const { agentReload } = await import('../cli/agent.js');
+                    return await agentReload();
+                })();
+            return !result.ok ? fail(result.code ?? 'INTERNAL', result.error) : { ok: true, result };
+        }
+        const result = await execAgentAction(sub, { aid: targetAid ?? taskAid, force: argv.includes('--force') }, delegation.grant.actorId, eventBus, agentApplicationService);
+        return 'error' in result ? fail(result.code, result.error) : { ok: true, result: { ok: true, ...(result.data ?? {}) } };
+    });
+}