evolcore 0.0.26 → 0.0.28

package/dist/ipc.js

@@ -5,13 +5,14 @@ import fs from 'fs';
 import crypto from 'crypto';
 import os from 'os';
 import path from 'path';
+import { execFile } from 'node:child_process';
 import { logger } from './utils/logger.js';
 import { withMenuProcessingTime, logMenuRequestCompleted, logMenuRequestReceived } from './core/command/menu-protocol.js';
 import { fileCache } from './core/daemon-file-cache.js';
 import { DAEMON_RUNTIME_EPOCH_ENV } from './cli/task-context.js';
 import { HANDOFF_QUERY_MAX_LIMIT, HANDOFF_STATES } from './core/handoff/types.js';
 import { AgentReloadBusyError } from './core/agent-reload-coordinator.js';
-import { getWindowsInstanceSocketPathCandidates, normalizeIpcEndpoint, resolvePaths } from './paths.js';
+import { getPackageRoot, getWindowsInstanceSocketPathCandidates, normalizeIpcEndpoint, resolvePaths } from './paths.js';
 import { getProcessStartTime, isSameOrOlderProcess } from './utils/process-introspect.js';
 import { classifyProcessTree, ProcessTreeSampler, readProcessMetrics } from './utils/process-tree-stats.js';
 import { readSystemMemoryUsage } from './utils/system-memory.js';
@@ -73,10 +74,42 @@ function nextIpcQueryId(cmd) {
     return `ipc-${ipcQuerySequence}`;
 }
 function requiresLocalControlToken(cmd) {
-    // Managed bootstrap completion is authenticated by the session delegation
-    // ticket. A standalone CLI invocation still needs the daemon control token.
-    return LOCAL_CONTROL_COMMANDS.has(String(cmd.type ?? ''))
-        || ((cmd.type === 'evolagent.bootstrapComplete' || cmd.type === 'diag') && typeof cmd.sessionId !== 'string');
+    // Managed calls use task delegation. Standalone queries must not gain
+    // management scope merely by omitting (or emptying) sessionId.
+    return cmd.type === 'evolagent.initialize' || LOCAL_CONTROL_COMMANDS.has(String(cmd.type ?? ''))
+        || (['evolagent.bootstrapComplete', 'diag', 'handoff-status', 'handoff-list', 'handoff-trace', 'task.resume'].includes(String(cmd.type))
+            && !(typeof cmd.sessionId === 'string' && cmd.sessionId.trim()));
+}
+/** Preserve the pipe DACL and grant only the provisioned Codex users data I/O. */
+function grantWindowsSandboxPipeAccess(endpoint) {
+    const powershell = path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+    const request = Buffer.from(JSON.stringify({ action: 'pipe', path: endpoint })).toString('base64');
+    return new Promise((resolve, reject) => {
+        // Asynchronous: the ACL helper connects as a client, so Node must keep
+        // accepting pipe instances while it runs. Never interpolate shell source.
+        execFile(powershell, ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass',
+            '-File', path.join(getPackageRoot(), 'bin', 'codex-managed-acl.ps1'), '-Request', request], { windowsHide: true, timeout: 15_000, maxBuffer: 64 * 1024 }, (error, stdout, stderr) => {
+            if (error) {
+                reject(new Error(`Windows IPC sandbox ACL setup failed: ${stderr.trim() || error.message}`));
+                return;
+            }
+            try {
+                const result = JSON.parse(stdout.replace(/^\uFEFF/, '').trim());
+                if (!Array.isArray(result.granted))
+                    throw new Error('invalid ACL helper response');
+                if (result.granted.length) {
+                    logger.info(`[IPC] Sandbox pipe access granted to ${result.granted.join(', ')}`);
+                }
+                else {
+                    logger.info('[IPC] Codex sandbox accounts are not provisioned; restart daemon after Windows sandbox setup');
+                }
+                resolve();
+            }
+            catch (parseError) {
+                reject(parseError);
+            }
+        });
+    });
 }
 export function summarizeMonitorAgents(agents, aids) {
     const connectedAgents = new Set(aids.filter(aid => aid.status === 'connected').map(aid => aid.agentName || aid.aid));
@@ -102,18 +135,22 @@ export class IpcServer {
     aunAidStatsRecorder;
     menuExecutor;
     agentOperationExecutor;
+    initializationExecutor;
     statsProvider;
     agentStatsProvider;
     queueSnapshotProvider;
     queueActionExecutor;
     queueOperationExecutor;
     statusAuthorizationExecutor;
+    taskResumeExecutor;
     storageAuthorizationExecutor;
+    storageUploadExecutor;
     triggerExecutor;
     bootstrapCompleteExecutor;
     agentReloadExecutor;
     shutdownExecutor;
     taskRuntimeContextProvider;
+    taskRuntimeContextAuthorizer;
     codexPreToolUseExecutor;
     aunMsgSender;
     diagExecutor;
@@ -211,6 +248,9 @@ export class IpcServer {
     setMenuExecutor(executor) {
         this.menuExecutor = executor;
     }
+    setInitializationExecutor(executor) {
+        this.initializationExecutor = executor;
+    }
     setAgentOperationExecutor(executor) {
         this.agentOperationExecutor = executor;
     }
@@ -354,9 +394,15 @@ export class IpcServer {
     setStatusAuthorizationExecutor(executor) {
         this.statusAuthorizationExecutor = executor;
     }
+    setTaskResumeExecutor(executor) {
+        this.taskResumeExecutor = executor;
+    }
     setStorageAuthorizationExecutor(executor) {
         this.storageAuthorizationExecutor = executor;
     }
+    setStorageUploadExecutor(executor) {
+        this.storageUploadExecutor = executor;
+    }
     /** Inject daemon-level trigger executor for ec trigger. */
     setTriggerExecutor(executor) {
         this.triggerExecutor = executor;
@@ -369,6 +415,9 @@ export class IpcServer {
     setTaskRuntimeContextProvider(provider) {
         this.taskRuntimeContextProvider = provider;
     }
+    setTaskRuntimeContextAuthorizer(authorizer) {
+        this.taskRuntimeContextAuthorizer = authorizer;
+    }
     setCodexPreToolUseExecutor(executor) {
         this.codexPreToolUseExecutor = executor;
     }
@@ -792,8 +841,17 @@ export class IpcServer {
                     }
                     catch { }
                 }
-                logger.info(`[IPC] Listening on ${this.socketPath}`);
-                resolve();
+                const permissionsReady = isNamedPipe(this.socketPath)
+                    ? grantWindowsSandboxPipeAccess(this.socketPath)
+                    : Promise.resolve();
+                void permissionsReady.then(() => {
+                    logger.info(`[IPC] Listening on ${this.socketPath}`);
+                    resolve();
+                }, error => {
+                    this.stop();
+                    logger.error('[IPC] Unable to configure pipe permissions:', error);
+                    reject(error);
+                });
             });
         });
     }
