evolcore 0.0.33 → 0.0.34

package/dist/core/auth/delegation-diagnostics.js

@@ -0,0 +1,414 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { StringDecoder } from 'node:string_decoder';
+import { isDelegationDiagnosticsEnabled } from '../../config-store.js';
+import { resolvePaths } from '../../paths.js';
+import { PRODUCT_DISPLAY_NAME } from '../../product.js';
+import { stableWriteJson } from '../../utils/atomic-write.js';
+import { logger } from '../../utils/logger.js';
+import { LogWriter } from '../../utils/log-writer.js';
+const contexts = new AsyncLocalStorage();
+const DAY_MS = 86_400_000;
+const EVENT_RETENTION_DAYS = 180;
+const STATE_RETENTION_MS = 90 * DAY_MS;
+const MESSAGES = {
+    missing_token: '当前请求未携带任务授权凭据。',
+    unknown_token: '在保留的诊断记录中无法识别授权凭据，无法确认其是否曾存在或已被清理。',
+    session_mismatch: '授权凭据不属于当前会话，请在正确的活动任务中重新发起命令。',
+    task_replaced: '当前任务授权已被替换，请在新的活动任务中重新发起命令。',
+    task_revoked: '任务授权已因任务结束、中断或策略变更被撤销，请重新发起任务。',
+    approval_not_found: '已识别会话凭据，但未找到当前命令的匹配审批。',
+    approval_expired: '当前命令的审批已过期，请在活动任务中重新申请审批。',
+    approval_consumed: '当前命令的审批使用次数已耗尽，请勿重放旧请求。',
+    command_hash_mismatch: '提交的命令参数与命令指纹不一致，当前请求已被拒绝。',
+    daemon_restarted: `授权来自先前的 ${PRODUCT_DISPLAY_NAME} 实例，请重新发起任务授权，不要重试旧请求。`,
+};
+export function delegationDiagnosticMessage(cause) {
+    return `(${cause}) ${MESSAGES[cause]}`;
+}
+export async function withDelegationDiagnosticContext(context, callback) {
+    return contexts.run(context, async () => {
+        const result = await callback();
+        if (!result || typeof result !== 'object' || !context.diagnostic)
+            return result;
+        const response = result;
+        if (response.ok !== false || typeof response.error !== 'string'
+            || !response.error.includes(context.diagnostic.reason))
+            return result;
+        const error = response.error;
+        return {
+            ...response,
+            error: error.startsWith(`(${context.diagnostic.diagnosticCause})`)
+                ? error
+                : `(${context.diagnostic.diagnosticCause}) ${error}`,
+            diagnosticCause: context.diagnostic.diagnosticCause,
+            ...(context.diagnostic.diagnosticEventId ? { diagnosticEventId: context.diagnostic.diagnosticEventId } : {}),
+        };
+    });
+}
+function stateKey(state) {
+    return JSON.stringify([state.kind, state.tokenHash, state.sessionId, state.commandHash ?? '']);
+}
+function fingerprint(value) {
+    return typeof value === 'string' && /^[a-f0-9]{64}$/.test(value) ? value : undefined;
+}
+function reference(value) {
+    return typeof value === 'string' && value.length > 0 && value.length <= 512 && !/[\s\x00-\x1f\x7f]/.test(value)
+        ? value : undefined;
+}
+function readState(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const state = value;
+    if (!['task', 'session', 'approval'].includes(state.kind) || !fingerprint(state.tokenHash)
+        || !reference(state.sessionId) || !reference(state.taskId) || !reference(state.runtimeEpoch)
+        || !Number.isFinite(state.updatedAt)
+        || !['active', 'replaced', 'revoked', 'expired', 'consumed'].includes(state.status)
+        || state.kind === 'approval' && (!fingerprint(state.commandHash) || !fingerprint(state.activeTokenHash)))
+        return undefined;
+    const sanitized = {
+        kind: state.kind, tokenHash: state.tokenHash, sessionId: state.sessionId, taskId: state.taskId,
+        runtimeEpoch: state.runtimeEpoch, status: state.status, updatedAt: state.updatedAt,
+    };
+    for (const field of ['selfAid', 'peerKey', 'actorId', 'issuedRole', 'permissionMode', 'threadId', 'messageId']) {
+        const safe = reference(state[field]);
+        if (safe)
+            sanitized[field] = safe;
+    }
+    for (const field of ['commandHash', 'activeTokenHash']) {
+        const safe = fingerprint(state[field]);
+        if (safe)
+            sanitized[field] = safe;
+    }
+    for (const field of ['expiresAt', 'remainingUses', 'sequence']) {
+        const numeric = state[field];
+        if (typeof numeric === 'number' && Number.isSafeInteger(numeric) && numeric >= 0)
+            sanitized[field] = numeric;
+    }
+    if (state.credentialType === 'task' || state.credentialType === 'codex-session')
+        sanitized.credentialType = state.credentialType;
+    if (state.revocationReason && ['completed', 'interrupted', 'replaced', 'policy_revoked', 'failed', 'revoked'].includes(state.revocationReason)) {
+        sanitized.revocationReason = state.revocationReason;
+    }
+    return sanitized;
+}
+export class DelegationDiagnostics {
+    runtimeEpoch;
+    states = new Map();
+    credentialsByHash = new Map();
+    indexPath;
+    logDir;
+    writer;
+    lastCleanup = 0;
+    lastArchiveCleanup = 0;
+    persistenceState;
+    sequence = 0;
+    lastWarnings = new Map();
+    constructor(runtimeEpoch) {
+        this.runtimeEpoch = runtimeEpoch;
+        const paths = resolvePaths();
+        this.logDir = paths.logs;
+        this.indexPath = path.join(paths.dataDir, 'delegation-diagnostics', 'index.json');
+        this.load();
+        this.record('runtime.started');
+        this.save();
+    }
+    close() {
+        this.writer?.close();
+    }
+    put(event, input) {
+        const state = readState({ ...input, updatedAt: Date.now(), sequence: ++this.sequence });
+        if (!state) {
+            this.warn('诊断状态格式无效，记录已跳过', new Error('invalid state'));
+            return;
+        }
+        this.store(state);
+        this.record(event, { state });
+        this.save();
+    }
+    find(kind, tokenHash, sessionId, commandHash) {
+        const recent = this.states.get(stateKey({ kind, tokenHash, sessionId, commandHash }));
+        if (recent && this.retained(recent))
+            return recent;
+        return undefined;
+    }
+    findCredential(tokenHash, sessionId) {
+        const matches = [...(this.credentialsByHash.get(tokenHash)?.values() ?? [])].filter(state => this.retained(state));
+        return matches.find(state => state.sessionId === sessionId)
+            ?? matches.sort((left, right) => right.updatedAt - left.updatedAt)[0];
+    }
+    classify(tokenHash, sessionId, commandHash) {
+        const credential = this.findCredential(tokenHash, sessionId);
+        if (!credential)
+            return 'unknown_token';
+        if (credential.sessionId !== sessionId)
+            return 'session_mismatch';
+        if (credential.kind === 'task')
+            return this.taskCause(credential);
+        const approval = commandHash ? this.find('approval', tokenHash, sessionId, commandHash) : undefined;
+        const activeTokenHash = approval?.activeTokenHash ?? credential.activeTokenHash;
+        const task = activeTokenHash
+            ? this.find('task', activeTokenHash, sessionId)
+            : undefined;
+        if (task && task.status !== 'active')
+            return this.taskCause(task);
+        if (credential.runtimeEpoch !== this.runtimeEpoch || approval && approval.runtimeEpoch !== this.runtimeEpoch) {
+            return 'daemon_restarted';
+        }
+        if (credential.status !== 'active')
+            return this.taskCause(credential);
+        if (!approval)
+            return 'approval_not_found';
+        if (approval.status === 'consumed')
+            return 'approval_consumed';
+        if (approval.status === 'expired' || approval.expiresAt !== undefined && approval.expiresAt <= Date.now()) {
+            return 'approval_expired';
+        }
+        if (approval.status !== 'active')
+            return this.taskCause(approval);
+        return 'approval_not_found';
+    }
+    classifyCommandHashMismatch(tokenHash, sessionId) {
+        return this.classifyCredential(tokenHash, sessionId) ?? 'command_hash_mismatch';
+    }
+    failure(cause, sessionId, tokenHash, commandHash) {
+        const reason = delegationDiagnosticMessage(cause);
+        const diagnosticEventId = this.record('validation.rejected', {
+            diagnosticCause: cause, sessionId: reference(sessionId), tokenHash: fingerprint(tokenHash), commandHash: fingerprint(commandHash),
+        });
+        const diagnostic = { diagnosticCause: cause, ...(diagnosticEventId ? { diagnosticEventId } : {}), reason };
+        const context = contexts.getStore();
+        if (context)
+            context.diagnostic = diagnostic;
+        return {
+            ok: false,
+            code: cause === 'missing_token' ? 'DELEGATION_REQUIRED'
+                : cause === 'daemon_restarted' ? 'DAEMON_RESTARTED' : 'INVALID_DELEGATION',
+            ...diagnostic,
+        };
+    }
+    accepted(sessionId, tokenHash, commandHash) {
+        this.record('validation.accepted', { sessionId: reference(sessionId), tokenHash: fingerprint(tokenHash), commandHash: fingerprint(commandHash) });
+    }
+    taskCause(state) {
+        if (state.status === 'replaced')
+            return 'task_replaced';
+        if (state.status !== 'active')
+            return 'task_revoked';
+        return state.runtimeEpoch !== this.runtimeEpoch ? 'daemon_restarted' : 'unknown_token';
+    }
+    classifyCredential(tokenHash, sessionId) {
+        const credential = this.findCredential(tokenHash, sessionId);
+        if (!credential)
+            return 'unknown_token';
+        if (credential.sessionId !== sessionId)
+            return 'session_mismatch';
+        if (credential.status === 'replaced')
+            return 'task_replaced';
+        if (credential.status !== 'active')
+            return 'task_revoked';
+        if (credential.runtimeEpoch !== this.runtimeEpoch)
+            return 'daemon_restarted';
+        if (credential.kind === 'task')
+            return undefined;
+        if (!credential.activeTokenHash)
+            return 'unknown_token';
+        const task = this.find('task', credential.activeTokenHash, sessionId);
+        if (!task)
+            return 'unknown_token';
+        if (task.status === 'replaced')
+            return 'task_replaced';
+        if (task.status !== 'active')
+            return 'task_revoked';
+        if (task.runtimeEpoch !== this.runtimeEpoch)
+            return 'daemon_restarted';
+        return undefined;
+    }
+    retained(state) {
+        if (state.runtimeEpoch === this.runtimeEpoch && state.status === 'active'
+            && (state.kind !== 'approval' || state.expiresAt !== undefined && state.expiresAt > Date.now()))
+            return true;
+        return state.updatedAt >= Date.now() - STATE_RETENTION_MS;
+    }
+    store(state) {
+        const key = stateKey(state);
+        this.states.set(key, state);
+        if (state.kind !== 'approval') {
+            let credentials = this.credentialsByHash.get(state.tokenHash);
+            if (!credentials) {
+                credentials = new Map();
+                this.credentialsByHash.set(state.tokenHash, credentials);
+            }
+            credentials.set(key, state);
+        }
+        this.sequence = Math.max(this.sequence, state.sequence ?? 0);
+    }
+    record(event, details = {}) {
+        if (!this.persistenceEnabled())
+            return undefined;
+        const context = contexts.getStore();
+        const record = {
+            version: 1, eventId: `del-audit-${crypto.randomUUID()}`, ts: Date.now(), runtimeEpoch: this.runtimeEpoch, event,
+            ...(reference(context?.requestId) ? { requestId: context.requestId } : {}),
+            ...(reference(context?.correlationId) ? { correlationId: context.correlationId } : {}),
+            ...(reference(context?.operation) ? { operation: context.operation } : {}),
+            ...details,
+        };
+        try {
+            if (!this.writer) {
+                this.writer = new LogWriter({
+                    baseName: 'delegation-audit', logDir: this.logDir, rotation: 'daily',
+                    retention: { days: EVENT_RETENTION_DAYS },
+                });
+                this.writer.close();
+            }
+            if (Date.now() - this.lastArchiveCleanup > 3_600_000) {
+                LogWriter.cleanupArchivesIn(this.logDir, 'delegation-audit', EVENT_RETENTION_DAYS * DAY_MS);
+                this.lastArchiveCleanup = Date.now();
+            }
+            this.writer.writeChecked(JSON.stringify(record));
+            return record.eventId;
+        }
+        catch (error) {
+            this.warn('审计事件写入失败', error);
+            return undefined;
+        }
+    }
+    load() {
+        try {
+            const index = JSON.parse(fs.readFileSync(this.indexPath, 'utf8'));
+            if (index.version !== 1 || !Array.isArray(index.states))
+                throw new Error('invalid diagnostic index');
+            for (const raw of index.states) {
+                const state = readState(raw);
+                if (state && this.retained(state))
+                    this.store(state);
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                this.warn('诊断索引读取失败，尝试从审计事件重建', error);
+        }
+        this.scanHistory(state => {
+            if (!this.retained(state))
+                return;
+            const previous = this.states.get(stateKey(state));
+            if (!previous || (state.sequence !== undefined && previous.sequence !== undefined
+                ? state.sequence > previous.sequence : state.updatedAt > previous.updatedAt))
+                this.store(state);
+        });
+    }
+    scanHistory(visit) {
+        try {
+            if (!fs.existsSync(this.logDir))
+                return;
+            const files = fs.readdirSync(this.logDir).filter(name => /^delegation-audit(?:-\d{8})?\.log$/.test(name)).sort();
+            for (const name of files) {
+                let descriptor;
+                const consume = (line) => {
+                    if (!line.trim())
+                        return;
+                    try {
+                        const event = JSON.parse(line);
+                        const state = event.version === 1 ? readState(event.state) : undefined;
+                        if (state)
+                            visit(state);
+                    }
+                    catch (error) {
+                        this.warn(`忽略损坏的审计记录 ${name}`, error);
+                    }
+                };
+                try {
+                    descriptor = fs.openSync(path.join(this.logDir, name), 'r');
+                    const decoder = new StringDecoder('utf8');
+                    const buffer = Buffer.alloc(64 * 1024);
+                    let pending = '';
+                    let skipping = false;
+                    let bytes;
+                    while ((bytes = fs.readSync(descriptor, buffer, 0, buffer.length, null)) > 0) {
+                        pending += decoder.write(buffer.subarray(0, bytes));
+                        let newline;
+                        while ((newline = pending.indexOf('\n')) >= 0) {
+                            if (!skipping && newline <= 64 * 1024)
+                                consume(pending.slice(0, newline));
+                            pending = pending.slice(newline + 1);
+                            skipping = false;
+                        }
+                        if (pending.length > 64 * 1024) {
+                            pending = '';
+                            skipping = true;
+                            this.warn(`忽略过长的审计记录 ${name}`, new Error('oversized record'));
+                        }
+                    }
+                    if (!skipping)
+                        consume(pending + decoder.end());
+                }
+                catch (error) {
+                    this.warn(`历史审计读取失败 ${name}`, error);
+                }
+                finally {
+                    if (descriptor !== undefined)
+                        fs.closeSync(descriptor);
+                }
+            }
+        }
+        catch (error) {
+            this.warn('历史审计读取失败', error);
+        }
+    }
+    save() {
+        if (Date.now() - this.lastCleanup > 3_600_000) {
+            for (const [key, state] of this.states) {
+                if (this.retained(state))
+                    continue;
+                this.states.delete(key);
+                const credentials = this.credentialsByHash.get(state.tokenHash);
+                credentials?.delete(key);
+                if (credentials?.size === 0)
+                    this.credentialsByHash.delete(state.tokenHash);
+            }
+            this.lastCleanup = Date.now();
+        }
+        if (!this.persistenceEnabled())
+            return;
+        this.writeIndex();
+    }
+    writeIndex() {
+        try {
+            fs.mkdirSync(path.dirname(this.indexPath), { recursive: true, mode: 0o700 });
+            if (fs.existsSync(this.indexPath))
+                fs.chmodSync(this.indexPath, 0o600);
+            stableWriteJson(this.indexPath, { version: 1, states: [...this.states.values()].filter(state => this.retained(state)) });
+        }
+        catch (error) {
+            this.warn('诊断索引写入失败', error);
+        }
+    }
+    persistenceEnabled() {
+        let enabled = false;
+        try {
+            enabled = isDelegationDiagnosticsEnabled();
+        }
+        catch (error) {
+            this.warn('诊断开关读取失败，暂停持久化', error);
+        }
+        if (enabled && this.persistenceState === false)
+            this.writeIndex();
+        this.persistenceState = enabled;
+        if (enabled)
+            return true;
+        this.writer?.close();
+        this.writer = undefined;
+        return false;
+    }
+    warn(action, error) {
+        const code = error.code ?? 'storage_error';
+        const key = `${action}:${code}`;
+        if (Date.now() - (this.lastWarnings.get(key) ?? 0) < 60_000)
+            return;
+        this.lastWarnings.set(key, Date.now());
+        logger.warn(`[DelegationDiagnostics] ${action}: ${code}; index=${this.indexPath}; logs=${this.logDir}; 请检查文件权限、磁盘空间及诊断记录完整性；历史记录不参与授权。`);
+    }
+}

package/dist/core/auth/operation-authorizer.js

@@ -951,7 +951,7 @@ function ownPeerOnlyDenialReason(ctx, requestedPeer) {
     const currentPeer = ctx.actorId || peerIdFromArg(ctx.peerKey || '') || '当前私聊对端';
     const target = requestedPeer || '指定目标';
     return `当前托管会话只能联系当前私聊对端（${currentPeer}），不能联系第三方目标（${target}）。`
-        + ' 如果本次请求来自 handoff，请执行 ec handoff return <handoff-id> "<失败原因>"（已有命令）将失败原因反馈给原会话；'
+        + ` 如果本次请求来自 handoff，请执行 ec handoff return <handoff-id> '<失败原因>'（已有命令）将失败原因反馈给原会话；`
         + '否则请让目标先直接发起会话，或由 Agent owner 为当前角色配置允许 relay/第三方外联后再发送。';
 }
 function peerIdFromArg(value) {

package/dist/core/auth/operation-catalog.js

@@ -1207,6 +1207,22 @@ const OPERATIONS = [
         description: '通过 ec ctl file 向当前会话发送项目文件',
         sources: ['agent-tool'],
     },
+    ...['grant', 'revoke'].map(action => ({
+        id: `ec.ctl.path.${action}`,
+        category: 'write-agent',
+        dangerous: true,
+        defaultScopes: ['relation', 'agent'],
+        description: `${action} a runtime path grant for the current managed session (owner/admin only)`,
+        sources: ['agent-tool'],
+    })),
+    {
+        id: 'ec.ctl.path.list',
+        category: 'read',
+        dangerous: false,
+        defaultScopes: ['relation'],
+        description: 'List runtime path grants for the current managed session',
+        sources: ['agent-tool'],
+    },
     ...['read', 'clear', 'cancel', 'interrupt'].map(action => ({
         id: `ec.ctl.queue.${action}`,
         category: action === 'read' ? 'read' : 'write-own',

package/dist/core/command/agent-control.js

@@ -583,9 +583,24 @@ export async function execAgentUpdate(args, subject) {
     if (p.channels !== undefined && p.channelOwners !== undefined) {
         return { error: 'channels 与 channelOwners 不能同时提交', code: 'INVALID_ARGS' };
     }
-    const config = cfgRead(ConfigTarget.Agent, { self: a.aid });
+    const config = cfgRead(ConfigTarget.Agent, { self: a.aid }, { cache: false });
     if (!config)
         return { error: `Agent "${a.aid}" not found`, code: 'NOT_FOUND' };
+    if (p.fullaccess !== undefined) {
+        if (!p.fullaccess || typeof p.fullaccess !== 'object' || Array.isArray(p.fullaccess)) {
+            return { error: 'fullaccess 必须是对象', code: 'INVALID_ARGS' };
+        }
+        const fullaccess = p.fullaccess;
+        if (Object.keys(fullaccess).some(key => key !== 'enabled')) {
+            return { error: 'fullaccess 只支持 enabled 字段', code: 'INVALID_ARGS' };
+        }
+        if (typeof fullaccess.enabled !== 'boolean') {
+            return { error: 'fullaccess.enabled 必须是布尔值', code: 'INVALID_ARGS' };
+        }
+        const denied = agentFullAccessWriteError(a.aid, subject);
+        if (denied)
+            return { error: denied, code: 'FORBIDDEN' };
+    }
     // Legacy App requests share the canonical validation, storage and agent.md publication flow.
     if (Object.hasOwn(p, 'avatar'))
         return execAidAvatar({ aid: a.aid, data: p.avatar });
@@ -640,27 +655,7 @@ export async function execAgentUpdate(args, subject) {
         touched = true;
     }
     if (p.fullaccess !== undefined) {
-        if (!p.fullaccess || typeof p.fullaccess !== 'object' || Array.isArray(p.fullaccess)) {
-            return { error: 'fullaccess 必须是对象', code: 'INVALID_ARGS' };
-        }
-        const fullaccess = p.fullaccess;
-        if (Object.keys(fullaccess).some(key => key !== 'enabled')) {
-            return { error: 'fullaccess 只支持 enabled 字段', code: 'INVALID_ARGS' };
-        }
-        if (fullaccess.enabled !== undefined && typeof fullaccess.enabled !== 'boolean') {
-            return { error: 'fullaccess.enabled 必须是布尔值', code: 'INVALID_ARGS' };
-        }
-        if (typeof fullaccess.enabled !== 'boolean')
-            return { error: 'fullaccess.enabled is required', code: 'INVALID_ARGS' };
-        const denied = agentFullAccessWriteError({
-            daemonOwner: subject?.isDaemonOwner === true,
-            ecwebManagement: subject?.ecwebManagement === true,
-            delegated: subject?.canApprovePersistentFullAccess === false || subject?.chatType === 'group',
-            enabled: fullaccess.enabled,
-        });
-        if (denied)
-            return { error: denied, code: 'FORBIDDEN' };
-        config.fullaccess = { enabled: fullaccess.enabled };
+        config.fullaccess = { enabled: p.fullaccess.enabled };
         touched = true;
     }
     if (p.chatmode !== undefined) {
@@ -747,10 +742,7 @@ export async function execAgentQuery(args, service, subject) {
         safeConfig,
         fullaccessStatus: {
             ...fullaccessStatus,
-            canConfigure: subject?.ecwebManagement === true
-                && subject?.isDaemonOwner === true
-                && subject.canApprovePersistentFullAccess !== false
-                && subject.chatType !== 'group',
+            canConfigure: agentFullAccessWriteError(aid, subject) === undefined,
         },
     };
     // 叠加构建进度（create 受理后、ready 前可见；ready 后文件仍在，可反映软失败 warn）