evolcore 0.0.26 → 0.0.27

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

@@ -25,6 +25,7 @@ const GROUP_MANAGEMENT_OPERATIONS = [
     ['ec.group.list', 'read', ['agent'], 'List groups joined by the current Agent'],
     ['ec.group.info', 'read', ['relation', 'agent'], 'Read group information'],
     ['ec.group.pull', 'read', ['relation', 'agent'], 'Pull group messages'],
+    ['ec.group.history', 'read', ['relation', 'agent'], 'Read local group conversation history'],
     ['ec.group.members', 'read', ['relation', 'agent'], 'List group members'],
     ['ec.group.online', 'read', ['relation', 'agent'], 'List online group members'],
     ['ec.group.rules.get', 'read', ['relation', 'agent'], 'Read the published group rules file'],
@@ -47,6 +48,11 @@ const GROUP_MANAGEMENT_OPERATIONS = [
     ['ec.group.owner', 'write-agent', ['agent'], 'Transfer group ownership'],
     ['ec.group.ban', 'write-agent', ['agent'], 'Read or update the group ban list'],
     ['ec.group.unban', 'write-agent', ['agent'], 'Remove a group ban'],
+    ['ec.group.block', 'write-own', ['relation', 'agent'], 'Block group message reception'],
+    ['ec.group.unblock', 'write-own', ['relation', 'agent'], 'Unblock group message reception'],
+    ['ec.group.blocklist', 'read', ['agent'], 'Read the group block list'],
+    ['ec.group.report-status', 'write-own', ['relation', 'agent'], 'Report the current Agent group status'],
+    ['ec.group.member-statuses', 'read', ['relation', 'agent'], 'Read reported group member statuses'],
     ['ec.group.rules.set', 'write-agent', ['agent'], 'Upload and publish group rules content'],
     ['ec.group.rules.publish', 'write-agent', ['agent'], 'Publish the current group rules file'],
     ['ec.group.rules.update', 'write-agent', ['agent'], 'Update group join rules'],
@@ -365,6 +371,86 @@ const OPERATIONS = [
         description: '获取文件内容（需路径沙箱检查）',
         sources: ['slash', 'menu'],
     },
+    {
+        id: 'file.root.agent',
+        category: 'read',
+        dangerous: false,
+        defaultScopes: ['agent'],
+        description: '获取 Agent 内部数据根目录句柄',
+        sources: ['menu'],
+    },
+    {
+        id: 'file.root.relation',
+        category: 'read',
+        dangerous: false,
+        defaultScopes: ['relation', 'agent'],
+        description: '获取当前或 owner 指定关系的共享数据根目录句柄',
+        sources: ['menu'],
+    },
+    {
+        id: 'file.data.list',
+        category: 'read',
+        dangerous: false,
+        defaultScopes: ['relation', 'agent'],
+        description: '列出已授权内部数据根目录',
+        sources: ['menu'],
+    },
+    {
+        id: 'file.data.query',
+        category: 'read',
+        dangerous: false,
+        defaultScopes: ['relation', 'agent'],
+        description: '查询已授权内部数据根文件元信息',
+        sources: ['menu'],
+    },
+    {
+        id: 'file.data.fetch',
+        category: 'read',
+        dangerous: false,
+        defaultScopes: ['relation', 'agent'],
+        description: '下载已授权内部数据根文件',
+        sources: ['menu'],
+    },
+    {
+        id: 'file.root.storage',
+        category: 'read',
+        dangerous: false,
+        defaultScopes: ['agent'],
+        description: '获取 Agent 自有云存储根句柄',
+        sources: ['menu'],
+    },
+    {
+        id: 'file.storage.list',
+        category: 'read',
+        dangerous: false,
+        defaultScopes: ['agent'],
+        description: '列出 Agent 自有云存储目录',
+        sources: ['menu'],
+    },
+    {
+        id: 'file.storage.query',
+        category: 'read',
+        dangerous: false,
+        defaultScopes: ['agent'],
+        description: '查询 Agent 自有云存储元信息',
+        sources: ['menu'],
+    },
+    {
+        id: 'file.storage.fetch',
+        category: 'read',
+        dangerous: false,
+        defaultScopes: ['agent'],
+        description: '获取 Agent 自有云存储短时下载链接',
+        sources: ['menu'],
+    },
+    {
+        id: 'file.storage.quota',
+        category: 'read',
+        dangerous: false,
+        defaultScopes: ['agent'],
+        description: '查询 Agent 自有云存储配额',
+        sources: ['menu'],
+    },
     // ── Trigger Operations ──
     {
         id: 'trigger.list',
@@ -624,6 +710,14 @@ const OPERATIONS = [
         description: '读取或更新当前 Agent 的 persona.md',
         sources: ['agent-tool', 'control'],
     },
+    {
+        id: 'agent.welcome',
+        category: 'write-agent',
+        dangerous: false,
+        defaultScopes: ['agent'],
+        description: '读取或更新当前 Agent 的 Bootstrap welcome.md',
+        sources: ['agent-tool', 'control'],
+    },
     {
         id: 'agent.create',
         category: 'process',
@@ -632,6 +726,14 @@ const OPERATIONS = [
         description: '创建新 agent',
         sources: ['menu', 'menu.cli', 'agent-tool', 'control'],
     },
+    {
+        id: 'agent.initialize',
+        category: 'process',
+        dangerous: true,
+        defaultScopes: ['control'],
+        description: 'Create and initialize an Agent from an explicit final plan',
+        sources: ['menu', 'menu.cli', 'agent-tool', 'control'],
+    },
     {
         id: 'agent.enable',
         category: 'process',
@@ -935,6 +1037,14 @@ const OPERATIONS = [
     ...HANDOFF_READ_OPERATIONS,
     ...HANDOFF_WRITE_OPERATIONS,
     ...QUEUE_OPERATIONS,
+    {
+        id: 'ec.task.resume',
+        category: 'write-agent',
+        dangerous: false,
+        defaultScopes: ['agent'],
+        description: 'Resume a paused or abnormally interrupted Agent session task',
+        sources: ['agent-tool', 'control'],
+    },
     {
         id: 'ec.version',
         category: 'read',

package/dist/core/auth/remote-access-store.js

@@ -12,13 +12,21 @@ export function remoteAccessTokenStorePath() {
 function loadStore() {
     try {
         const value = JSON.parse(fs.readFileSync(remoteAccessTokenStorePath(), 'utf8'));
-        if (Array.isArray(value.tokens))
-            return value;
+        if (Array.isArray(value.tokens)) {
+            return {
+                tokens: value.tokens,
+                pairingIssuances: Array.isArray(value.pairingIssuances) ? value.pairingIssuances : [],
+            };
+        }
     }
     catch { }
-    return { tokens: [] };
+    return { tokens: [], pairingIssuances: [] };
 }
 function saveStore(store) {
+    // Issuance history contains no credentials. Keep 30 days; live tokens retain
+    // their own provenance even after the corresponding history is pruned.
+    const cutoff = Date.now() - 30 * 24 * 60 * 60 * 1000;
+    store.pairingIssuances = store.pairingIssuances.filter(record => record.expiresAt >= cutoff);
     const file = remoteAccessTokenStorePath();
     fs.mkdirSync(path.dirname(file), { recursive: true });
     const temporary = `${file}.${process.pid}.tmp`;
@@ -87,6 +95,12 @@ export class RemoteAccessService {
     pairingCode = '';
     pairingExpiresAt = 0;
     pairingAuthorizedBy;
+    pairingId = '';
+    pairingIssuedAt = 0;
+    pairingIssuers = [];
+    // Do not recycle consumed codes during their original validity window,
+    // including when other sources have issued intervening codes.
+    recentPairingCodes = new Map();
     /** Synchronous reservation: concurrent invitations cannot issue two grants. */
     issueDiagnosticToken(controlAid, agentAid, ownerAid, now = Date.now()) {
         const store = loadStore();
@@ -124,18 +138,62 @@ export class RemoteAccessService {
         saveStore(store);
         return record;
     }
-    getPairingCode(authorizedBy, now = Date.now()) {
-        if (!this.pairingCode || now >= this.pairingExpiresAt) {
-            this.pairingCode = String(crypto.randomInt(0, 1_000_000)).padStart(6, '0');
+    getPairingCode(authorizedBy, now = Date.now(), source = 'host-cli') {
+        const owner = validOwner(authorizedBy);
+        if (!['host-cli', 'pair', 'menu', 'ecweb-local'].includes(source)
+            || ((source === 'pair' || source === 'menu') && !owner)) {
+            throw new Error('pairing source requires a valid source and an owner for /pair or Menu');
+        }
+        const generated = !this.pairingCode || now >= this.pairingExpiresAt;
+        if (generated) {
+            for (const [code, expiresAt] of this.recentPairingCodes) {
+                if (now >= expiresAt)
+                    this.recentPairingCodes.delete(code);
+            }
+            // Choose uniformly from unused values without an unbounded retry loop.
+            let code = crypto.randomInt(0, 1_000_000 - this.recentPairingCodes.size);
+            for (const occupied of [...this.recentPairingCodes.keys()].sort((a, b) => a - b)) {
+                if (occupied > code)
+                    break;
+                code++;
+            }
+            this.pairingCode = String(code).padStart(6, '0');
+            this.pairingId = crypto.randomUUID();
+            this.pairingIssuedAt = now;
             this.pairingExpiresAt = now + REMOTE_ACCESS_PAIRING_TTL_MS;
+            this.recentPairingCodes.set(code, this.pairingExpiresAt);
             this.pairingAuthorizedBy = undefined;
+            this.pairingIssuers = [];
         }
-        const owner = validOwner(authorizedBy);
+        const previousOwner = this.pairingAuthorizedBy;
         if (!this.pairingAuthorizedBy && owner)
             this.pairingAuthorizedBy = owner;
+        const issuer = {
+            source,
+            issuedAt: now,
+            ...((source === 'pair' || source === 'menu') && owner ? { authorizedBy: owner } : {}),
+        };
+        const addedIssuer = !this.pairingIssuers.some(candidate => candidate.source === issuer.source
+            && candidate.authorizedBy === issuer.authorizedBy);
+        if (addedIssuer) {
+            this.pairingIssuers.push(issuer);
+        }
+        try {
+            this.recordPairingIssuance();
+        }
+        catch (error) {
+            if (generated)
+                this.clearPairingCode();
+            else {
+                this.pairingAuthorizedBy = previousOwner;
+                if (addedIssuer)
+                    this.pairingIssuers.pop();
+            }
+            throw error;
+        }
         return { code: this.pairingCode, expiresAt: this.pairingExpiresAt };
     }
-    redeemPairingCode(code, label, authorizedBy, now = Date.now()) {
+    redeemPairingCode(code, label, now = Date.now()) {
         if (typeof code !== 'string' || !/^\d{6}$/.test(code)) {
             return { ok: false, code: 'INVALID_ARGUMENT', error: 'pairing code must be six digits' };
         }
@@ -149,17 +207,65 @@ export class RemoteAccessService {
         const token = crypto.randomBytes(32).toString('hex');
         const store = loadStore();
         pruneExpired(store, now);
-        const owner = validOwner(authorizedBy) ?? this.pairingAuthorizedBy;
+        const owner = this.pairingAuthorizedBy;
+        const pairingId = this.pairingId;
+        const pairingIssuers = this.pairingIssuers.map(issuer => ({ ...issuer }));
         store.tokens.push({
             token,
             createdAt,
             lastActive: createdAt,
             label: validLabel(label),
             ...(owner ? { authorizedBy: owner } : {}),
+            pairingId,
+            pairingIssuers,
         });
+        const issuance = store.pairingIssuances.find(record => record.pairingId === pairingId);
+        if (issuance) {
+            issuance.redeemedAt = createdAt;
+        }
+        else {
+            store.pairingIssuances.push({
+                pairingId,
+                issuedAt: this.pairingIssuedAt,
+                expiresAt: this.pairingExpiresAt,
+                issuers: pairingIssuers,
+                redeemedAt: createdAt,
+            });
+        }
         saveStore(store);
+        // A pairing code is a one-time capability. Clear it only after the token
+        // and provenance record have been atomically saved. No await separates
+        // validation, persistence and consumption, so concurrent IPC calls cannot
+        // grant the same code twice.
+        this.clearPairingCode();
         return { ok: true, token, expiresAt: createdAt + REMOTE_ACCESS_TOKEN_TTL_MS };
     }
+    clearPairingCode() {
+        this.pairingCode = '';
+        this.pairingExpiresAt = 0;
+        this.pairingAuthorizedBy = undefined;
+        this.pairingId = '';
+        this.pairingIssuedAt = 0;
+        this.pairingIssuers = [];
+    }
+    recordPairingIssuance() {
+        if (!this.pairingId || !this.pairingCode)
+            return;
+        const store = loadStore();
+        const existing = store.pairingIssuances.find(record => record.pairingId === this.pairingId);
+        const record = {
+            pairingId: this.pairingId,
+            issuedAt: this.pairingIssuedAt,
+            expiresAt: this.pairingExpiresAt,
+            issuers: this.pairingIssuers.map(issuer => ({ ...issuer })),
+            ...(existing?.redeemedAt ? { redeemedAt: existing.redeemedAt } : {}),
+        };
+        if (existing)
+            Object.assign(existing, record);
+        else
+            store.pairingIssuances.push(record);
+        saveStore(store);
+    }
     issueLocalToken(label, now = Date.now()) {
         const token = crypto.randomBytes(32).toString('hex');
         const store = loadStore();

package/dist/core/bootstrap-messages.js

@@ -1,10 +1,12 @@
 import fs from 'fs';
+import { loadAgent } from '../config-store.js';
+import { resolveAgentLifecycle } from '../config/lifecycle.js';
 import { agentMdPath, resolvePaths } from '../paths.js';
 import { parseAgentDisplayName, resolveAgentDisplayName } from '../aun/aid/agentmd.js';
-import { generateWelcomeMessage } from '../utils/welcome.js';
+import { generateWelcomeMessage, parseAgentWelcomeMetadata, readAgentWelcomeTemplate, renderPostBootstrapWelcomeMessage, } from '../utils/welcome.js';
 import * as outbox from '../aun/outbox.js';
 import { chatDirPath } from './session/session-fs-store.js';
-import { hasMessageLogOperation } from './message/message-log.js';
+import { hasMessageLogOperation, findMessageLogOperationMessageId } from './message/message-log.js';
 import { isDeliveryTarget, sameDeliveryTarget } from './message/message-utils.js';
 export const BOOTSTRAP_MESSAGE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 export const BOOTSTRAP_NOTIFICATION_WINDOW_MS = 24 * 60 * 60 * 1000;
@@ -32,10 +34,27 @@ export function isPostBootstrapWelcomeOperationId(operationId, aid) {
 export function renderPostBootstrapWelcome(aid, owner, ownerName) {
     const mdPath = agentMdPath(aid);
     const agentMd = fs.existsSync(mdPath) ? fs.readFileSync(mdPath, 'utf-8') : '';
-    const agentName = parseAgentDisplayName(agentMd)
+    const metadata = parseAgentWelcomeMetadata(agentMd);
+    const agentName = metadata.name || parseAgentDisplayName(agentMd)
         || resolveAgentDisplayName(aid)
         || aid.split('.')[0];
     const fallbackOwnerName = owner.replace(/^@/, '').split('.')[0];
+    const template = readAgentWelcomeTemplate(aid);
+    if (template) {
+        return renderPostBootstrapWelcomeMessage({
+            template,
+            agentName,
+            agentDescription: metadata.description,
+            agentAid: aid,
+            agentTags: metadata.tags,
+            ownerName: ownerName || fallbackOwnerName,
+            ownerAid: owner,
+        });
+    }
+    const config = loadAgent(aid);
+    if (config && resolveAgentLifecycle(config) === 'bootstrapping' && config.initialization?.mode !== 'supplied') {
+        throw new Error('WELCOME_REQUIRED: Owner-confirmed welcome.md is required before activation');
+    }
     return generateWelcomeMessage({
         channelType: 'aun',
         agentName,
@@ -49,15 +68,18 @@ export function preparePostBootstrapWelcomeOutbox(aid, owner, ownerName, deliver
     const legacyOperationId = postBootstrapWelcomeOperationId(aid);
     if (hasMessageLogOperation(chatDir, operationId) || hasMessageLogOperation(chatDir, legacyOperationId))
         return;
-    const legacy = outbox.findByDedupeKey(aid, legacyOperationId);
+    const legacy = outbox.findByDedupeKey(aid, legacyOperationId, { includeTerminal: true });
     if (legacy?.channelId === owner)
         return;
-    const existing = outbox.findByDedupeKey(aid, operationId);
+    const existing = outbox.findByDedupeKey(aid, operationId, { includeTerminal: true });
     if (existing
         && existing.channelId === owner
         && isDeliveryTarget(existing.delivery)
         && sameDeliveryTarget(existing.delivery, delivery))
         return;
+    // Render before touching an existing route record: malformed content must not
+    // remove the only durable record of an earlier attempt.
+    const text = renderPostBootstrapWelcome(aid, owner, ownerName);
     if (existing)
         outbox.remove(aid, existing.id);
     outbox.enqueue(aid, {
@@ -66,7 +88,7 @@ export function preparePostBootstrapWelcomeOutbox(aid, owner, ownerName, deliver
         dedupeKey: operationId,
         critical: true,
         type: 'text',
-        text: renderPostBootstrapWelcome(aid, owner, ownerName),
+        text,
         ttl: BOOTSTRAP_MESSAGE_TTL_MS,
         context: {
             delivery,
@@ -79,6 +101,43 @@ export function preparePostBootstrapWelcomeOutbox(aid, owner, ownerName, deliver
         },
     });
 }
+/** Read durable evidence, including failures and already accepted operations. */
+export function postBootstrapWelcomeStatus(aid, owners) {
+    const entries = findPostBootstrapWelcomeOutbox(aid, { includeTerminal: true });
+    return {
+        deliveries: Array.from(new Set(owners)).map(owner => {
+            const operationId = postBootstrapWelcomeOperationId(aid, owner);
+            const chatDir = chatDirPath(resolvePaths().sessionsDir, 'aun', owner, aid);
+            const loggedId = findMessageLogOperationMessageId(chatDir, operationId)
+                ?? findMessageLogOperationMessageId(chatDir, postBootstrapWelcomeOperationId(aid));
+            const entry = entries.find(candidate => candidate.channelId === owner
+                && candidate.delivery?.chatType === 'private'
+                && (candidate.dedupeKey === operationId || candidate.dedupeKey === postBootstrapWelcomeOperationId(aid)));
+            const base = { owner, operationId, ...(entry ? { outboxId: entry.id } : {}) };
+            if (loggedId)
+                return { ...base, status: 'sent', messageId: loggedId };
+            if (!entry)
+                return { ...base, status: 'not_prepared' };
+            const state = outbox.deliveryState(aid, entry.id);
+            if (state.status === 'sent' || state.status === 'failed')
+                return { ...base, ...state };
+            if (state.status === 'missing')
+                return { ...base, status: 'not_prepared' };
+            return { ...base, status: 'queued', error: entry.lastError, code: entry.lastErrorCode };
+        }),
+    };
+}
+/** Supersede unsent setup prompts when the agent becomes active. Keep diagnostic evidence. */
+export function cancelPendingBootstrapPrompts(aid) {
+    for (const entry of outbox.findByDedupePrefix(aid, bootstrapInitialMessageOperationPrefix(aid))) {
+        if (entry.deliveryReceipt)
+            continue;
+        outbox.markTerminal(aid, entry.id, {
+            code: 'BOOTSTRAP_SUPERSEDED',
+            error: 'Bootstrap is complete; the initial prompt is no longer needed',
+        }, entry);
+    }
+}
 export function hasPendingPostBootstrapWelcomeOutbox(aid) {
     return findPostBootstrapWelcomeOutbox(aid)
         .some(entry => outbox.isDeliveryForChannel(entry.delivery, entry.channelId));
@@ -92,7 +151,7 @@ export function findPostBootstrapWelcomeOutbox(aid, opts = {}) {
 }
 export function pendingPostBootstrapWelcomeOwners(aid) {
     return findPostBootstrapWelcomeOutbox(aid)
-        .filter(entry => outbox.isDeliveryForChannel(entry.delivery, entry.channelId))
+        .filter(entry => !entry.context?.sessionId && outbox.isDeliveryForChannel(entry.delivery, entry.channelId))
         .map(entry => entry.channelId)
         .filter((owner, index, all) => all.indexOf(owner) === index);
 }