@@ -814,11 +872,10 @@ export class IpcServer {
         if (requiresLocalControlToken(cmd) && !this.hasValidControlToken(cmd.controlToken)) {
             return { ok: false, code: 'INVALID_CONTROL_TOKEN', error: 'valid local control token is required' };
         }
-        if (typeof cmd.sessionId === 'string' && cmd.sessionId
-            && typeof cmd.delegationToken === 'string' && cmd.delegationToken
+        if (typeof cmd.delegationToken === 'string' && cmd.delegationToken
             && this.daemonRuntimeEpoch
             && cmd.daemonRuntimeEpoch !== this.daemonRuntimeEpoch) {
-            logger.warn(`[IPC] stale delegation rejected: session=${ipcLogToken(cmd.sessionId)} type=${ipcLogToken(cmd.type)} cause=daemon_runtime_epoch_mismatch`);
+            logger.warn(`[IPC] stale delegation rejected: session=${ipcLogToken(cmd.sessionId ?? cmd.originSessionId ?? cmd.actorSessionId)} type=${ipcLogToken(cmd.type)} cause=daemon_runtime_epoch_mismatch`);
             return {
                 ok: false,
                 code: 'DAEMON_RESTARTED',
@@ -910,16 +967,21 @@ export class IpcServer {
                 });
             }
             case 'remote-auth.pair-code': {
+                // IPC issues local codes. Owner-authenticated /pair and Menu paths
+                // supply provenance in-process, never from a caller-supplied source.
+                if (cmd.source !== undefined && cmd.source !== 'host-cli' && cmd.source !== 'ecweb-local') {
+                    return { ok: false, code: 'INVALID_ARGUMENT', error: 'invalid local pairing source' };
+                }
                 const requestedOwner = typeof cmd.authorizedBy === 'string' ? cmd.authorizedBy.trim() : undefined;
                 const authorizedBy = requestedOwner || this.remoteAccessOwnerProvider?.();
-                const pair = this.remoteAccessService.getPairingCode(authorizedBy);
+                const pair = this.remoteAccessService.getPairingCode(authorizedBy, Date.now(), cmd.source ?? 'host-cli');
                 return { ok: true, ...pair };
             }
             case 'remote-auth.issue-local': {
                 return this.remoteAccessService.issueLocalToken(cmd.label);
             }
             case 'remote-auth.redeem': {
-                return this.remoteAccessService.redeemPairingCode(cmd.code, cmd.label, cmd.authorizedBy);
+                return this.remoteAccessService.redeemPairingCode(cmd.code, cmd.label);
             }
             case 'remote-auth.validate': {
                 return { ok: true, ...this.remoteAccessService.validateToken(cmd.token) };
@@ -1093,6 +1155,25 @@ export class IpcServer {
                     delegationCommandHash: typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined,
                 });
             }
+            case 'storage.upload': {
+                if (!this.storageUploadExecutor)
+                    return { ok: false, code: 'NOT_CONFIGURED', error: 'storage upload not configured' };
+                if (typeof cmd.sessionId !== 'string' || !cmd.sessionId
+                    || typeof cmd.aid !== 'string' || !cmd.aid
+                    || typeof cmd.localFile !== 'string' || !cmd.localFile
+                    || typeof cmd.remotePath !== 'string' || !cmd.remotePath) {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing sessionId, aid, localFile, or remotePath' };
+                }
+                return await this.storageUploadExecutor({
+                    sessionId: cmd.sessionId,
+                    aid: cmd.aid,
+                    localFile: cmd.localFile,
+                    remotePath: cmd.remotePath,
+                    isPublic: cmd.isPublic === true,
+                    delegationToken: typeof cmd.delegationToken === 'string' ? cmd.delegationToken : undefined,
+                    delegationCommandHash: typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined,
+                });
+            }
             case 'aun-aid-stats-record-outbound': {
                 if (!this.aunAidStatsRecorder)
                     return { ok: false, error: 'recorder not configured' };
@@ -1110,11 +1191,47 @@ export class IpcServer {
                     return { ok: false, error: String(e?.message || e) };
                 }
             }
+            case 'task.resume': {
+                const allowed = new Set(['type', 'targetSessionId', 'sessionId', 'delegationToken',
+                    'delegationCommandHash', 'controlToken', 'daemonRuntimeEpoch', 'requestId', 'id']);
+                if (Object.keys(cmd).some(key => !allowed.has(key))
+                    || typeof cmd.targetSessionId !== 'string' || !cmd.targetSessionId.trim()
+                    || (cmd.sessionId !== undefined && (typeof cmd.sessionId !== 'string' || !cmd.sessionId.trim()))) {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'task.resume accepts only a target session and caller credentials' };
+                }
+                if (cmd.sessionId && (typeof cmd.delegationToken !== 'string' || !cmd.delegationToken)) {
+                    return { ok: false, code: 'DELEGATION_REQUIRED', error: 'managed task resume requires a delegation token' };
+                }
+                if (!this.taskResumeExecutor)
+                    return { ok: false, code: 'NOT_CONFIGURED', error: 'task.resume not configured' };
+                try {
+                    return await this.taskResumeExecutor({
+                        targetSessionId: cmd.targetSessionId,
+                        sessionId: cmd.sessionId,
+                        delegationToken: typeof cmd.delegationToken === 'string' ? cmd.delegationToken : undefined,
+                        delegationCommandHash: typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined,
+                        localControl: !cmd.sessionId && this.hasValidControlToken(cmd.controlToken),
+                    });
+                }
+                catch (error) {
+                    return { ok: false, code: 'TASK_RESUME_FAILED', error: error instanceof Error ? error.message : String(error) };
+                }
+            }
             case 'task-runtime-context': {
                 if (!this.taskRuntimeContextProvider)
                     return { ok: false, error: 'task runtime context not configured' };
                 if (!cmd.sessionId || typeof cmd.sessionId !== 'string')
                     return { ok: false, error: 'missing sessionId' };
+                if (!this.taskRuntimeContextAuthorizer) {
+                    return { ok: false, code: 'DELEGATION_REQUIRED', error: 'task runtime context authorization is not configured' };
+                }
+                const authorization = this.taskRuntimeContextAuthorizer({
+                    sessionId: cmd.sessionId,
+                    delegationToken: typeof cmd.delegationToken === 'string' ? cmd.delegationToken : undefined,
+                    delegationCommandHash: typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined,
+                });
+                if (!authorization.ok)
+                    return authorization;
                 const context = this.taskRuntimeContextProvider({ sessionId: cmd.sessionId }) ?? null;
                 return { ok: true, context };
             }
