evolcore 0.0.21 → 0.0.23

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

@@ -0,0 +1,135 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolvePaths } from '../../paths.js';
+export const REMOTE_ACCESS_TOKEN_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+export const REMOTE_ACCESS_PAIRING_TTL_MS = 5 * 60 * 1000;
+export function remoteAccessTokenStorePath() {
+    return path.join(resolvePaths().instanceDir, 'control-access-tokens.json');
+}
+function loadStore() {
+    try {
+        const value = JSON.parse(fs.readFileSync(remoteAccessTokenStorePath(), 'utf8'));
+        if (Array.isArray(value.tokens))
+            return value;
+    }
+    catch { }
+    return { tokens: [] };
+}
+function saveStore(store) {
+    const file = remoteAccessTokenStorePath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temporary = `${file}.${process.pid}.tmp`;
+    try {
+        fs.writeFileSync(temporary, JSON.stringify(store, null, 2) + '\n', { mode: 0o600 });
+        fs.renameSync(temporary, file);
+        try {
+            fs.chmodSync(file, 0o600);
+        }
+        catch { }
+    }
+    finally {
+        if (fs.existsSync(temporary)) {
+            try {
+                fs.unlinkSync(temporary);
+            }
+            catch { }
+        }
+    }
+}
+function pruneExpired(store, now) {
+    const before = store.tokens.length;
+    store.tokens = store.tokens.filter(record => typeof record?.token === 'string'
+        && typeof record.lastActive === 'number'
+        && now - record.lastActive < REMOTE_ACCESS_TOKEN_TTL_MS);
+    return store.tokens.length !== before;
+}
+function validLabel(value) {
+    if (typeof value !== 'string')
+        return 'remote';
+    const normalized = value.trim().replace(/[\r\n]/g, ' ').slice(0, 256);
+    return normalized || 'remote';
+}
+function validOwner(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const normalized = value.trim();
+    if (!normalized || normalized.length > 512 || /[\r\n]/.test(normalized))
+        return undefined;
+    return normalized;
+}
+/** Validate and slide the expiry window of a daemon-owned remote token. */
+export function validateAndRenewRemoteAccessToken(token, now = Date.now()) {
+    if (typeof token !== 'string' || !token || token.length > 512)
+        return { valid: false };
+    try {
+        const store = loadStore();
+        const changed = pruneExpired(store, now);
+        const record = store.tokens.find(candidate => candidate.token === token);
+        if (!record) {
+            if (changed)
+                saveStore(store);
+            return { valid: false };
+        }
+        record.lastActive = now;
+        saveStore(store);
+        const authorizedBy = validOwner(record.authorizedBy);
+        return { valid: true, ...(authorizedBy ? { authorizedBy } : {}) };
+    }
+    catch {
+        return { valid: false };
+    }
+}
+export class RemoteAccessService {
+    pairingCode = '';
+    pairingExpiresAt = 0;
+    pairingAuthorizedBy;
+    getPairingCode(authorizedBy, now = Date.now()) {
+        if (!this.pairingCode || now >= this.pairingExpiresAt) {
+            this.pairingCode = String(crypto.randomInt(0, 1_000_000)).padStart(6, '0');
+            this.pairingExpiresAt = now + REMOTE_ACCESS_PAIRING_TTL_MS;
+            this.pairingAuthorizedBy = undefined;
+        }
+        const owner = validOwner(authorizedBy);
+        if (!this.pairingAuthorizedBy && owner)
+            this.pairingAuthorizedBy = owner;
+        return { code: this.pairingCode, expiresAt: this.pairingExpiresAt };
+    }
+    redeemPairingCode(code, label, authorizedBy, now = Date.now()) {
+        if (typeof code !== 'string' || !/^\d{6}$/.test(code)) {
+            return { ok: false, code: 'INVALID_ARGUMENT', error: 'pairing code must be six digits' };
+        }
+        if (!this.pairingCode || now >= this.pairingExpiresAt) {
+            return { ok: false, code: 'PAIRING_EXPIRED', error: 'pairing code has expired' };
+        }
+        if (code !== this.pairingCode) {
+            return { ok: false, code: 'PAIRING_INVALID', error: 'pairing code is invalid' };
+        }
+        const createdAt = now;
+        const token = crypto.randomBytes(32).toString('hex');
+        const store = loadStore();
+        pruneExpired(store, now);
+        const owner = validOwner(authorizedBy) ?? this.pairingAuthorizedBy;
+        store.tokens.push({
+            token,
+            createdAt,
+            lastActive: createdAt,
+            label: validLabel(label),
+            ...(owner ? { authorizedBy: owner } : {}),
+        });
+        saveStore(store);
+        return { ok: true, token, expiresAt: createdAt + REMOTE_ACCESS_TOKEN_TTL_MS };
+    }
+    issueLocalToken(label, now = Date.now()) {
+        const token = crypto.randomBytes(32).toString('hex');
+        const store = loadStore();
+        pruneExpired(store, now);
+        store.tokens.push({ token, createdAt: now, lastActive: now, label: validLabel(label) });
+        saveStore(store);
+        return { ok: true, token, expiresAt: now + REMOTE_ACCESS_TOKEN_TTL_MS };
+    }
+    validateToken(token, now = Date.now()) {
+        return validateAndRenewRemoteAccessToken(token, now);
+    }
+}
+export const remoteAccessService = new RemoteAccessService();

