evolcore 0.0.29 → 0.0.30

package/dist/core/ipc-registration.js

@@ -0,0 +1,457 @@
+import { TriggerDefinitionManager } from '../trigger/manager.js';
+import { logger } from '../utils/logger.js';
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { executeTaskResume } from './task/task-resume-operation.js';
+import { isHClassPath, isSameOrDescendant } from './permission/protected-paths.js';
+import { computeBuildId } from '../utils/evolcore-version.js';
+import { loadAgent } from '../config-store.js';
+import { executeLocalInitializationCommand, hasSuppliedInitialization } from '../cli/agent-create.js';
+import { remoteAccessService } from './auth/remote-access-store.js';
+import { createDelegationAuthorizer } from './auth/delegation-authorization.js';
+import { executeDiagIpc } from './command/diag-service.js';
+import { registerAgentOperationExecutor } from './agent-ipc-registration.js';
+import { registerHandoffIpc } from './handoff/ipc-registration.js';
+import { registerAunIpcSender } from './message/aun-ipc-sender.js';
+import { registerConsolidationCheckExecutor, registerConsolidationLaunchExecutor, } from './memory/consolidation.js';
+import { createTriggerBaseagentResolver, registerTriggerIpcExecutor } from '../trigger/ipc-service.js';
+import { isLinkedInstall } from '../utils/npm-ops.js';
+export function registerDaemonIpc({ ipcServer, agentRegistry, agentDelegationRegistry, sessionManager, statsCollector, aidStatsCollector, responseEngine, messageQueue, agentMap, commandHandler, channelInstances, eventBus, handoffRuntime, reloadCoordinator, agentApplicationService, agentInitializationService, enqueueConsolidation, completeAgentBootstrap, contactBinds, bindService, diagService, getProcessOwners, getControlAidState, daemonAid, triggerControlToken, triggerSchedulers, daemonTriggerOwner, primaryAgent, triggerAuthorization, }) {
+    const authorizeManagedAgentOperation = createDelegationAuthorizer({
+        agentDelegationRegistry,
+        sessionManager,
+        getProcessOwners,
+    });
+    registerCommandIpcProviders({
+        ipcServer,
+        agentRegistry,
+        triggerControlToken,
+        remoteAccessService,
+        authorizeManagedAgentOperation,
+        hasSuppliedInitialization,
+        loadAgent,
+        completeAgentBootstrap,
+        contactBinds,
+        cmdHandler: commandHandler,
+        executeDiag: command => executeDiagIpc(diagService, agentDelegationRegistry, getProcessOwners(), command),
+        channelInstances,
+        getControlAidState,
+        daemonAid,
+        bindService,
+    });
+    registerRuntimeIpcProviders({
+        ipcServer,
+        channelInstances,
+        messageQueue,
+        aidStatsCollector,
+        responseEngine,
+        sessionManager,
+        agentDelegationRegistry,
+        agentMap,
+        isLinkedInstall: isLinkedInstall(),
+    });
+    registerHandoffIpc({
+        ipcServer,
+        agentDelegationRegistry,
+        responseEngine,
+        sessionManager,
+        agentRegistry,
+        handoffRuntime,
+        getProcessOwners,
+    });
+    registerAunIpcSender({ ipcServer, channelInstances, agentDelegationRegistry, responseEngine, handoffRuntime });
+    ipcServer.setAgentReloadExecutor((aid, options) => reloadCoordinator.reload(aid, options));
+    registerConsolidationCheckExecutor({ ipcServer, agentRegistry, enqueueConsolidation });
+    ipcServer.setInitializationExecutor(async (command) => executeLocalInitializationCommand(agentInitializationService, command));
+    ipcServer.setAgentApplicationService(agentApplicationService);
+    registerQueueIpcProviders({ ipcServer, statsCollector, agentRegistry, messageQueue });
+    registerAgentOperationExecutor({
+        ipcServer,
+        sessionManager,
+        agentDelegationRegistry,
+        eventBus,
+        responseEngine,
+        handoffRuntime,
+        agentApplicationService,
+        agentInitializationService,
+    });
+    registerOperationIpcProviders({
+        ipcServer,
+        sessionManager,
+        messageQueue,
+        agentRegistry,
+        authorizeManagedAgentOperation,
+        recoverTask: request => responseEngine.recoverTask(request),
+    });
+    registerConsolidationLaunchExecutor({ ipcServer, sessionManager, enqueueConsolidation });
+    registerTriggerIpcExecutor(ipcServer, {
+        daemonTriggerOwnerAid: daemonTriggerOwner.aid,
+        daemonTriggerBaseagent: daemonTriggerOwner.baseagent,
+        getScheduler: agentAid => triggerSchedulers.get(agentAid),
+        hasAgent: agentAid => !!agentRegistry.get(agentAid),
+        getAgentBaseagent: agentAid => agentRegistry.get(agentAid)?.baseagent,
+        getAvailableBaseagents: createTriggerBaseagentResolver({
+            daemonTriggerOwnerAid: daemonTriggerOwner.aid,
+            getAgentName: agentAid => agentRegistry.get(agentAid)?.name,
+            getDaemonAgentName: () => primaryAgent?.name,
+            agentMap,
+        }),
+        getSessionById: sessionId => sessionManager.getSessionById(sessionId),
+        ...triggerAuthorization,
+    });
+}
+export function createIpcStatusProvider(dependencies) {
+    return () => {
+        const channels = {};
+        const channelsByType = {};
+        for (const instance of dependencies.channelInstances) {
+            const name = instance.adapter.channelName;
+            const status = instance.channel.getStatus?.() ?? { connected: true };
+            const channelType = instance.channelType || name;
+            channels[name] = { ...status, channelType };
+            if (!channelsByType[channelType])
+                channelsByType[channelType] = [];
+            channelsByType[channelType].push(name);
+        }
+        const snapshot = dependencies.statsCollector.getSnapshot();
+        const agents = dependencies.agentRegistry.list();
+        const runtimeError = dependencies.getAgentRuntimeError();
+        return {
+            pid: process.pid,
+            uptime: snapshot.uptimeMs,
+            build: {
+                runtimeMode: dependencies.runtimeIsDist ? 'dist' : 'source',
+                runtimeId: dependencies.runtimeBuildIdentity.id,
+                diskDistId: computeBuildId(dependencies.diskDistDir),
+                entry: dependencies.runtimeBuildIdentity.entry,
+                version: dependencies.runtimeBuildIdentity.version,
+            },
+            controlPlane: { ready: true, owned: dependencies.getProcessOwners().length > 0 },
+            agentRuntime: {
+                state: dependencies.getAgentRuntimeState(),
+                runnableAgents: agents.filter(agent => agent.status !== 'error' && agent.status !== 'disabled').length,
+                runningAgents: agents.filter(agent => agent.status === 'running').length,
+                ...(runtimeError ? { error: runtimeError } : {}),
+            },
+            channels,
+            channelsByType,
+            queue: { pending: dependencies.messageQueue.getGlobalQueueLength(), processing: dependencies.messageQueue.getGlobalProcessingCount() },
+            stats: {
+                received: snapshot.lastHour.received,
+                sent: snapshot.lastHour.sent,
+                completed: snapshot.lastHour.completed,
+                errors: snapshot.lastHour.errors,
+                avgResponseMs: snapshot.lastHour.avgResponseMs,
+            },
+            controlAid: (() => {
+                if (!dependencies.daemonAid)
+                    return undefined;
+                const aidState = dependencies.getControlAidState();
+                return {
+                    aid: dependencies.daemonAid,
+                    connected: aidState?.status === 'connected',
+                    ...(aidState ? {
+                        status: aidState.status,
+                        gatewayUrl: aidState.gatewayUrl,
+                        reconnectCount: aidState.reconnectCount,
+                        lastConnectedAt: aidState.lastConnectedAt,
+                        lastTransportEventAt: aidState.lastTransportEventAt,
+                        lastInboundAt: aidState.lastInboundAt,
+                        lastError: aidState.lastError,
+                    } : {}),
+                };
+            })(),
+        };
+    };
+}
+export function registerRuntimeIpcProviders({ ipcServer, channelInstances, messageQueue, aidStatsCollector, responseEngine, sessionManager, agentDelegationRegistry, agentMap, isLinkedInstall, }) {
+    ipcServer.setAunAidProvider(() => {
+        const out = [];
+        for (const instance of channelInstances) {
+            if (instance.channelType !== 'aun')
+                continue;
+            const channel = instance.channel;
+            if (typeof channel?.getAidState !== 'function')
+                continue;
+            try {
+                const aidState = channel.getAidState();
+                const agentName = aidState.agentName || aidState.aid;
+                const processing = messageQueue.getProcessingCountByAgent(agentName);
+                const queued = messageQueue.getQueueLengthByAgent(agentName);
+                out.push({ ...aidState, queueStatus: { processing, queued } });
+            }
+            catch {
+                // A channel may disappear while its state is being collected.
+            }
+        }
+        return out;
+    });
+    for (const instance of channelInstances) {
+        if (instance.channelType !== 'aun')
+            continue;
+        const channel = instance.channel;
+        if (typeof channel?.setAidStatsCollector === 'function') {
+            channel.setAidStatsCollector(aidStatsCollector);
+        }
+    }
+    aidStatsCollector.setQueueStatsProvider((agentName) => ({
+        processing: messageQueue.getProcessingCountByAgent(agentName),
+        queued: messageQueue.getQueueLengthByAgent(agentName),
+        muted: messageQueue.isAgentMuted(agentName),
+    }));
+    ipcServer.setAunAidStatsProvider(() => aidStatsCollector.getAllSnapshots());
+    ipcServer.setAunAidStatsRecorder((params) => {
+        aidStatsCollector.recordOutbound(params.aid, params.toPeer, Buffer.byteLength(params.text || '', 'utf-8'), params.text, false, params.encrypt, params.chatmode, 'send');
+    });
+    ipcServer.setTaskRuntimeContextProvider(({ sessionId }) => responseEngine.getTaskRuntimeContext(sessionId));
+    if (isLinkedInstall) {
+        ipcServer.setDebugTaskRuntimeContextProvider(async ({ sessionId }) => {
+            const session = await sessionManager.getSessionById(sessionId);
+            if (!session)
+                return null;
+            const { buildDebugTaskContext } = await import('./memory/consolidation.js');
+            const { ensureSessionRuntimeDir } = await import('../cli/task-context.js');
+            return buildDebugTaskContext({
+                session,
+                getTrigger: (agentAid, triggerId) => new TriggerDefinitionManager(agentAid).get(triggerId),
+                sessionRuntimeDir: ensureSessionRuntimeDir(session.id),
+            });
+        });
+        logger.info('[Memory] 开发仓安装：已启用 ec memory --debug <sessionId>');
+    }
+    ipcServer.setTaskRuntimeContextAuthorizer(({ sessionId, delegationToken, delegationCommandHash }) => {
+        const authorization = agentDelegationRegistry.validateForContext(delegationToken, sessionId, delegationCommandHash);
+        return authorization.ok
+            ? { ok: true }
+            : { ok: false, code: authorization.code, error: authorization.reason };
+    });
+    ipcServer.setCodexPreToolUseExecutor(async (params) => {
+        for (const runner of new Set(agentMap.values())) {
+            if (typeof runner?.evaluatePreToolUse !== 'function')
+                continue;
+            const result = await runner.evaluatePreToolUse(params.threadId, params.toolName, params.toolInput, params.signal, params.callId, params.sessionToken);
+            if (result.applicable)
+                return result;
+        }
+        return {
+            ok: false,
+            applicable: true,
+            decision: 'deny',
+            reason: 'No active EvolCore Codex runner accepted this managed hook credential',
+        };
+    });
+}
+export function registerQueueIpcProviders({ ipcServer, statsCollector, agentRegistry, messageQueue, }) {
+    ipcServer.setStatsProvider(() => statsCollector.getSnapshot());
+    ipcServer.setAgentStatsProvider(() => {
+        const agents = agentRegistry.list();
+        const snapshots = statsCollector.getSnapshots(agents.map(agent => agent.aid));
+        return agents.map((agent) => {
+            const snapshot = snapshots.get(agent.aid);
+            return {
+                aid: agent.aid,
+                received: snapshot.lastHour.received,
+                sent: snapshot.lastHour.sent,
+                completed: snapshot.lastHour.completed,
+                errors: snapshot.lastHour.errors,
+                interrupts: snapshot.lastHour.interrupts,
+                avgResponseMs: snapshot.lastHour.avgResponseMs,
+                processing: messageQueue.getProcessingCountByAgent(agent.aid),
+                queued: messageQueue.getQueueLengthByAgent(agent.aid),
+                muted: messageQueue.isAgentMuted(agent.aid),
+            };
+        });
+    });
+    ipcServer.setQueueSnapshotProvider((params) => {
+        const handle = agentRegistry.get(params.agent);
+        const agentName = handle?.name;
+        if (!agentName)
+            return [];
+        return messageQueue.getQueueItemsByAgent(agentName, { after: params.after, before: params.before });
+    });
+    ipcServer.setQueueActionExecutor(async (params) => {
+        const handle = agentRegistry.get(params.agent);
+        const agentName = handle?.name;
+        if (!agentName)
+            return { ok: false, error: `agent not found: ${params.agent}` };
+        switch (params.action) {
+            case 'clear':
+                return { ok: true, cleared: messageQueue.clearByAgent(agentName) };
+            case 'cancel':
+                if (!params.messageId)
+                    return { ok: false, error: 'missing messageId' };
+                return { ok: true, cancelled: messageQueue.cancelMessageById(agentName, params.messageId) };
+            case 'interrupt': {
+                if (!params.sessionKey)
+                    return { ok: false, error: 'missing sessionKey' };
+                const sessionId = messageQueue.findSessionIdBySessionKey(params.sessionKey);
+                if (!sessionId)
+                    return { ok: false, error: `session not found: ${params.sessionKey}` };
+                return { ok: true, interrupted: await messageQueue.interruptBySession(sessionId) };
+            }
+            default:
+                return { ok: false, error: `unknown action: ${params.action}` };
+        }
+    });
+}
+export function registerCommandIpcProviders({ ipcServer, agentRegistry, triggerControlToken, remoteAccessService, authorizeManagedAgentOperation, hasSuppliedInitialization, loadAgent, completeAgentBootstrap, contactBinds, cmdHandler, executeDiag, channelInstances, getControlAidState, daemonAid, bindService, }) {
+    ipcServer.setAgentRegistry(agentRegistry);
+    ipcServer.setControlToken(triggerControlToken);
+    ipcServer.setRemoteAccessService(remoteAccessService);
+    ipcServer.setBootstrapCompleteExecutor(async (aid, auth) => {
+        if (auth?.sessionId) {
+            const authorization = await authorizeManagedAgentOperation({
+                sessionId: auth.sessionId,
+                delegationToken: auth.delegationToken,
+                delegationCommandHash: auth.delegationCommandHash,
+                targetAid: aid,
+            }, 'agent.bootstrapComplete');
+            if (!authorization.ok)
+                return authorization;
+        }
+        else {
+            const providedToken = typeof auth?.controlToken === 'string' ? Buffer.from(auth.controlToken) : undefined;
+            const expectedToken = Buffer.from(triggerControlToken);
+            if (!providedToken
+                || providedToken.length !== expectedToken.length
+                || !crypto.timingSafeEqual(providedToken, expectedToken)) {
+                return { ok: false, code: 'INVALID_CONTROL_TOKEN', error: 'valid local control token is required' };
+            }
+        }
+        if (hasSuppliedInitialization(aid) || loadAgent(aid)?.initialization) {
+            return { ok: false, code: 'INITIALIZATION_MANAGED', error: 'Use the initialization service for this Agent' };
+        }
+        return completeAgentBootstrap(aid);
+    });
+    ipcServer.setDingtalkContactBindExecutor(contactBinds.dingtalk);
+    ipcServer.setFeishuContactBindExecutor(contactBinds.feishu);
+    ipcServer.setQQBotContactBindExecutor(contactBinds.qqbot);
+    ipcServer.setWecomContactBindExecutor(contactBinds.wecom);
+    ipcServer.setWechatContactBindExecutor(contactBinds.wechat);
+    ipcServer.setMenuExecutor((payload, auth) => cmdHandler.execMenuForEcweb(payload, auth));
+    ipcServer.setConfigOperationExecutor((argv, sessionId, delegationToken, delegationCommandHash) => cmdHandler.handleConfigOperation(argv, sessionId, delegationToken, delegationCommandHash));
+    ipcServer.setContactOperationExecutor((argv, sessionId, delegationToken, delegationCommandHash) => cmdHandler.handleContactOperation(argv, sessionId, delegationToken, delegationCommandHash));
+    ipcServer.setAidOperationExecutor((argv, sessionId, delegationToken, delegationCommandHash) => cmdHandler.handleAidOperation(argv, sessionId, delegationToken, delegationCommandHash));
+    ipcServer.setDiagExecutor(command => executeDiag(command));
+    ipcServer.setMenuClientExecutor(async (command) => {
+        if (!Array.isArray(command.argv)
+            || command.argv.some((value) => typeof value !== 'string')
+            || typeof command.sessionId !== 'string') {
+            return { ok: false, code: 'INVALID_ARGUMENT', error: 'A managed session and Menu argv are required' };
+        }
+        return cmdHandler.handleMenuClientOperation(command.argv, command.sessionId, command.delegationToken, command.delegationCommandHash, async (options) => {
+            const instance = channelInstances.find(item => (item.channelType === 'aun'
+                && item.channel.getAidState()?.aid === options.fromAid));
+            if (!instance)
+                throw new Error('Current Agent AUN channel is unavailable');
+            return instance.channel.requestRemoteMenu(options);
+        });
+    });
+    ipcServer.setGroupOperationExecutor((argv, sessionId, delegationToken, delegationCommandHash) => cmdHandler.handleGroupOperation(argv, sessionId, delegationToken, delegationCommandHash));
+    ipcServer.setMsgOperationExecutor((argv, sessionId, delegationToken, delegationCommandHash) => cmdHandler.handleMsgOperation(argv, sessionId, delegationToken, delegationCommandHash));
+    ipcServer.setFsOperationExecutor((argv, sessionId, delegationToken, delegationCommandHash) => cmdHandler.handleFsOperation(argv, sessionId, delegationToken, delegationCommandHash));
+    cmdHandler.setDaemonStatusProvider(() => {
+        const aidState = getControlAidState();
+        return {
+            aid: daemonAid ?? null,
+            aun: aidState ? {
+                connected: aidState.status === 'connected',
+                status: aidState.status,
+                reconnectCount: aidState.reconnectCount ?? 0,
+                flapCount: aidState.flapCount ?? 0,
+                ...(aidState.lastError ? { lastError: String(aidState.lastError).slice(0, 80) } : {}),
+                ...(aidState.kickDetail?.reason ? { kickReason: String(aidState.kickDetail.reason).slice(0, 80) } : {}),
+            } : {
+                connected: false,
+                status: daemonAid ? 'disconnected' : 'disabled',
+            },
+        };
+    });
+    if (bindService) {
+        ipcServer.setBindExecutor({
+            begin: command => bindService.begin(command),
+            status: taskId => bindService.status(taskId),
+            cancel: taskId => bindService.cancel(taskId),
+        });
+    }
+}
+export function registerOperationIpcProviders({ ipcServer, sessionManager, messageQueue, agentRegistry, authorizeManagedAgentOperation, recoverTask, }) {
+    ipcServer.setTaskResumeExecutor(params => executeTaskResume(params, {
+        sessions: sessionManager,
+        authorizeManaged: authorizeManagedAgentOperation,
+        recover: recoverTask,
+    }));
+    ipcServer.setQueueOperationExecutor(async (params) => {
+        const operation = `ec.queue.${params.action ?? 'read'}`;
+        const authorization = await authorizeManagedAgentOperation(params, operation);
+        if (!authorization.ok)
+            return authorization;
+        const handle = agentRegistry.get(authorization.aid);
+        if (!handle?.name)
+            return { ok: false, code: 'AGENT_NOT_FOUND', error: 'current Agent not found' };
+        if (!params.action) {
+            return { ok: true, items: messageQueue.getQueueItemsByAgent(handle.name, {
+                    after: params.after,
+                    before: params.before,
+                }) };
+        }
+        if (params.action === 'clear')
+            return { ok: true, cleared: messageQueue.clearByAgent(handle.name) };
+        if (params.action === 'cancel') {
+            if (!params.messageId)
+                return { ok: false, code: 'INVALID_ARGUMENT', error: 'missing messageId' };
+            return { ok: true, cancelled: messageQueue.cancelMessageById(handle.name, params.messageId) };
+        }
+        if (!params.sessionKey)
+            return { ok: false, code: 'INVALID_ARGUMENT', error: 'missing sessionKey' };
+        const targetSessionId = messageQueue.findSessionIdBySessionKey(params.sessionKey);
+        if (!targetSessionId)
+            return { ok: false, code: 'SESSION_NOT_FOUND', error: `session not found: ${params.sessionKey}` };
+        const targetSession = await sessionManager.getSessionById(targetSessionId);
+        if (!targetSession || targetSession.selfAID !== authorization.aid) {
+            return { ok: false, code: 'SCOPE_MISMATCH', error: 'session does not belong to the current Agent' };
+        }
+        return { ok: true, interrupted: await messageQueue.interruptBySession(targetSessionId) };
+    });
+    ipcServer.setStatusAuthorizationExecutor(async (params) => {
+        const authorization = await authorizeManagedAgentOperation(params, 'system.status');
+        return authorization.ok ? { ok: true } : authorization;
+    });
+    ipcServer.setStorageAuthorizationExecutor(async (params) => {
+        const authorization = await authorizeManagedAgentOperation({ ...params, targetAid: params.aid }, params.operation);
+        return authorization.ok ? { ok: true } : authorization;
+    });
+    ipcServer.setStorageUploadExecutor(async (params) => {
+        const authorization = await authorizeManagedAgentOperation({ ...params, targetAid: params.aid }, 'storage.upload');
+        if (!authorization.ok)
+            return authorization;
+        const session = await sessionManager.getSessionById(params.sessionId);
+        if (!session)
+            return { ok: false, code: 'SESSION_NOT_FOUND', error: 'current session not found' };
+        try {
+            const projectPath = fs.realpathSync(path.resolve(session.projectPath));
+            const requestedFile = path.resolve(session.projectPath, params.localFile);
+            const requestedStat = fs.lstatSync(requestedFile);
+            if (requestedStat.isSymbolicLink()) {
+                return { ok: false, code: 'INVALID_LOCAL_FILE', error: 'Upload source must not be a symbolic link' };
+            }
+            const localFile = fs.realpathSync(requestedFile);
+            const stat = fs.lstatSync(localFile);
+            if (!isSameOrDescendant(localFile, projectPath) || isHClassPath(localFile)) {
+                return { ok: false, code: 'INVALID_LOCAL_PATH', error: 'Upload source must be an unprotected file inside the current session project' };
+            }
+            if (!stat.isFile() || stat.isSymbolicLink()) {
+                return { ok: false, code: 'INVALID_LOCAL_FILE', error: 'Upload source must be a regular non-symlink file' };
+            }
+            const { storageUpload } = await import('../aun/storage/index.js');
+            const result = await storageUpload(authorization.aid, localFile, params.remotePath, { isPublic: params.isPublic });
+            return result.ok
+                ? { ok: true, objectKey: result.objectKey, publicUrl: result.publicUrl }
+                : { ok: false, code: 'STORAGE_UPLOAD_FAILED', error: result.error };
+        }
+        catch (error) {
+            return { ok: false, code: 'INVALID_LOCAL_FILE', error: error instanceof Error ? error.message : String(error) };
+        }
+    });
+}

package/dist/core/memory/consolidation-trigger.js

@@ -35,6 +35,14 @@ export const META_INDEX_THRESHOLD = 200;
 const DEFAULT_CRON = '17 * * * *';
 const SCRIPT_NAME = 'consolidation-check.cjs';
 export const CONSOLIDATION_CHECK_TRIGGER_ID = '__memory-consolidation-check';
+export function consolidationCheckCron(intervalHours) {
+    const hours = intervalHours && intervalHours > 0 ? Math.floor(intervalHours) : 1;
+    if (hours === 1)
+        return '17 * * * *';
+    if (hours >= 24)
+        return '17 3 * * *';
+    return `17 */${hours} * * *`;
+}
 /** Register the periodic consolidation candidate check trigger. */
 export function seedConsolidationCheckTrigger(manager, owner, packageRoot = getPackageRoot()) {
     const now = Date.now();