@@ -1361,6 +1478,13 @@ export class IpcServer {
                 }
                 return await this.fsOperationExecutor(argv, sessionId, delegationToken, typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined);
             }
+            case 'evolagent.initialize': {
+                if (cmd.sessionId || cmd.delegationToken)
+                    return { ok: false, code: 'NOT_ALLOWED', error: 'Managed callers must use agent.op' };
+                if (!this.initializationExecutor)
+                    return { ok: false, code: 'NOT_CONFIGURED', error: 'Initialization service unavailable' };
+                return this.initializationExecutor(cmd);
+            }
             case 'agent.op': {
                 if (!this.agentOperationExecutor)
                     return { ok: false, code: 'NOT_CONFIGURED', error: 'agent.op not configured' };
@@ -1428,12 +1552,13 @@ export class IpcServer {
                 if (!this.bootstrapCompleteExecutor)
                     return { ok: false, error: 'bootstrap complete executor not configured' };
                 try {
-                    return await this.bootstrapCompleteExecutor(aid, {
+                    const auth = {
                         sessionId: typeof cmd.sessionId === 'string' ? cmd.sessionId : undefined,
                         delegationToken: typeof cmd.delegationToken === 'string' ? cmd.delegationToken : undefined,
                         delegationCommandHash: typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined,
                         controlToken: typeof cmd.controlToken === 'string' ? cmd.controlToken : undefined,
-                    });
+                    };
+                    return await this.bootstrapCompleteExecutor(aid, auth);
                 }
                 catch (e) {
                     return { ok: false, error: e?.message || String(e) };
@@ -1600,7 +1725,7 @@ export class IpcTransportError extends Error {
     endpoint;
     constructor(code, endpoint) {
         const hint = code === 'EPERM' || code === 'EACCES'
-            ? '权限被拒绝；Windows 下请检查 daemon 与 CLI 是否使用相同用户和提升权限级别。'
+            ? '权限被拒绝；请检查 IPC 端点权限及沙箱隔离。Windows 下同用户进程也可能因受限令牌无法连接命名管道。'
             : code === 'ETIMEDOUT'
                 ? '等待 daemon 响应超时；请求可能已执行，请先检查状态再重试。'
                 : code === 'ENOENT' || code === 'ECONNREFUSED'
@@ -1671,6 +1796,7 @@ function ipcQueryOnce(socketPath, cmd, timeoutMs = 3000) {
     const request = {
         ...(delegationCommandHash ? { ...authenticatedCmd, delegationCommandHash } : authenticatedCmd),
         ...(process.env[DAEMON_RUNTIME_EPOCH_ENV]
+            && authenticatedCmd.daemonRuntimeEpoch === undefined
             && typeof authenticatedCmd.delegationToken === 'string'
             ? { daemonRuntimeEpoch: process.env[DAEMON_RUNTIME_EPOCH_ENV] }
             : {}),

package/dist/paths.js

@@ -72,11 +72,11 @@ export function aunPath() {
 export function aidsDir() {
     return path.join(resolveRoot(), 'AIDs');
 }
-export function aidLocalDir(aid) {
-    return path.join(resolveRoot(), 'AIDs', aid);
+export function aidLocalDir(aid, root = resolveRoot()) {
+    return path.join(root, 'AIDs', aid);
 }
-export function agentMdPath(aid) {
-    return path.join(resolveRoot(), 'AIDs', aid, 'agent.md');
+export function agentMdPath(aid, root = resolveRoot()) {
+    return path.join(root, 'AIDs', aid, 'agent.md');
 }
 // ── per-agent 路径（参数化，不进 resolvePaths() 的固定 map）──
 export function agentDir(aid) {
@@ -94,6 +94,10 @@ export function agentContactOperations(aid) {
 export function agentPersonalDir(aid) {
     return path.join(agentDir(aid), 'personal');
 }
+/** Agent-owned Bootstrap completion welcome template. */
+export function agentWelcomePath(aid) {
+    return path.join(agentPersonalDir(aid), 'welcome.md');
+}
 export function agentRolesDir(aid) {
     return path.join(agentDir(aid), 'roles');
 }
@@ -106,6 +110,12 @@ export function agentRoleConfig(aid, roleId) {
 export function agentRelationsDir(aid) {
     return path.join(agentDir(aid), 'relations');
 }
+export function agentRelationDir(aid, peerKey) {
+    return path.join(agentRelationsDir(aid), peerKey);
+}
+export function agentRelationSharedDir(aid, peerKey) {
+    return path.join(agentRelationDir(aid, peerKey), 'shared');
+}
 /** @deprecated Use agentRelationsDir instead */
 export function agentIdentitiesDir(aid) {
     return agentRelationsDir(aid);
@@ -128,6 +138,9 @@ export function agentDataCacheDir(aid) {
 export function agentHandoffDir(aid) {
     return path.join(agentDataDir(aid), 'handoff');
 }
+export function agentGroupInviteReviewsPath(aid) {
+    return path.join(agentDataDir(aid), 'aun', 'group-invite-reviews.json');
+}
 export function agentOutboxPath(aid) {
     return path.join(resolvePaths().outboxDir, encodeURIComponent(aid), 'outbox.jsonl');
 }

package/dist/product.js

@@ -14,6 +14,9 @@ export const MIN_ECWEB_VERSION = '0.0.8';
 export const DAEMON_CONFIG_FILENAME = 'daemon.json';
 export const DAEMON_SCHEMA_NAME = 'daemon';
 export const RUNTIME_HOME_ENV = 'EVOLCORE_HOME';
+export const TARGET_PACKAGE_ROOT_ENV = 'EVOLCORE_TARGET_PACKAGE_ROOT';
+export const SESSION_ID_ENV = 'EVOLCORE_SESSION_ID';
+export const SELF_AID_ENV = 'EVOLCORE_SELF_AID';
 export const DEFAULT_RUNTIME_HOME_DIRNAME = '.evolcore';
 export const INSTANCE_SOCKET_FILENAME = 'daemon.sock';
 export const WINDOWS_PIPE_PREFIX = 'daemon';

package/dist/trigger/event-source.js

@@ -1,4 +1,8 @@
 import { logger } from '../utils/logger.js';
+export function isDaemonEventSessionTrigger(trigger) {
+    return trigger.feedback.strategy === 'event_session'
+        && (trigger.origin?.channelKey === 'daemon' || trigger.origin?.channelType === 'daemon');
+}
 /** Match a real or simulated event without publishing it to the event bus. */
 export function matchTriggerEvent(source, event) {
     if (typeof event.type !== 'string' || !event.type.trim()) {
@@ -34,6 +38,21 @@ export class TriggerEventSource {
                     return;
                 if (event.type.startsWith('trigger:') && event.originTriggerId === trigger.id)
                     return;
+                // Dynamic routing is agent-local for ordinary Agent Triggers. A
+                // daemon-origin event_session Trigger is explicitly allowed to route
+                // the event to the owning Agent discovered from the payload.
+                if (trigger.feedback.strategy === 'event_session') {
+                    const payload = event;
+                    const daemonScoped = isDaemonEventSessionTrigger(trigger);
+                    if (daemonScoped && event.type === 'task:error' && payload.originTriggerId === trigger.id)
+                        return;
+                    if (typeof payload.agentAid !== 'string' || !payload.agentAid.trim()
+                        || (!daemonScoped && payload.agentAid !== trigger.agentAid)
+                        || typeof payload.sessionId !== 'string' || !payload.sessionId)
+                        return;
+                }
+                if (event.causation?.trigger?.path.some(node => node.triggerId === trigger.id))
+                    return;
                 if (!matchTriggerEvent({ type: 'event', eventPattern, ...(filter ? { filter } : {}) }, event).matched)
                     return;
                 this.fire(trigger.id, {