package/dist/core/bootstrap-messages.js

@@ -7,9 +7,17 @@ import { chatDirPath } from './session/session-fs-store.js';
 import { hasMessageLogOperation } 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;
 export function bootstrapInitialMessageOperationId(aid) {
     return `bootstrap-initial:v1:${aid}`;
 }
+export function bootstrapInitialMessageOperationPrefix(aid) {
+    return `bootstrap-initial:v1:${aid}`;
+}
+/** A new operation ID is required after the notification window expires. */
+export function bootstrapInitialRetryOperationId(aid, at = Date.now()) {
+    return `${bootstrapInitialMessageOperationPrefix(aid)}:${at}`;
+}
 export function postBootstrapWelcomeOperationId(aid) {
     return `bootstrap-complete:v1:${aid}`;
 }

package/dist/core/bootstrap-service.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import { randomBytes } from 'crypto';
-import { kitsTemplatesDir, agentMdPath } from '../paths.js';
+import { kitsTemplatesDir, agentMdPath, resolvePaths } from '../paths.js';
 import { buildInitialAgentMd, resolveAgentDisplayName } from '../aun/aid/agentmd.js';
 import { logger } from '../utils/logger.js';
 import { loadAgent, saveAgent } from '../config-store.js';
@@ -9,7 +9,10 @@ import { resolveAgentLifecycle, withLifecycleForWrite } from '../config/lifecycl
 import { renderTemplate } from '../eck/manifest-engine.js';
 import { activeBaseagent } from './model/config-scope.js';
 import { buildEnvelope } from './message/message-utils.js';
