evolcore 0.0.29 → 0.0.30

package/dist/core/channel-runtime.js

@@ -0,0 +1,435 @@
+import path from 'path';
+import fs from 'fs';
+import { tryParseChannelKey } from './channel-loader.js';
+import { agentMdPath } from '../paths.js';
+import { registerAdapterInteractions } from './interaction-router.js';
+import { resolvePeerDisplayLabel } from '../config/contact-book.js';
+import { sanitizeMenuLogValue } from './command/menu-protocol.js';
+import { appendMessageLog, buildOutboundEntry } from './message/message-log.js';
+import crypto from 'crypto';
+import { buildEnvelope } from './message/message-utils.js';
+import { normalizeMessageSource, outboundPayloadToLogText, resolvePersistedRestartDelivery, sendSystemPayload, shouldCountSentPayload, summarizeOutboundPayload, tagErrorPayloadWithEvolcoreVersion, } from './message/outbound.js';
+import { getFirstStaticAgentOwner } from '../config/peer-role-resolver.js';
+import { isManagementRole } from '../config/builtin-roles.js';
+import { pendingInterruptHints } from './message/pending-hints.js';
+import { logger } from '../utils/logger.js';
+export function createAgentStorageClientResolver(channelInstances) {
+    return (channelKey, targetAid) => {
+        const instance = channelInstances.find(candidate => candidate.channelType === 'aun'
+            && (candidate.adapter.channelKey === channelKey || candidate.adapter.channelName === channelKey)
+            && candidate.channel.getAid?.() === targetAid);
+        if (!instance || instance.channel.getStatus?.().connected !== true)
+            return undefined;
+        const client = instance.channel.getClient?.();
+        return client?.aid === targetAid ? client : undefined;
+    };
+}
+export function bindStartupChannelsToAgents(channelInstances, agentRegistry, agentInstances) {
+    for (const instance of channelInstances) {
+        const agent = agentRegistry.resolveByChannel(instance.adapter.channelKey);
+        if (!agent || agent.status === 'error')
+            continue;
+        agent.channels.set(instance.adapter.channelKey, instance.adapter);
+        const hasRunner = agentInstances.some(runner => runner.evolagentName === agent.aid);
+        if (agent.status === 'stopped' && hasRunner)
+            agent.status = 'running';
+    }
+}
+export function createDefaultChannelPolicy() {
+    return {
+        canSwitchProject: (chatType, role) => chatType === 'private' ? isManagementRole(role) : role === 'owner',
+        canListProjects: (chatType, role) => chatType === 'private' ? isManagementRole(role) : role === 'owner',
+        canCreateSession: () => true,
+        canDeleteSession: (chatType, role) => chatType === 'private' ? isManagementRole(role) : role === 'owner',
+        canImportCliSession: (chatType, role) => chatType === 'private' ? isManagementRole(role) : role === 'owner',
+        messagePrefix: () => '',
+        showMiddleResult: () => true,
+        showIdleMonitor: () => true,
+        accumulateErrors: () => true,
+    };
+}
+export function preloadChannelThreads(channelInstances, sessionManager) {
+    for (const instance of channelInstances) {
+        const channelType = instance.channelType || instance.adapter.channelName;
+        if (channelType === 'feishu' && 'preloadThreads' in instance.channel) {
+            instance.channel.preloadThreads(sessionManager.getKnownThreadIds(instance.adapter.channelKey));
+        }
+    }
+}
+export function createChannelConnectionRuntime(dependencies) {
+    const { channelInstances, connectedChannels } = dependencies;
+    const queuePendingObserverHints = (aid, channelKey) => (pendingInterruptHints(dependencies.sessionsDir, aid)
+        .filter(pending => pending.channelKey === channelKey)
+        .map(pending => dependencies.responseEngine.scheduleObserverHint({ ...pending, selfAid: aid })
+        .then(result => {
+        if (result === 'SESSION_NOT_FOUND')
+            logger.warn(`[ObserverHint] recovery target missing hint=${pending.hintId}`);
+    })
+        .catch(error => logger.warn(`[ObserverHint] recovery failed hint=${pending.hintId}: ${error}`))));
+    const markChannelConnected = async (instance) => {
+        const name = instance.adapter.channelName;
+        const key = instance.adapter.channelKey;
+        if (connectedChannels.has(key))
+            return;
+        connectedChannels.add(name);
+        connectedChannels.add(key);
+        const type = instance.channelType || name;
+        dependencies.eventBus.publish({ type: 'channel:connected', channel: type.toLowerCase(), channelName: name, timestamp: Date.now() });
+        const agent = dependencies.resolveOwningAgent(key, name);
+        if (instance.channelType === 'aun' && agent) {
+            const recoveries = queuePendingObserverHints(agent.aid, key);
+            if (dependencies.isRestoringStartupQueue())
+                dependencies.startupObserverRecoveries.push(...recoveries);
+        }
+        await Promise.all([
+            dependencies.bootstrapService.tryStartBootstrap({
+                adapter: instance.adapter,
+                channelKey: key,
+                channelType: instance.channelType || type,
+                source: 'connected',
+            }),
+            agent ? dependencies.ensureTriggerSchedulerStarted(agent) : Promise.resolve(),
+            Promise.resolve().then(() => dependencies.sendOnlineNoticeForChannel(instance)),
+            dependencies.trySendPendingRestartNotice(),
+        ]);
+    };
+    const markChannelDisconnected = (channelName) => {
+        connectedChannels.delete(channelName);
+        const instance = channelInstances.find(candidate => candidate.adapter.channelName === channelName);
+        if (instance)
+            connectedChannels.delete(instance.adapter.channelKey);
+    };
+    const unregisterRuntimeChannel = (channelName) => {
+        markChannelDisconnected(channelName);
+        dependencies.processor.unregisterChannel(channelName);
+        dependencies.commandHandler.unregisterChannel(channelName);
+        dependencies.messageBridge.removeChannel(channelName);
+    };
+    return { markChannelConnected, markChannelDisconnected, unregisterRuntimeChannel, queuePendingObserverHints };
+}
+export function registerChannelInstance(inst, dependencies) {
+    const { defaultProjectPath, defaultPolicy, processor, commandHandler, interactionRouter, messageBridge, eventBus, sessionManager, responseEngine, resolveOwningAgent, } = dependencies;
+    wrapChannelSend(inst, {
+        eventBus,
+        sessionManager,
+        aidStatsCollector: dependencies.aidStatsCollector,
+        resolveOwningAgent: () => resolveOwningAgent(inst.adapter.channelKey, inst.adapter.channelName),
+    });
+    if (inst.onProjectPathRequest && inst.channel.onProjectPathRequest) {
+        inst.channel.onProjectPathRequest(async (channelId) => {
+            const owningAgent = resolveOwningAgent(inst.adapter.channelKey, inst.adapter.channelName);
+            const effectiveDefault = owningAgent?.projectPath ?? defaultProjectPath;
+            const parsedKey = tryParseChannelKey(inst.adapter.channelKey);
+            const session = await sessionManager.getOrCreateSession(inst.adapter.channelKey, channelId, effectiveDefault, undefined, undefined, undefined, undefined, undefined, owningAgent?.baseagent, parsedKey?.selfAID, parsedKey?.type);
+            return path.isAbsolute(session.projectPath)
+                ? session.projectPath
+                : path.resolve(process.cwd(), session.projectPath);
+        });
+    }
+    const options = inst.channelType
+        ? { ...inst.options, channelType: inst.channelType }
+        : inst.options;
+    processor.registerChannel(inst.adapter, inst.policy || defaultPolicy, options);
+    commandHandler.registerAdapter(inst.adapter);
+    commandHandler.registerChannel(inst.adapter.channelName, inst.channel, inst.channelType);
+    if (inst.policy)
+        commandHandler.registerPolicy(inst.adapter.channelName, inst.policy);
+    registerAdapterInteractions(inst.adapter, interactionRouter);
+    const channelType = inst.channelType || inst.adapter.channelName;
+    inst.registerBridge?.(messageBridge, channelType);
+    inst.registerHooks?.({ eventBus, sessionManager });
+    const channelForObserver = inst.channel;
+    if (typeof channelForObserver.setObserverConfigResolver === 'function') {
+        const channelKey = inst.adapter.channelKey;
+        channelForObserver.setObserverConfigResolver(() => {
+            const owningAgent = resolveOwningAgent(channelKey, inst.adapter.channelName);
+            return {
+                observable: owningAgent?.getObservable() ?? false,
+                owners: owningAgent ? Array.from(new Set(owningAgent.config.owners ?? [])) : [],
+            };
+        });
+    }
+    if (inst.channelType === 'aun') {
+        channelForObserver.setObserverHintRuntime({
+            hasSession: target => responseEngine.hasObserverTargetSession(target),
+            schedule: target => responseEngine.scheduleObserverHint(target),
+        });
+    }
+    inst.channel.onRecall?.((messageId, selfAID) => {
+        messageBridge.cancel(messageId, selfAID);
+    });
+}
+export function createChannelStartupNotifications({ channelInstances, agentRegistry, commandHandler, connectedChannels, pendingFile, upmsg, }) {
+    const onlineNoticeSent = new Set();
+    let pendingRestartNoticeInFlight = null;
+    let pendingRestartNoticeSent = false;
+    const sendOnlineNoticeForChannel = (inst) => {
+        const name = inst.adapter.channelName;
+        const agent = agentRegistry.resolveByChannel(inst.adapter.channelKey) ?? agentRegistry.resolveByChannel(name);
+        if (!agent || !upmsg)
+            return;
+        const ownerAid = getFirstStaticAgentOwner(agent.aid);
+        if (!ownerAid)
+            return;
+        const noticeKey = `${agent.aid}#${name}`;
+        if (onlineNoticeSent.has(noticeKey))
+            return;
+        onlineNoticeSent.add(noticeKey);
+        setTimeout(() => {
+            const adapter = agent.channels.get(inst.adapter.channelKey) ?? agent.channels.get(name);
+            if (!adapter)
+                return;
+            let agentName = agent.aid;
+            try {
+                const content = fs.readFileSync(agentMdPath(agent.aid), 'utf-8');
+                const nameMatch = content.match(/^name:\s*"?([^"\n]+)/m);
+                if (nameMatch)
+                    agentName = nameMatch[1].trim().replace(/"$/, '');
+            }
+            catch { }
+            const projectDir = path.basename(agent.projectPath);
+            const text = `✓ ${agentName} 已上线 | 工作目录: ${projectDir}`;
+            const envelope = buildEnvelope({
+                taskId: `system-online-${crypto.randomBytes(5).toString('hex')}`,
+                channel: adapter.channelName,
+                channelId: ownerAid,
+                agentName,
+                delivery: { chatType: 'private' },
+            });
+            sendSystemPayload(adapter, envelope, {
+                kind: 'system.notice',
+                text,
+                subtype: 'restarted',
+            }).catch(() => { });
+        }, 1000 + Math.random() * 2000);
+    };
+    const trySendPendingRestartNotice = async () => {
+        if (pendingRestartNoticeSent)
+            return;
+        if (pendingRestartNoticeInFlight) {
+            try {
+                await pendingRestartNoticeInFlight;
+            }
+            catch { }
+            return;
+        }
+        if (!fs.existsSync(pendingFile))
+            return;
+        pendingRestartNoticeInFlight = (async () => {
+            if (pendingRestartNoticeSent || !fs.existsSync(pendingFile))
+                return;
+            const pending = JSON.parse(fs.readFileSync(pendingFile, 'utf-8'));
+            const adapter = commandHandler.getAdapter(pending.channel)
+                ?? channelInstances.find(inst => inst.adapter.channelKey === pending.channel)?.adapter;
+            if (!adapter)
+                return;
+            if (!connectedChannels.has(pending.channel)
+                && !connectedChannels.has(adapter.channelName)
+                && !connectedChannels.has(adapter.channelKey)) {
+                logger.info(`[Restart] Pending notification waits for channel connection: ${pending.channel}`);
+                return;
+            }
+            const restartDelivery = resolvePersistedRestartDelivery({
+                channel: pending.channel,
+                adapterChannel: adapter.channelName,
+                channelId: pending.channelId,
+                delivery: pending.delivery,
+            });
+            if (!restartDelivery.valid) {
+                logger.warn(`[Restart] Discarding pending notification without a valid persisted delivery route: channel=${pending.channel} channelId=${pending.channelId}`);
+                fs.rmSync(pendingFile, { force: true });
+                return;
+            }
+            const replyContext = {
+                ...(restartDelivery.delivery ? { delivery: restartDelivery.delivery } : {}),
+                ...(pending.threadId ? { threadId: pending.threadId } : {}),
+                ...(pending.rootId ? { replyToMessageId: pending.rootId, replyInThread: !!pending.threadId } : {}),
+            };
+            const owningAgent = agentRegistry.resolveByChannel(adapter.channelKey);
+            const envelope = buildEnvelope({
+                taskId: `system-restart-${process.pid}`,
+                channel: adapter.channelKey,
+                channelId: pending.channelId,
+                agentName: owningAgent?.aid || 'evolcore',
+                ...(restartDelivery.delivery ? { delivery: restartDelivery.delivery } : {}),
+                replyContext: Object.keys(replyContext).length > 0 ? replyContext : undefined,
+            });
+            const restartNotice = pending.outcome === 'rolled-back'
+                ? {
+                    text: `⚠️ 服务已重启，但运行的是上一个版本。${pending.outcomeReason ? `原因：${pending.outcomeReason}。` : ''}本次改动未生效，请检查后重试。`,
+                    subtype: 'restarted-rolled-back',
+                }
+                : pending.outcome === 'upgraded'
+                    ? {
+                        text: `✅ 服务重启成功！${pending.outcomeReason ? `${pending.outcomeReason}` : ''}`,
+                        subtype: 'restarted-upgraded',
+                    }
+                    : { text: '✅ 服务重启成功！', subtype: 'restarted' };
+            await sendSystemPayload(adapter, envelope, {
+                kind: 'system.notice',
+                text: restartNotice.text,
+                subtype: restartNotice.subtype,
+            });
+            pendingRestartNoticeSent = true;
+            fs.rmSync(pendingFile, { force: true });
+            logger.info(`[Restart] Notification sent via ${pending.channel}`);
+        })();
+        try {
+            await pendingRestartNoticeInFlight;
+        }
+        catch (error) {
+            logger.error('[Restart] Failed to send restart notification:', error);
+        }
+        finally {
+            pendingRestartNoticeInFlight = null;
+        }
+    };
+    const summarizeConnectedChannels = (connected) => {
+        const connectedTypeCount = new Map();
+        const typeOrder = [];
+        for (const inst of channelInstances) {
+            const name = inst.adapter.channelName;
+            if (!connected.includes(name))
+                continue;
+            const type = inst.channelType || name;
+            if (!connectedTypeCount.has(type)) {
+                connectedTypeCount.set(type, 0);
+                typeOrder.push(type);
+            }
+            connectedTypeCount.set(type, connectedTypeCount.get(type) + 1);
+        }
+        return typeOrder
+            .map(type => {
+            const count = connectedTypeCount.get(type);
+            return count === 1 ? type : `${type}×${count}`;
+        })
+            .join(', ');
+    };
+    return { sendOnlineNoticeForChannel, trySendPendingRestartNotice, summarizeConnectedChannels };
+}
+export function registerChannelHealthNotifications({ eventBus, channelInstances, agentRegistry, }) {
+    eventBus.subscribe('channel:error', (event) => {
+        if (event.type !== 'channel:error' || event.status !== 'auth_error')
+            return;
+        const sourceChannelType = event.channel;
+        const sourceChannelName = event.channelName || sourceChannelType;
+        const message = event.message;
+        logger.error(`[ChannelHealth] ${sourceChannelName} auth_error: ${message}`);
+        const notified = new Set();
+        for (const other of channelInstances) {
+            const otherType = other.channelType || other.adapter.channelName;
+            if (otherType === sourceChannelType)
+                continue;
+            if (notified.has(otherType))
+                continue;
+            const owningAgent = agentRegistry.resolveByChannel(other.adapter.channelKey);
+            const ownerId = owningAgent ? getFirstStaticAgentOwner(owningAgent.aid) : undefined;
+            if (!ownerId)
+                continue;
+            notified.add(otherType);
+            const envelope = buildEnvelope({
+                taskId: `system-channel-down-${crypto.randomBytes(5).toString('hex')}`,
+                channel: other.adapter.channelKey,
+                channelId: ownerId,
+                agentName: owningAgent?.aid || 'evolcore',
+                delivery: { chatType: 'private' },
+            });
+            sendSystemPayload(other.adapter, envelope, {
+                kind: 'system.error',
+                text: message,
+                subtype: 'channel_down',
+                recoverable: false,
+            }).catch(error => {
+                logger.error(`[ChannelHealth] Failed to notify ${other.adapter.channelName} owner:`, error);
+            });
+        }
+    });
+}
+/** Wrap a channel send so delivery logging, message statistics, and sent events stay centralized. */
+export function wrapChannelSend(inst, dependencies) {
+    const originalSend = inst.adapter.send.bind(inst.adapter);
+    const adapter = inst.adapter;
+    adapter.send = async (envelope, rawPayload) => {
+        const channelType = inst.channelType || adapter.channelName;
+        const payload = rawPayload ? tagErrorPayloadWithEvolcoreVersion(rawPayload) : rawPayload;
+        const owningAgent = dependencies.resolveOwningAgent();
+        logger.channelOut({
+            channel: adapter.channelName,
+            channelId: envelope.channelId,
+            taskId: envelope.taskId,
+            correlationId: envelope.operationId ?? envelope.taskId,
+            sessionId: envelope.sessionId,
+            agentAid: owningAgent?.aid,
+            agentName: envelope.agentName,
+            payload: sanitizeMenuLogValue(summarizeOutboundPayload(payload)),
+        });
+        const result = await originalSend(envelope, payload);
+        // AUN adapters return an explicit receipt. Only a receipt with a remote
+        // message ID proves delivery; queued/failed results must not be emitted
+        // as `message:sent`. Legacy adapters that return void remain compatible.
+        const deliveryConfirmed = result === undefined
+            || (result && typeof result === 'object' && result.status === 'sent'
+                && typeof result.messageId === 'string'
+                && result.messageId.length > 0);
+        if (shouldCountSentPayload(payload) && deliveryConfirmed) {
+            if (channelType !== 'aun') {
+                try {
+                    const logPayload = outboundPayloadToLogText(payload);
+                    const session = envelope.sessionId
+                        ? await dependencies.sessionManager.getSessionById(envelope.sessionId)
+                        : envelope.replyContext?.threadId
+                            ? await dependencies.sessionManager.getThreadSession(envelope.channel ?? adapter.channelName, envelope.channelId, envelope.replyContext.threadId)
+                            : dependencies.sessionManager.getActiveSessionSync(envelope.channel ?? adapter.channelName, envelope.channelId, channelType, owningAgent?.aid);
+                    if (logPayload && session) {
+                        const chatDir = dependencies.sessionManager.getChatDir(session);
+                        const isGroup = session.chatType === 'group';
+                        const target = isGroup
+                            ? (session.metadata?.groupId || session.channelId)
+                            : (envelope.replyContext?.peerId || session.metadata?.peerId || envelope.channelId);
+                        appendMessageLog(chatDir, buildOutboundEntry({
+                            from: owningAgent?.aid ?? envelope.agentName ?? session.selfAID ?? 'self',
+                            to: String(target || envelope.channelId),
+                            sessionId: session.id,
+                            threadId: envelope.replyContext?.threadId || session.threadId || null,
+                            chatType: isGroup ? 'group' : 'private',
+                            groupId: isGroup ? String(session.metadata?.groupId || session.channelId) : null,
+                            msgId: `${envelope.taskId || 'out'}_${Date.now()}`,
+                            content: logPayload.text,
+                            replyTo: envelope.replyContext?.replyToMessageId ?? null,
+                            agent: session.baseagent ?? null,
+                            model: null,
+                            durationMs: null,
+                            msgType: logPayload.msgType,
+                            source: normalizeMessageSource(envelope.replyContext?.metadata?.source),
+                            chatmode: envelope.chatmode,
+                        }));
+                        // Per-AID 统计（预览行/tooltip 数据源）。AUN 在 channel 层自行记账，此处只补非 AUN。
+                        const statsAid = owningAgent?.aid ?? envelope.agentName ?? session.selfAID;
+                        if (statsAid) {
+                            dependencies.aidStatsCollector.recordOutbound(statsAid, String(target || envelope.channelId), Buffer.byteLength(logPayload.text, 'utf-8'), logPayload.text, false, undefined, envelope.chatmode, 'send', {
+                                channelType,
+                                // 与入向同一套展示名解析：联系人簿 displayName 优先，兜底原生 ID
+                                peerLabel: resolvePeerDisplayLabel(statsAid, channelType, String(target || envelope.channelId), adapter.channelKey) || session.metadata?.peerName || String(target || envelope.channelId),
+                                routeId: envelope.channelId,
+                            });
+                        }
+                    }
+                }
+                catch (error) {
+                    logger.debug(`[MessageLog] Failed to write outbound channel log: ${error}`);
+                }
+            }
+            dependencies.eventBus.publish({
+                type: 'message:sent',
+                sessionId: envelope.sessionId ?? envelope.taskId ?? `out-${Date.now()}`,
+                channel: envelope.channel ?? adapter.channelName,
+                channelName: adapter.channelName,
+                channelId: envelope.channelId,
+                agentName: owningAgent?.aid ?? envelope.agentName,
+                payloadKind: payload.kind,
+                timestamp: Date.now(),
+            });
+        }
+        return result;
+    };
+}

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