-import { BOOTSTRAP_MESSAGE_TTL_MS, bootstrapInitialMessageOperationId } from './bootstrap-messages.js';
+import { BOOTSTRAP_MESSAGE_TTL_MS, BOOTSTRAP_NOTIFICATION_WINDOW_MS, bootstrapInitialMessageOperationId, bootstrapInitialMessageOperationPrefix, bootstrapInitialRetryOperationId, } from './bootstrap-messages.js';
+import { findLatestMessageLogOperation } from './message/message-log.js';
+import * as outbox from '../aun/outbox.js';
+import { chatDirPath } from './session/session-fs-store.js';
 /** Coordinate the write-ahead completion welcome with the lifecycle commit. */
 export async function completeBootstrapWithWelcome(service, aid, welcome, sessions) {
     const lifecycle = service.lifecycleOf(aid);
@@ -102,6 +105,7 @@ export class BootstrapService {
     agentRegistry;
     eventBus;
     inFlight = new Set();
+    notifiedInProcess = new Map();
     constructor(agentRegistry, eventBus) {
         this.agentRegistry = agentRegistry;
         this.eventBus = eventBus;
@@ -161,41 +165,58 @@ export class BootstrapService {
         try {
             const agentName = this.resolveAgentDisplayName(aid);
             const baseagent = this.resolveBaseagent(agent, aid);
+            const notificationState = this.bootstrapNotificationState({
+                aid,
+                channelType,
+                channelId,
+                channelKey: ctx.channelKey,
+            });
+            const operationId = starting && !notificationState.hasCompletedHistory
+                ? bootstrapInitialMessageOperationId(aid)
+                : bootstrapInitialRetryOperationId(aid);
+            const shouldSend = !notificationState.recentlyNotified;
             if (starting) {
                 await this.publishAgentMdIfSupported(ctx.adapter, aid, agentName);
                 this.setLifecycle(agent, aid, 'bootstrapping');
                 lifecycleStarted = true;
             }
-            const text = this.renderWelcome({
-                agentAid: aid,
-                agentName,
-                ownerName: ctx.recipientName || recipientId,
-                channel: channelType || ctx.channelKey,
-                baseagent,
-            });
-            await ctx.adapter.send(buildEnvelope({
-                taskId: `bootstrap-${randomBytes(5).toString('hex')}`,
-                channel: ctx.adapter.channelKey || ctx.adapter.channelName,
-                channelId,
-                agentName: aid,
-                replyContext: {
-                    delivery,
-                    metadata: {
-                        source: 'daemon',
-                        persistRequired: true,
-                        operationId: bootstrapInitialMessageOperationId(aid),
-                        outboxTtl: BOOTSTRAP_MESSAGE_TTL_MS,
-                        criticalDelivery: true,
+            if (shouldSend) {
+                const text = this.renderWelcome({
+                    agentAid: aid,
+                    agentName,
+                    ownerName: ctx.recipientName || recipientId,
+                    channel: channelType || ctx.channelKey,
+                    baseagent,
+                });
+                await ctx.adapter.send(buildEnvelope({
+                    taskId: `bootstrap-${randomBytes(5).toString('hex')}`,
+                    operationId,
+                    channel: ctx.adapter.channelKey || ctx.adapter.channelName,
+                    channelId,
+                    agentName: aid,
+                    replyContext: {
+                        delivery,
+                        metadata: {
+                            source: 'daemon',
+                            persistRequired: true,
+                            operationId,
+                            outboxTtl: BOOTSTRAP_MESSAGE_TTL_MS,
+                            criticalDelivery: true,
+                        },
                     },
-                },
-            }), { kind: 'result.text', text, isFinal: true });
+                }), { kind: 'result.text', text, isFinal: true });
+                this.notifiedInProcess.set(aid, Date.now());
+            }
             if (starting) {
                 this.eventBus.publish({ type: 'agent:bootstrap-started', aid, channel: channelType || ctx.channelKey, timestamp: Date.now() });
                 logger.info(`[Bootstrap] Started for ${aid} via ${ctx.channelKey} (${ctx.source})`);
             }
-            else {
+            else if (shouldSend) {
                 logger.info(`[Bootstrap] Reconciled initial message for ${aid} via ${ctx.channelKey} (${ctx.source})`);
             }
+            else {
+                logger.debug(`[Bootstrap] Initial message already sent within the notification window for ${aid}`);
+            }
             return true;
         }
         catch (e) {
@@ -288,6 +309,53 @@ export class BootstrapService {
             return 'unknown';
         }
     }
+    bootstrapNotificationState(input) {
+        const prefix = bootstrapInitialMessageOperationPrefix(input.aid);
+        const now = Date.now();
+        const cutoff = now - BOOTSTRAP_NOTIFICATION_WINDOW_MS;
+        let latestTs = this.notifiedInProcess.get(input.aid) ?? 0;
+        let latestLoggedOperationId;
+        try {
+            const chatDir = chatDirPath(resolvePaths().sessionsDir, input.channelType || 'aun', input.channelId, input.aid, input.channelKey);
+            let latestLogged = findLatestMessageLogOperation(chatDir, prefix);
+            // Releases before the stable envelope operation ID fix persisted the
+            // random bootstrap task ID instead. Recognize that exact legacy shape
+            // so an upgrade/restart does not immediately resend the welcome.
+            if (!latestLogged) {
+                const legacyLogged = findLatestMessageLogOperation(chatDir, 'bootstrap-');
+                if (legacyLogged && /^bootstrap-[a-f0-9]{10}$/u.test(legacyLogged.operationId)) {
+                    latestLogged = legacyLogged;
+                }
+            }
+            if (latestLogged) {
+                latestTs = Math.max(latestTs, latestLogged.ts);
+                latestLoggedOperationId = latestLogged.operationId;
+            }
+        }
+        catch {
+            // A missing or malformed session path must not prevent bootstrap.
+        }
+        for (const entry of outbox.findByDedupePrefix(input.aid, prefix, { includeTerminal: true })) {
+            // A completed operation no longer needs its queued duplicate. Entries
+            // older than the notification window must not be delivered alongside
+            // the newly generated reminder operation.
+            if (entry.terminal) {
+                outbox.remove(input.aid, entry.id);
+                continue;
+            }
+            if (entry.dedupeKey === latestLoggedOperationId || entry.ts < cutoff) {
+                outbox.remove(input.aid, entry.id);
+                continue;
+            }
+            latestTs = Math.max(latestTs, entry.ts || 0);
+        }
+        const recentlyNotified = latestTs >= cutoff;
+        if (recentlyNotified)
+            this.notifiedInProcess.set(input.aid, latestTs);
+        else
+            this.notifiedInProcess.delete(input.aid);
+        return { recentlyNotified, hasCompletedHistory: !!latestLoggedOperationId };
+    }
     async publishAgentMdIfSupported(adapter, aid, fallbackName) {
         if (typeof adapter.uploadAgentMd !== 'function')
             return;

package/dist/core/command/command-handler.js

@@ -114,7 +114,12 @@ export class CommandHandler {
     triggerSchedulerResolver;
     triggerSchedulerFallback;
     triggerSchedulerFallbackAid;
+    /** Runtime-only owner for the daemon trigger scheduler. It is intentionally
+     * kept outside EvolAgentRegistry because the daemon channel is not an Agent. */
+    daemonTriggerOwnerAid;
+    daemonTriggerChannel = 'daemon';
     daemonStatusProvider;
+    daemonMonitorProvider;
     agentDelegationRegistry;
     handoffRuntime;
     contactRequestSubmitter;
@@ -219,6 +224,32 @@ export class CommandHandler {
     setTriggerSchedulerResolver(resolver) {
         this.triggerSchedulerResolver = resolver;
     }
+    /** Bind the virtual daemon channel to its trigger scheduler owner AID. */
+    setDaemonTriggerOwner(aid, channel = 'daemon') {
+        const normalizedAid = String(aid || '').trim();
+        if (!normalizedAid)
+            throw new Error('daemon trigger owner AID is required');
+        this.daemonTriggerOwnerAid = normalizedAid;
+        this.daemonTriggerChannel = String(channel || 'daemon').trim() || 'daemon';
+    }
+    /** Used by control-menu routing; daemon owner is not in the Agent registry. */
+    getDaemonTriggerOwnerAid(channel = 'daemon') {
+        if (channel !== this.daemonTriggerChannel)
+            return undefined;
+        if (this.daemonTriggerOwnerAid)
+            return this.daemonTriggerOwnerAid;
+        try {
+            const controlAid = String(loadDaemonConfig().aid || '__daemon__').trim() || '__daemon__';
+            const existing = this.agentRegistry?.get?.(controlAid);
+            // Match index.ts: only a runnable (pre-start `stopped`) Agent causes
+            // the daemon scheduler owner to receive the collision suffix.
+            const conflicts = !!existing && (existing.status === undefined || existing.status === 'stopped');
+            return conflicts ? `${controlAid}#daemon` : controlAid;
+        }
+        catch {
+            return undefined;
+        }
+    }
     /** Compatibility entrypoint for older tests/callers that inject a single scheduler. */
     setTriggerScheduler(scheduler, manager) {
         this.triggerSchedulerFallback = scheduler;
@@ -233,6 +264,9 @@ export class CommandHandler {
     setDaemonStatusProvider(provider) {
         this.daemonStatusProvider = provider;
     }
+    setDaemonMonitorProvider(provider) {
+        this.daemonMonitorProvider = provider;
+    }
     /** 返回管理当前通道的 EvolAgent，无则返回 null */
     getOwningAgent(channel) {
         if (!this.agentRegistry)
@@ -240,7 +274,9 @@ export class CommandHandler {
         return this.agentRegistry.resolveByChannel(channel);
     }
     getTriggerSchedulerForChannel(channel) {
-        const agentAid = this.getOwningAgent(channel)?.aid ?? tryParseChannelKey(channel)?.selfAID;
+        const agentAid = this.getOwningAgent(channel)?.aid
+            ?? this.getDaemonTriggerOwnerAid(channel)
+            ?? tryParseChannelKey(channel)?.selfAID;
         return agentAid ? this.triggerSchedulerResolver?.(agentAid) : this.triggerSchedulerFallback;
     }
     getTriggerSchedulerForAgent(agentAid) {
@@ -975,9 +1011,9 @@ export class CommandHandler {
     async execMenuForEcweb(payload, auth) {
         return await menuExecMenuForEcweb.call(this, payload, auth);
     }
-    /** 控制 AID channel 专用入口：peerId 须 ∈ evolcore.owners，全量权限。 */
-    async execMenuForControl(payload, peerId) {
-        return await menuExecMenuForControl.call(this, payload, peerId);
+    /** Control AID Menu entry: daemon-owner or validated remote-access token. */
+    async execMenuForControl(payload, peerId, auth) {
+        return await menuExecMenuForControl.call(this, payload, peerId, auth);
     }
     /**
      * CLI 透传执行：spawn `node dist/cli/index.js <argv>` 子进程，捕获输出回传。
@@ -1119,6 +1155,27 @@ export class CommandHandler {
     async handle(content, channel, channelId, sendMessage, userId, threadId, chatType, source, messageId, selfAID, overrideIdentity, authSubject, replyContext) {
         try {
             const result = await this._handleInternal(content, channel, channelId, sendMessage, userId, threadId, chatType, source, messageId, selfAID, overrideIdentity, authSubject, replyContext);
+            // Lifecycle commands are control-plane operations. Their replies must
+            // use notification payloads so other agents in a group do not treat the
+            // text as ordinary model input. Normalize guard-path replies here too,
+            // since those return before slash-handler command-specific branches.
+            if (/^\/(?:new|renew)(?:\s|$)/i.test(content.trim())
+                && result && typeof result === 'object'
+                && (result.kind === 'command.result' || result.kind === 'command.error')) {
+                const isError = result.kind === 'command.error';
+                return isError
+                    ? {
+                        kind: 'system.error',
+                        text: result.text,
+                        subtype: `session.${content.trim().toLowerCase().startsWith('/new') ? 'new' : 'renew'}.error`,
+                        recoverable: true,
+                    }
+                    : {
+                        kind: 'system.notice',
+                        text: result.text,
+                        subtype: `session.${content.trim().toLowerCase().startsWith('/new') ? 'new' : 'renew'}.result`,
+                    };
+            }
             return result;
         }
         catch (error) {
@@ -1323,7 +1380,7 @@ export class CommandHandler {
 /trigger list [--all] — 查看所有触发器
 /trigger create <参数> — 创建触发器（set 为兼容别名）
 /trigger update <名称|ID> <参数> — 修改触发器
-常用参数：--exec script|trigger-session|target-session（create 必填）、--delay/--at/--cron/--every、--prompt、--model、--effort、--permission（省略则继承；update 可用 inherit 清除覆盖）
+常用参数：--delay/--at/--cron/--every、--prompt、--description、--model、--effort、--permission（省略则继承；update 可用 inherit 清除覆盖）、--feedback、--target-channel/--target-channel-id、--trigger-thread、--baseagent、--on-error、--retry-attempts/--retry-backoff、--script-runtime/--script-args/--script-timeout
 /trigger enable <名称|ID> — 启用触发器
 /trigger disable <名称|ID> — 暂停触发器
 /trigger show <名称|ID> — 查看触发器详情