@@ -2077,7 +2077,10 @@ export class CommandHandler {
         if (sessionSelfAid && sessionSelfAid !== grantSelfAid) {
             return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation self agent does not match the active session' };
         }
-        const requiresSelfAid = parsed.command.kind === 'show' || parsed.command.kind === 'agentmd.put' || parsed.command.kind === 'avatar';
+        const requiresSelfAid = parsed.command.kind === 'show'
+            || parsed.command.kind === 'agentmd.put'
+            || parsed.command.kind === 'agentmd.set'
+            || parsed.command.kind === 'avatar';
         if (requiresSelfAid
             && parsed.command.aid !== grantSelfAid
             && (parsed.command.kind === 'avatar' || !hasTrustedFullAccessDelegation(delegation.grant))) {

package/dist/core/daemon-bootstrap.js

@@ -0,0 +1,151 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../paths.js';
+import { AUNChannel } from '../channels/aun.js';
+import { BindService } from '../utils/aid-bind.js';
+import { commandExists } from '../utils/cross-platform.js';
+import { logger } from '../utils/logger.js';
+import { remoteAccessService } from './auth/remote-access-store.js';
+import { IpcServer } from '../ipc.js';
+import { removeAll } from '../utils/instance-registry.js';
+import { controlReplyContext } from './message/outbound.js';
+import { TriggerDefinitionManager } from '../trigger/manager.js';
+import { seedUpgradeCheckTrigger } from '../trigger/system-definitions.js';
+export function detectAvailableBaseagents() {
+    const out = [];
+    for (const command of ['claude', 'gemini', 'codex']) {
+        if (commandExists(command))
+            out.push(command);
+    }
+    return out;
+}
+export async function runBindBootstrapDaemon(daemonCfg) {
+    logger.warn('[daemon-bootstrap] starting control AID + IPC only');
+    const bootstrapControlAid = daemonCfg.aid || '__daemon__';
+    try {
+        seedUpgradeCheckTrigger(new TriggerDefinitionManager(bootstrapControlAid), {
+            aid: bootstrapControlAid,
+            originPeerId: bootstrapControlAid,
+            baseagent: 'codex',
+        });
+    }
+    catch (error) {
+        logger.warn(`[daemon-bootstrap] failed to seed daemon upgrade trigger: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const bindService = new BindService({
+        receiverAid: daemonCfg.aid,
+        getAvailableBaseagents: detectAvailableBaseagents,
+        getUptimeSeconds: () => Math.floor(process.uptime()),
+    });
+    bindService.startCleanup();
+    let controlChannel;
+    let shutdown;
+    let pendingShutdownReason;
+    let shutdownInProgress = false;
+    controlChannel = new AUNChannel({
+        aid: daemonCfg.aid,
+        agentName: daemonCfg.aid,
+        channelName: 'control',
+        pureIdentity: true,
+        defaultEncrypt: daemonCfg.aun?.defaultEncrypt,
+        aunTrace: daemonCfg.debug?.aunTrace,
+        aunSdkLog: daemonCfg.debug?.aunSdkLog,
+    });
+    try {
+        await controlChannel.connect();
+        logger.info(`✓ 控制 AID 已连接: ${daemonCfg.aid}`);
+    }
+    catch (error) {
+        logger.warn(`控制 AID 首连失败（后台自动重连，不影响 bootstrap IPC）: ${error?.message || error}`);
+    }
+    controlChannel.onMessage(async (opts) => {
+        const text = (opts.content || '').trim();
+        let parsed = null;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            parsed = null;
+        }
+        const response = parsed ? await bindService.handleRequest(parsed, opts.peerId) : null;
+        if (response) {
+            await controlChannel.sendMessage(opts.channelId, JSON.stringify(response), controlReplyContext(opts));
+        }
+    });
+    const controlToken = crypto.randomBytes(32).toString('base64url');
+    fs.mkdirSync(path.dirname(resolvePaths().controlToken), { recursive: true });
+    fs.writeFileSync(resolvePaths().controlToken, controlToken, { mode: 0o600 });
+    try {
+        fs.chmodSync(resolvePaths().controlToken, 0o600);
+    }
+    catch { }
+    const ipcServer = new IpcServer(resolvePaths().socket, () => ({
+        pid: process.pid,
+        uptime: Math.round(process.uptime() * 1000),
+        channels: {},
+        channelsByType: {},
+        queue: { pending: 0, processing: 0 },
+        controlAid: (() => {
+            const aidState = controlChannel?.getAidState();
+            return {
+                aid: daemonCfg.aid,
+                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,
+                } : {}),
+            };
+        })(),
+    }));
+    ipcServer.setControlToken(controlToken);
+    ipcServer.setRemoteAccessService(remoteAccessService);
+    ipcServer.setRemoteAccessOwnerProvider(() => daemonCfg.owners?.[0]);
+    ipcServer.setShutdownExecutor(async (reason) => {
+        if (!shutdown) {
+            pendingShutdownReason = reason;
+            return;
+        }
+        await shutdown(reason);
+    });
+    ipcServer.setBindExecutor({
+        begin: (cmd) => bindService.begin(cmd),
+        status: (taskId) => bindService.status(taskId),
+        cancel: (taskId) => bindService.cancel(taskId),
+    });
+    await ipcServer.start();
+    fs.writeFileSync(resolvePaths().readySignal, String(Date.now()));
+    logger.info(`✓ Bind bootstrap ready signal written: ${resolvePaths().readySignal}`);
+    shutdown = async (signal) => {
+        if (shutdownInProgress)
+            return;
+        shutdownInProgress = true;
+        logger.info(`[daemon-bootstrap] shutting down${signal ? ` (${signal})` : ''}`);
+        ipcServer.stop();
+        try {
+            fs.unlinkSync(resolvePaths().readySignal);
+        }
+        catch { }
+        bindService.stopCleanup();
+        if (controlChannel) {
+            try {
+                await controlChannel.disconnect();
+            }
+            catch { /* ignore */ }
+        }
+        removeAll();
+        process.exit(0);
+    };
+    if (pendingShutdownReason) {
+        const reason = pendingShutdownReason;
+        setImmediate(() => { void shutdown?.(reason); });
+    }
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    process.on('exit', () => removeAll());
+}