@bolloon/bolloon-agent 0.1.2 → 0.1.4

package/dist/web/server.js

@@ -0,0 +1,1890 @@
+import express from 'express';
+import { createServer } from 'http';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { createHyperswarmCommunicator, createTopic, KeyManager, AgentAuthManager, } from '@diap/sdk';
+import { documentReader } from '../documents/reader.js';
+import { initMinimax, getMinimax } from '../constraints/index.js';
+import { createAgentSession } from '../agents/pi-sdk.js';
+import { llmConfigStore } from '../llm/config-store.js';
+import { irohTransport } from '../network/iroh-transport.js';
+// 前端资源路径：在打包后会通过 CommonJS require 加载，使用 import.meta.url
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const webRoot = path.join(__dirname, '..', '..', 'dist', 'web');
+const SHARED_SESSION_PATH = path.join(process.env.HOME || '/tmp', '.bolloon', 'sessions');
+const SESSION_CACHE_PATH = path.join(SHARED_SESSION_PATH, 'cache');
+const CHANNELS_PATH = path.join(SHARED_SESSION_PATH, 'channels.json');
+const THEME_PATH = path.join(SHARED_SESSION_PATH, 'theme.json');
+const IPFS_ENDPOINT = 'http://127.0.0.1:5001';
+let irohNodeInfo = null;
+let irohInitialized = false;
+async function ensureSessionDirs() {
+    await fs.mkdir(SESSION_CACHE_PATH, { recursive: true });
+}
+async function loadChannels() {
+    try {
+        const data = await fs.readFile(CHANNELS_PATH, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return [];
+    }
+}
+async function saveChannels(channels) {
+    const jsonStr = JSON.stringify(channels, null, 2);
+    console.log('[saveChannels] 保存频道数据, 数量:', channels.length);
+    console.log('[saveChannels] JSON 长度:', jsonStr.length);
+    await fs.writeFile(CHANNELS_PATH, jsonStr);
+    // 验证保存的内容
+    const verifyData = await fs.readFile(CHANNELS_PATH, 'utf-8');
+    const verifyChannels = JSON.parse(verifyData);
+    console.log('[saveChannels] 验证 - 保存了', verifyChannels.length, '个频道');
+    verifyChannels.forEach((ch, i) => {
+        console.log(`  [${i}] ${ch.name}: did=${ch.did || '无'}`);
+    });
+}
+async function loadSession(channelId, sessionId) {
+    // sessionId is optional for backward compatibility; if provided, load specific session
+    const key = sessionId ? `${channelId}:${sessionId}` : channelId;
+    const sessionPath = path.join(SESSION_CACHE_PATH, `${key}.json`);
+    try {
+        const data = await fs.readFile(sessionPath, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+async function saveSession(session) {
+    const key = session.sessionId ? `${session.channelId}:${session.sessionId}` : session.channelId;
+    const sessionPath = path.join(SESSION_CACHE_PATH, `${key}.json`);
+    await fs.writeFile(sessionPath, JSON.stringify(session, null, 2));
+}
+async function loadTheme() {
+    try {
+        const data = await fs.readFile(THEME_PATH, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return { theme: 'light', agentId: '' };
+    }
+}
+async function saveTheme(theme, agentId) {
+    await fs.writeFile(THEME_PATH, JSON.stringify({ theme, agentId }, null, 2));
+}
+// ==================== Task Queue & Workflow System ====================
+const TASK_QUEUE_PATH = path.join(SHARED_SESSION_PATH, 'task-queue.json');
+const WORKFLOW_STATE_PATH = path.join(SHARED_SESSION_PATH, 'workflow-state.json');
+async function loadTaskQueue() {
+    try {
+        const data = await fs.readFile(TASK_QUEUE_PATH, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return [];
+    }
+}
+async function saveTaskQueue(tasks) {
+    await fs.writeFile(TASK_QUEUE_PATH, JSON.stringify(tasks, null, 2));
+}
+async function loadWorkflowState(channelId) {
+    try {
+        const data = await fs.readFile(WORKFLOW_STATE_PATH, 'utf-8');
+        const states = JSON.parse(data);
+        return states.find(s => s.channelId === channelId) || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function saveWorkflowState(state) {
+    try {
+        const data = await fs.readFile(WORKFLOW_STATE_PATH, 'utf-8');
+        const states = JSON.parse(data);
+        const index = states.findIndex(s => s.channelId === state.channelId);
+        if (index >= 0) {
+            states[index] = state;
+        }
+        else {
+            states.push(state);
+        }
+        await fs.writeFile(WORKFLOW_STATE_PATH, JSON.stringify(states, null, 2));
+    }
+    catch {
+        await fs.writeFile(WORKFLOW_STATE_PATH, JSON.stringify([state], null, 2));
+    }
+}
+let isExecutingTask = false;
+let executionTaskId = null;
+async function executeTask(task, channelId) {
+    if (isExecutingTask)
+        return;
+    isExecutingTask = true;
+    executionTaskId = task.id;
+    const agent = await getAgentForChannel(channelId);
+    const tasks = await loadTaskQueue();
+    const taskIndex = tasks.findIndex(t => t.id === task.id);
+    if (taskIndex >= 0) {
+        tasks[taskIndex].status = 'running';
+        tasks[taskIndex].updatedAt = new Date().toISOString();
+        await saveTaskQueue(tasks);
+    }
+    broadcast({ type: 'task_status', taskId: task.id, status: 'running', progress: 0 }, channelId);
+    try {
+        let result = '';
+        switch (task.type) {
+            case 'chat':
+                if (task.description) {
+                    broadcast({ type: 'status', content: `执行任务: ${task.title}` }, channelId);
+                    result = await agent.prompt(task.description);
+                }
+                break;
+            case 'read':
+                if (task.description) {
+                    broadcast({ type: 'status', content: `读取文档: ${task.description}` }, channelId);
+                    const content = await documentReader.read(task.description);
+                    result = `📄 文档读取完成\n\n${content.text.substring(0, 500)}${content.text.length > 500 ? '...' : ''}`;
+                }
+                break;
+            case 'summarize':
+                if (task.description) {
+                    broadcast({ type: 'status', content: `总结文档: ${task.description}` }, channelId);
+                    const content = await documentReader.read(task.description);
+                    const llm = getMinimax();
+                    const summary = await llm.summarize(content.text);
+                    result = `📝 文档总结:\n\n${summary.summary}`;
+                }
+                break;
+            case 'workflow':
+                // 执行多步骤工作流
+                if (task.steps && task.steps.length > 0) {
+                    let loopCount = 0;
+                    for (let i = 0; i < task.steps.length; i++) {
+                        // 广播循环开始
+                        loopCount++;
+                        broadcast({ type: 'workflow_loop', loopCount, content: `开始步骤 ${i + 1}/${task.steps.length}: ${task.steps[i].name}` }, channelId);
+                        task.steps[i].status = 'running';
+                        broadcast({ type: 'task_status', taskId: task.id, status: 'running', currentStep: i, totalSteps: task.steps.length }, channelId);
+                        broadcast({ type: 'workflow_step', step: `步骤 ${i + 1}`, content: `执行中: ${task.steps[i].name}` }, channelId);
+                        // 执行步骤 - 模拟流式输出
+                        for (let j = 0; j < 3; j++) {
+                            await new Promise(resolve => setTimeout(resolve, 300));
+                            broadcast({ type: 'workflow_step', step: `步骤 ${i + 1}`, content: `执行中... (${(j + 1) * 33}%)` }, channelId);
+                        }
+                        task.steps[i].status = 'completed';
+                        task.progress = Math.round(((i + 1) / task.steps.length) * 100);
+                        broadcast({ type: 'workflow_step', step: `步骤 ${i + 1}`, content: `✅ 完成: ${task.steps[i].name}` }, channelId);
+                        broadcast({ type: 'workflow_loop', loopCount, status: 'completed', content: `步骤 ${i + 1} 完成` }, channelId);
+                        broadcast({ type: 'task_status', taskId: task.id, progress: task.progress }, channelId);
+                    }
+                    result = '✅ 工作流执行完成';
+                    broadcast({ type: 'workflow_loop', loopCount, status: 'finished', content: result }, channelId);
+                }
+                break;
+            default:
+                result = '未知任务类型';
+        }
+        // 更新任务状态
+        const tasks = await loadTaskQueue();
+        const idx = tasks.findIndex(t => t.id === task.id);
+        if (idx >= 0) {
+            tasks[idx].status = 'completed';
+            tasks[idx].progress = 100;
+            tasks[idx].result = result;
+            tasks[idx].updatedAt = new Date().toISOString();
+            await saveTaskQueue(tasks);
+        }
+        broadcast({ type: 'task_status', taskId: task.id, status: 'completed', progress: 100, result }, channelId);
+        broadcast({ type: 'ai', content: result }, channelId);
+    }
+    catch (error) {
+        const tasks = await loadTaskQueue();
+        const idx = tasks.findIndex(t => t.id === task.id);
+        if (idx >= 0) {
+            tasks[idx].status = 'failed';
+            tasks[idx].error = error.message;
+            tasks[idx].updatedAt = new Date().toISOString();
+            await saveTaskQueue(tasks);
+        }
+        broadcast({ type: 'task_status', taskId: task.id, status: 'failed', error: error.message }, channelId);
+        broadcast({ type: 'error', content: `任务执行失败: ${error.message}` }, channelId);
+    }
+    isExecutingTask = false;
+    executionTaskId = null;
+}
+let sseClients = new Set();
+let channelSessions = new Map(); // key: channelId
+let sessionMessages = new Map(); // key: channelId + sessionId
+async function getAgentForChannel(channelId, channelDid, channelName, channelDidDoc) {
+    // 获取当前 channel 的 currentSessionId
+    const channels = await loadChannels();
+    const channel = channels.find(c => c.id === channelId);
+    const currentSessionId = channel?.currentSessionId || 'default';
+    const sessionKey = `${channelId}:${currentSessionId}`;
+    console.log(`[Agent] 获取频道 ${channelId} 的 session, sessionKey = ${sessionKey}`);
+    const existingSession = channelSessions.get(sessionKey);
+    // 如果已有 session，检查是否需要更新 identity
+    if (existingSession) {
+        console.log(`[Agent] 找到现有 session: ${sessionKey}`);
+        const currentIdentity = existingSession.getIdentity();
+        // 如果当前 identity 没有真实 DID，或者 DID 与频道的 DID 不匹配，需要重建
+        let needsUpdate = !currentIdentity.did.startsWith('did:pi:') ||
+            (channelDid && !currentIdentity.did.includes(channelId));
+        if (!needsUpdate && channelDid && currentIdentity.did !== channelDid) {
+            needsUpdate = true;
+        }
+        if (needsUpdate && channelDid) {
+            // 更新现有 session 的 identity
+            existingSession.updateIdentity({
+                did: channelDid,
+                name: channelName || `Channel-${channelId.slice(-6)}`,
+                publicKey: '',
+                createdAt: Date.now(),
+                cid: channelDidDoc?.cid,
+                ipnsName: channelDidDoc?.ipnsName
+            });
+            console.log(`[Agent] 频道 ${channelId} 身份更新: DID = ${channelDid}`);
+        }
+        return existingSession;
+    }
+    // 构建频道的身份文档
+    const identityDoc = channelDid ? {
+        did: channelDid,
+        name: channelName || `Channel-${channelId.slice(-6)}`,
+        publicKey: '',
+        createdAt: Date.now(),
+        cid: channelDidDoc?.cid,
+        ipnsName: channelDidDoc?.ipnsName
+    } : undefined;
+    console.log(`[Agent] 创建新 session: ${sessionKey}`);
+    const session = await createAgentSession({
+        cwd: process.cwd(),
+        peerId: `channel-${channelId}:${currentSessionId}`,
+        identityDoc
+    }, true); // forceNew: true 强制创建新实例
+    channelSessions.set(sessionKey, session);
+    if (channelDid) {
+        console.log(`[Agent] 新建频道 ${channelId} session, DID = ${channelDid}, sessionId = ${currentSessionId}`);
+    }
+    else {
+        console.log(`[Agent] 新建频道 ${channelId} session, 使用默认身份, sessionId = ${currentSessionId}`);
+    }
+    return session;
+}
+export async function createWebServer(port = 3000) {
+    // 防止 P2P DHT 超时等错误导致进程崩溃
+    process.on('unhandledRejection', (reason, promise) => {
+        console.error('[警告] 未处理的 Promise 拒绝:', reason);
+    });
+    // 重置旧的 agent session，确保使用新的 LLM 配置
+    const { resetAgentSession } = await import('../agents/pi-sdk.js');
+    resetAgentSession();
+    // 初始化 LLM（从配置文件读取 MiniMax 配置）
+    initMinimax();
+    // ==================== P2P DIAP 身份初始化 ====================
+    let p2pIdentity = {
+        did: '',
+        name: '',
+        publicKey: '',
+        keypair: null
+    };
+    let p2pCommunicator = null;
+    try {
+        console.log('开始生成 P2P 身份...');
+        // 生成 DIAP 身份
+        const kp = KeyManager.generate();
+        console.log('KeyManager.generate() 完成, kp:', !!kp, 'kp.did:', kp?.did);
+        console.log('kp.publicKey:', kp?.publicKey);
+        const did = kp.did || 'did:unknown:123456';
+        console.log(`DID: ${did}`);
+        const username = 'web-user';
+        const suffix = did?.split(':').pop()?.substring(0, 4) || 'xxxx';
+        const name = `blln-${username}-${suffix}`;
+        p2pIdentity = {
+            did: did || '',
+            name,
+            publicKey: Buffer.from(kp.publicKey).toString('hex'),
+            keypair: kp
+        };
+        console.log(`P2P 身份已生成: ${p2pIdentity.did}`);
+        // 尝试发布 DID 到 IPFS
+        try {
+            const auth = await AgentAuthManager.newWithRemoteIpfs('http://127.0.0.1:5001', 'http://127.0.0.1:8080');
+            await auth.registerAgent({ name, services: [] }, kp, '');
+            console.log('P2P DID 已发布到 IPFS');
+        }
+        catch (e) {
+            console.log('P2P DID 本地模式运行');
+        }
+        // 初始化 P2P 通信器
+        try {
+            const rawSeed = crypto.getRandomValues(new Uint8Array(32));
+            p2pCommunicator = createHyperswarmCommunicator({
+                server: true,
+                client: true,
+                autoConnect: true,
+                maxConnections: 50,
+                seed: rawSeed
+            });
+            p2pCommunicator.on('connection', (conn) => {
+                console.log(`P2P 连接: ${conn.publicKey.substring(0, 8)}...`);
+            });
+            p2pCommunicator.on('message', async (msg, conn) => {
+                const content = new TextDecoder().decode(msg.content);
+                console.log(`P2P 收到消息: ${content.substring(0, 50)}...`);
+                // 可以在这里处理接收到的消息
+                broadcast({ type: 'p2p_message', from: conn.publicKey.substring(0, 8), content }, undefined);
+            });
+            await p2pCommunicator.start();
+            const topic = createTopic('bolloon-agent-harness');
+            await p2pCommunicator.joinTopic(topic);
+            console.log(`P2P 网络已就绪`);
+        }
+        catch (e) {
+            console.log(`P2P 网络初始化失败: ${e.message}`);
+        }
+    }
+    catch (e) {
+        console.log(`P2P 身份初始化失败: ${e.message}`);
+    }
+    const app = express();
+    const server = createServer(app);
+    await ensureSessionDirs();
+    app.use(express.json());
+    app.use((req, res, next) => {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        if (req.method === 'OPTIONS') {
+            return res.status(200).end();
+        }
+        next();
+    });
+    app.use(express.static(webRoot));
+    app.get('/', (req, res) => {
+        res.sendFile(join(webRoot, 'index.html'));
+    });
+    app.get('/api-config', (req, res) => {
+        res.sendFile(join(webRoot, 'api-config.html'));
+    });
+    app.get('/events', (req, res) => {
+        const channelId = req.query.channelId;
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.flushHeaders();
+        const clientInfo = { res, channelId };
+        sseClients.add(clientInfo);
+        req.on('close', () => {
+            sseClients.delete(clientInfo);
+        });
+    });
+    app.post('/message', async (req, res) => {
+        const { text, channelId, channelDid } = req.body;
+        if (!text) {
+            return res.status(400).json({ error: 'No text provided' });
+        }
+        if (!channelId) {
+            return res.status(400).json({ error: 'No channelId provided' });
+        }
+        // 获取频道信息，包括真实 DID 和完整 DID 文档
+        const channels = await loadChannels();
+        const channel = channels.find(c => c.id === channelId);
+        const currentSessionId = channel?.currentSessionId || 'default';
+        const realChannelDid = channelDid || channel?.did || '';
+        const realChannelName = channel?.name || '';
+        const realChannelDidDoc = channel?.didDocument;
+        broadcast({ type: 'user', content: text }, channelId);
+        try {
+            const agent = await getAgentForChannel(channelId, realChannelDid, realChannelName, realChannelDidDoc);
+            let fullResponse = '';
+            const streamCallback = (event) => {
+                // 同时发送给流式显示和工作流显示
+                if (event.type === 'token' || event.type === 'thinking') {
+                    broadcast({ type: 'stream', streamType: event.type, content: event.content }, channelId);
+                    // 同时作为 workflow_step 显示（用于动态 loop 循环）
+                    if (event.content) {
+                        broadcast({ type: 'workflow_step', step: 'AI 思考', content: event.content.substring(0, 100) }, channelId);
+                    }
+                }
+                else if (event.type === 'status' || event.type === 'tool') {
+                    broadcast({ type: 'status', tool: event.tool, content: event.content }, channelId);
+                    broadcast({ type: 'workflow_step', step: event.tool || '系统', content: event.content }, channelId);
+                    console.log(`[SSE 广播] workflow_step: step=${event.tool}, content="${event.content?.substring(0, 80)}..."`);
+                }
+                else if (event.type === 'error') {
+                    broadcast({ type: 'error', content: event.content }, channelId);
+                }
+            };
+            console.log(`[消息处理] 开始处理用户消息, channelId: ${channelId}, sessionId: ${currentSessionId}`);
+            // 将真实 DID 作为上下文前缀，让 AI 使用真实的 DID 而不是自己编造的
+            const contextHint = realChannelDid ? `[系统上下文] 当前频道名称: ${realChannelName}, 你的真实 DID: ${realChannelDid}\n\n` : '';
+            fullResponse = await agent.promptStream(contextHint + text, streamCallback);
+            broadcast({ type: 'ai', content: fullResponse }, channelId);
+            const existingSession = await loadSession(channelId, currentSessionId);
+            const session = existingSession || { channelId, sessionId: currentSessionId, messages: [], lastUpdated: new Date().toISOString() };
+            session.sessionId = currentSessionId;
+            session.messages.push({ id: crypto.randomUUID(), type: 'user', content: text, timestamp: new Date().toISOString() });
+            session.messages.push({ id: crypto.randomUUID(), type: 'ai', content: fullResponse, timestamp: new Date().toISOString() });
+            session.lastUpdated = new Date().toISOString();
+            await saveSession(session);
+            const channels = await loadChannels();
+            const channel = channels.find(c => c.id === channelId);
+            if (channel && channel.name === '智能体') {
+                const renameSuggestion = await agent.suggestRename(session.messages);
+                if (renameSuggestion) {
+                    channel.name = renameSuggestion;
+                    await saveChannels(channels);
+                    broadcast({ type: 'renamed', channelId, newName: renameSuggestion }, channelId);
+                }
+            }
+            if (channel) {
+                channel.updatedAt = new Date().toISOString();
+                await saveChannels(channels);
+            }
+            broadcast({ type: 'done' }, channelId);
+            res.json({ ok: true });
+        }
+        catch (err) {
+            broadcast({ type: 'error', content: err.message }, channelId);
+            broadcast({ type: 'done' }, channelId);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 获取频道并确保每个频道都有 DID
+    async function getChannelsWithDID() {
+        const channels = await loadChannels();
+        console.log(`[getChannelsWithDID] 加载了 ${channels.length} 个频道`);
+        let changed = false;
+        for (const channel of channels) {
+            // 检查 DID 是否有效
+            const didMissing = channel.did === undefined || channel.did === null || channel.did === 'undefined' || channel.did === 'null' || channel.did === '';
+            console.log(`[getChannelsWithDID] 频道 ${channel.name}: did=${JSON.stringify(channel.did)}, 缺失=${didMissing}`);
+            if (didMissing) {
+                console.log(`[修复频道] ${channel.name} (${channel.id}) 缺少 DID，正在生成...`);
+                try {
+                    const kp = KeyManager.generate();
+                    const generatedDid = kp.did;
+                    console.log(`[修复频道] KeyManager.generate() 结果: kp=${!!kp}, did=${generatedDid}`);
+                    if (generatedDid && typeof generatedDid === 'string' && generatedDid.length > 0) {
+                        channel.did = generatedDid;
+                        channel.publicKey = Buffer.from(kp.publicKey).toString('hex');
+                        console.log(`[修复频道] ${channel.name} 生成了 DID: ${channel.did}`);
+                        // 发布到 IPFS 并保存完整 DID 文档
+                        try {
+                            const auth = await AgentAuthManager.newWithRemoteIpfs('http://127.0.0.1:5001', 'http://127.0.0.1:8080');
+                            const result = await auth.registerAgent({ name: channel.name, services: [] }, kp, '');
+                            channel.cid = result.cid || '';
+                            // 保存完整 DID 文档（用于传递给 session）
+                            if (result.didDocument) {
+                                channel.didDocument = result.didDocument;
+                            }
+                            console.log(`[修复频道] ${channel.name} CID: ${channel.cid}`);
+                        }
+                        catch (ipfsErr) {
+                            console.log(`[修复频道] ${channel.name} IPFS 失败`);
+                        }
+                    }
+                    else {
+                        console.log(`[修复频道] ${channel.name} KeyManager 返回无效 DID`);
+                        channel.did = `did:web:${channel.id}`;
+                        channel.publicKey = `pk_${channel.id}`;
+                    }
+                    changed = true;
+                }
+                catch (e) {
+                    console.log(`[修复频道] ${channel.name} 失败: ${e}`);
+                }
+            }
+        }
+        if (changed) {
+            console.log('[getChannelsWithDID] 保存修改后的频道');
+            await saveChannels(channels);
+        }
+        return channels;
+    }
+    app.get('/channels', async (_req, res) => {
+        try {
+            console.log('[API] /channels 被调用');
+            const channels = await getChannelsWithDID();
+            console.log('[获取频道] 返回', channels.length, '个');
+            channels.forEach((ch, i) => {
+                console.log(`  [${i}] ${ch.name} - did: ${ch.did || '无'} - cid: ${ch.cid || '无'}`);
+            });
+            res.json(channels);
+        }
+        catch (err) {
+            console.error('[API] /channels 错误:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/channels', async (req, res) => {
+        try {
+            const { name, agentId } = req.body;
+            console.log(`[创建频道] 收到请求: name=${name}, agentId=${agentId}`);
+            if (!name || !agentId) {
+                return res.status(400).json({ error: 'name and agentId required' });
+            }
+            const channels = await loadChannels();
+            const id = `ch_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+            // 先创建频道（不阻塞等待 DID 生成）
+            const channel = {
+                id,
+                name,
+                agentId,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                currentSessionId: `sess_${Date.now()}`,
+                sessions: [{
+                        id: `sess_${Date.now()}`,
+                        createdAt: new Date().toISOString(),
+                        messageCount: 0,
+                        preview: ''
+                    }]
+            };
+            console.log(`[创建频道] 先保存频道 ID: ${id}`);
+            channels.push(channel);
+            await saveChannels(channels);
+            await saveSession({ channelId: id, sessionId: 'default', messages: [], lastUpdated: new Date().toISOString() });
+            res.json(channel);
+            // 后台生成 DID
+            console.log(`[创建频道] 后台生成 DID...`);
+            setTimeout(async () => {
+                try {
+                    const kp = KeyManager.generate();
+                    if (kp.did) {
+                        const allChannels = await loadChannels();
+                        const ch = allChannels.find(c => c.id === id);
+                        if (ch) {
+                            ch.did = kp.did;
+                            ch.publicKey = Buffer.from(kp.publicKey).toString('hex');
+                            console.log(`[创建频道] DID 生成完成: ${ch.did}`);
+                            // 发布到 IPFS
+                            try {
+                                const auth = await AgentAuthManager.newWithRemoteIpfs('http://127.0.0.1:5001', 'http://127.0.0.1:8080');
+                                const result = await auth.registerAgent({ name, services: [] }, kp, '');
+                                ch.cid = result.cid || '';
+                                console.log(`[创建频道] CID: ${ch.cid}`);
+                            }
+                            catch { }
+                            await saveChannels(allChannels);
+                        }
+                    }
+                }
+                catch (e) {
+                    console.log(`[创建频道] ${name} 后台生成 DID 失败`);
+                }
+            }, 100);
+        }
+        catch (err) {
+            console.error('[创建频道] 错误:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 创建新 Session（在现有 Channel 下）
+    app.post('/channels/:channelId/sessions', async (req, res) => {
+        try {
+            const { channelId } = req.params;
+            const channels = await loadChannels();
+            const channel = channels.find(c => c.id === channelId);
+            if (!channel) {
+                return res.status(404).json({ error: 'Channel not found' });
+            }
+            const sessionId = `sess_${Date.now()}`;
+            const session = {
+                id: sessionId,
+                createdAt: new Date().toISOString(),
+                messageCount: 0,
+                preview: ''
+            };
+            if (!channel.sessions) {
+                channel.sessions = [];
+            }
+            channel.sessions.push(session);
+            channel.currentSessionId = sessionId;
+            channel.updatedAt = new Date().toISOString();
+            await saveChannels(channels);
+            await saveSession({ channelId, sessionId, messages: [], lastUpdated: new Date().toISOString() });
+            res.json({ session, currentSessionId: sessionId });
+        }
+        catch (err) {
+            console.error('[创建Session] 错误:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 获取 Channel 下的所有 Sessions
+    app.get('/channels/:channelId/sessions', async (req, res) => {
+        try {
+            const { channelId } = req.params;
+            const channels = await loadChannels();
+            const channel = channels.find(c => c.id === channelId);
+            if (!channel) {
+                return res.status(404).json({ error: 'Channel not found' });
+            }
+            res.json({
+                sessions: channel.sessions || [],
+                currentSessionId: channel.currentSessionId
+            });
+        }
+        catch (err) {
+            console.error('[获取Sessions] 错误:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 切换 Session
+    app.post('/channels/:channelId/sessions/:sessionId/switch', async (req, res) => {
+        try {
+            const { channelId, sessionId } = req.params;
+            const channels = await loadChannels();
+            const channel = channels.find(c => c.id === channelId);
+            if (!channel) {
+                return res.status(404).json({ error: 'Channel not found' });
+            }
+            channel.currentSessionId = sessionId;
+            channel.updatedAt = new Date().toISOString();
+            await saveChannels(channels);
+            res.json({ ok: true, currentSessionId: sessionId });
+        }
+        catch (err) {
+            console.error('[切换Session] 错误:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.delete('/channels/:channelId', async (req, res) => {
+        try {
+            const { channelId } = req.params;
+            const channels = await loadChannels();
+            const index = channels.findIndex(c => c.id === channelId);
+            if (index === -1) {
+                return res.status(404).json({ error: 'Channel not found' });
+            }
+            channels.splice(index, 1);
+            await saveChannels(channels);
+            try {
+                await fs.unlink(path.join(SESSION_CACHE_PATH, `${channelId}.json`));
+            }
+            catch { }
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.patch('/channels/:channelId', async (req, res) => {
+        try {
+            const { channelId } = req.params;
+            const { name } = req.body;
+            if (!name) {
+                return res.status(400).json({ error: 'Name required' });
+            }
+            const channels = await loadChannels();
+            const channel = channels.find(c => c.id === channelId);
+            if (!channel) {
+                return res.status(404).json({ error: 'Channel not found' });
+            }
+            channel.name = name;
+            channel.updatedAt = new Date().toISOString();
+            await saveChannels(channels);
+            res.json(channel);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get('/sessions/:channelId', async (req, res) => {
+        try {
+            const session = await loadSession(req.params.channelId);
+            res.json(session || { channelId: req.params.channelId, messages: [], lastUpdated: null });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get('/theme', async (req, res) => {
+        try {
+            const themeData = await loadTheme();
+            res.json(themeData);
+        }
+        catch (err) {
+            res.json({ theme: 'light', agentId: '' });
+        }
+    });
+    app.post('/theme', async (req, res) => {
+        try {
+            const { theme, agentId } = req.body;
+            if (theme !== 'light' && theme !== 'dark') {
+                return res.status(400).json({ error: 'Invalid theme' });
+            }
+            await saveTheme(theme, agentId || '');
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 重新生成回复
+    app.post('/regenerate', async (req, res) => {
+        const { channelId, userMessage } = req.body;
+        if (!channelId) {
+            return res.status(400).json({ error: 'No channelId provided' });
+        }
+        if (!userMessage) {
+            return res.status(400).json({ error: 'No userMessage provided' });
+        }
+        try {
+            const channels = await loadChannels();
+            const channel = channels.find(c => c.id === channelId);
+            const currentSessionId = channel?.currentSessionId || 'default';
+            const realChannelDid = channel?.did || '';
+            const realChannelName = channel?.name || '';
+            const realChannelDidDoc = channel?.didDocument;
+            // 通知前端开始重新生成
+            broadcast({ type: 'regenerating', channelId }, channelId);
+            const agent = await getAgentForChannel(channelId, realChannelDid, realChannelName, realChannelDidDoc);
+            let fullResponse = '';
+            const streamCallback = (event) => {
+                if (event.type === 'token' || event.type === 'thinking') {
+                    broadcast({ type: 'stream', streamType: event.type, content: event.content }, channelId);
+                }
+                else if (event.type === 'status' || event.type === 'tool') {
+                    broadcast({ type: 'status', tool: event.tool, content: event.content }, channelId);
+                }
+                else if (event.type === 'error') {
+                    broadcast({ type: 'error', content: event.content }, channelId);
+                }
+            };
+            // 重新生成时只发送用户消息
+            fullResponse = await agent.promptStream(userMessage, streamCallback);
+            broadcast({ type: 'ai', content: fullResponse }, channelId);
+            // 更新 session
+            const existingSession = await loadSession(channelId, currentSessionId);
+            if (existingSession && existingSession.messages.length > 0) {
+                // 移除最后一个 AI 消息，替换为新的
+                const lastAiIndex = existingSession.messages.map((m) => m.type).lastIndexOf('ai');
+                if (lastAiIndex !== -1) {
+                    existingSession.messages = existingSession.messages.slice(0, lastAiIndex);
+                }
+                existingSession.messages.push({
+                    id: crypto.randomUUID(),
+                    type: 'ai',
+                    content: fullResponse,
+                    timestamp: new Date().toISOString()
+                });
+                existingSession.lastUpdated = new Date().toISOString();
+                await saveSession(existingSession);
+            }
+            broadcast({ type: 'done' }, channelId);
+            res.json({ ok: true });
+        }
+        catch (err) {
+            broadcast({ type: 'error', content: err.message }, channelId);
+            broadcast({ type: 'done' }, channelId);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ==================== Task Queue API ====================
+    // 获取所有任务
+    app.get('/api/tasks', async (req, res) => {
+        try {
+            const tasks = await loadTaskQueue();
+            res.json(tasks);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 创建新任务
+    app.post('/api/tasks', async (req, res) => {
+        try {
+            const { type, title, description, steps } = req.body;
+            if (!type || !title) {
+                return res.status(400).json({ error: 'type and title required' });
+            }
+            const tasks = await loadTaskQueue();
+            const task = {
+                id: `task_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`,
+                type,
+                title,
+                description,
+                status: 'pending',
+                progress: 0,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                steps: steps?.map((s, i) => ({
+                    id: `step_${i}`,
+                    name: s,
+                    status: 'pending'
+                }))
+            };
+            tasks.push(task);
+            await saveTaskQueue(tasks);
+            res.json(task);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 获取单个任务
+    app.get('/api/tasks/:taskId', async (req, res) => {
+        try {
+            const { taskId } = req.params;
+            const tasks = await loadTaskQueue();
+            const task = tasks.find(t => t.id === taskId);
+            if (!task) {
+                return res.status(404).json({ error: 'Task not found' });
+            }
+            res.json(task);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 更新任务
+    app.patch('/api/tasks/:taskId', async (req, res) => {
+        try {
+            const { taskId } = req.params;
+            const { status, currentStep } = req.body;
+            const tasks = await loadTaskQueue();
+            const taskIndex = tasks.findIndex(t => t.id === taskId);
+            if (taskIndex === -1) {
+                return res.status(404).json({ error: 'Task not found' });
+            }
+            if (status) {
+                tasks[taskIndex].status = status;
+            }
+            if (currentStep !== undefined) {
+                tasks[taskIndex].currentStep = currentStep;
+            }
+            tasks[taskIndex].updatedAt = new Date().toISOString();
+            await saveTaskQueue(tasks);
+            res.json(tasks[taskIndex]);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 删除任务
+    app.delete('/api/tasks/:taskId', async (req, res) => {
+        try {
+            const { taskId } = req.params;
+            const tasks = await loadTaskQueue();
+            const filtered = tasks.filter(t => t.id !== taskId);
+            await saveTaskQueue(filtered);
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 执行任务（自动执行下一步）
+    app.post('/api/tasks/:taskId/execute', async (req, res) => {
+        try {
+            const { taskId } = req.params;
+            const { channelId } = req.body;
+            if (!channelId) {
+                return res.status(400).json({ error: 'channelId required' });
+            }
+            const tasks = await loadTaskQueue();
+            const task = tasks.find(t => t.id === taskId);
+            if (!task) {
+                return res.status(404).json({ error: 'Task not found' });
+            }
+            if (isExecutingTask) {
+                return res.status(409).json({ error: 'Another task is currently executing' });
+            }
+            // 异步执行任务
+            executeTask(task, channelId);
+            res.json({ ok: true, taskId: task.id });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 执行下一个待处理任务
+    app.post('/api/tasks/execute-next', async (req, res) => {
+        try {
+            const { channelId } = req.body;
+            if (!channelId) {
+                return res.status(400).json({ error: 'channelId required' });
+            }
+            const tasks = await loadTaskQueue();
+            const nextTask = tasks.find(t => t.status === 'pending');
+            if (!nextTask) {
+                return res.json({ ok: false, message: 'No pending tasks' });
+            }
+            if (isExecutingTask) {
+                return res.status(409).json({ error: 'Another task is currently executing' });
+            }
+            // 异步执行任务
+            executeTask(nextTask, channelId);
+            res.json({ ok: true, taskId: nextTask.id });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 创建并执行工作流
+    app.post('/api/workflow', async (req, res) => {
+        try {
+            const { channelId, title, steps } = req.body;
+            if (!channelId || !steps || !Array.isArray(steps)) {
+                return res.status(400).json({ error: 'channelId and steps required' });
+            }
+            const tasks = await loadTaskQueue();
+            const task = {
+                id: `wf_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`,
+                type: 'workflow',
+                title: title || '工作流',
+                description: `包含 ${steps.length} 个步骤的工作流`,
+                status: 'pending',
+                progress: 0,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                steps: steps.map((s, i) => ({
+                    id: `step_${i}`,
+                    name: s,
+                    status: 'pending'
+                })),
+                currentStep: 0
+            };
+            tasks.push(task);
+            await saveTaskQueue(tasks);
+            // 自动开始执行
+            if (!isExecutingTask) {
+                executeTask(task, channelId);
+            }
+            res.json({ ok: true, task });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ==================== LLM 配置 API ====================
+    // 获取所有 LLM 配置
+    app.get('/api/llm-config', async (req, res) => {
+        try {
+            const config = await llmConfigStore.getConfig();
+            const providerInfo = llmConfigStore.getAllProviderInfo();
+            // 隐藏 API Key
+            const safeConfig = {
+                ...config,
+                providers: Object.fromEntries(Object.entries(config.providers).map(([key, val]) => [
+                    key,
+                    { ...val, apiKey: val.apiKey ? '***' + val.apiKey.slice(-4) : '' }
+                ])),
+                providerInfo
+            };
+            res.json(safeConfig);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 更新 LLM 配置
+    app.post('/api/llm-config', async (req, res) => {
+        try {
+            const { provider, config } = req.body;
+            if (!provider || !config) {
+                return res.status(400).json({ error: 'provider and config required' });
+            }
+            await llmConfigStore.updateProvider(provider, config);
+            // 如果是活跃供应商，重新初始化 Pi SDK
+            const currentActive = await llmConfigStore.getActiveProvider();
+            if (provider === currentActive) {
+                const newConfig = await llmConfigStore.getActiveProviderConfig();
+                if (newConfig) {
+                    initMinimax({
+                        provider,
+                        apiKey: newConfig.apiKey || undefined,
+                        baseUrl: newConfig.baseUrl || undefined,
+                        model: newConfig.model || undefined
+                    });
+                }
+            }
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 设置活跃供应商
+    app.post('/api/llm-provider', async (req, res) => {
+        try {
+            const { provider } = req.body;
+            if (!provider) {
+                return res.status(400).json({ error: 'provider required' });
+            }
+            await llmConfigStore.setActiveProvider(provider);
+            // 重新初始化 Pi SDK
+            const config = await llmConfigStore.getActiveProviderConfig();
+            if (config) {
+                initMinimax({
+                    provider: provider,
+                    apiKey: config.apiKey || undefined,
+                    baseUrl: config.baseUrl || undefined,
+                    model: config.model || undefined
+                });
+            }
+            res.json({ ok: true, provider });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 测试供应商连接
+    app.post('/api/llm-test', async (req, res) => {
+        try {
+            const { provider } = req.body;
+            if (!provider) {
+                return res.status(400).json({ error: 'provider required' });
+            }
+            const result = await llmConfigStore.testProvider(provider);
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ==================== P2P Network API ====================
+    // 获取当前身份
+    app.get('/api/identity', async (_req, res) => {
+        console.log('收到 /api/identity 请求');
+        console.log('p2pIdentity.did:', p2pIdentity.did);
+        try {
+            res.json({
+                did: p2pIdentity.did,
+                name: p2pIdentity.name,
+                publicKey: p2pIdentity.publicKey
+            });
+        }
+        catch (err) {
+            console.error('API identity 错误:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 获取已连接的节点
+    app.get('/api/peers', async (_req, res) => {
+        try {
+            if (!p2pCommunicator) {
+                res.json([]);
+                return;
+            }
+            const connections = p2pCommunicator.getConnections();
+            const peers = connections.map((conn) => ({
+                id: conn.publicKey.substring(0, 16),
+                publicKey: conn.publicKey,
+                peerId: conn.publicKey
+            }));
+            res.json(peers);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 获取已发现的所有节点（包括通过 CID 解析的）
+    app.get('/api/discovered-peers', async (_req, res) => {
+        try {
+            // 从全局状态获取已发现的节点
+            const discovered = global.discoveredAgents || [];
+            res.json(discovered);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ==================== iroh P2P API ====================
+    // 初始化 iroh P2P（带持久化）
+    app.post('/api/iroh/init', async (_req, res) => {
+        try {
+            if (irohInitialized && irohNodeInfo) {
+                res.json({ ok: true, ...irohNodeInfo });
+                return;
+            }
+            console.log('[iroh API] 初始化 iroh...');
+            // 启动 iroh（启用持久化）
+            await irohTransport.start(undefined, true);
+            const nodeId = irohTransport.getNodeId() || '';
+            console.log(`[iroh API] iroh 节点 ID: ${nodeId.substring(0, 20)}...`);
+            // 生成 DID
+            const keyPair = KeyManager.generate();
+            const did = keyPair.did;
+            // 构建节点信息文档
+            const nodeDoc = {
+                id: did,
+                name: `bolloon-web-${Date.now()}`,
+                version: '1.0',
+                capabilities: ['chat', 'ai', 'judgment-injection', 'web-interface'],
+                interests: ['ai', 'p2p', 'judgment-system'],
+                irohNodeId: nodeId,
+                channels: [{ id: 'main', name: '主对话' }],
+                createdAt: new Date().toISOString()
+            };
+            // 发布到 IPFS（可选，如果 IPFS 不可用则跳过）
+            let cid = '';
+            try {
+                const formData = new FormData();
+                const blob = new Blob([JSON.stringify(nodeDoc)], { type: 'application/json' });
+                formData.append('file', blob, 'node-info.json');
+                const ipfsRes = await fetch(`${IPFS_ENDPOINT}/api/v0/add`, {
+                    method: 'POST',
+                    body: formData,
+                    signal: AbortSignal.timeout(5000)
+                });
+                const ipfsResult = await ipfsRes.text();
+                const cidMatch = ipfsResult.match(/"Hash":"([^"]+)"/);
+                cid = cidMatch ? cidMatch[1] : '';
+                console.log(`[iroh API] CID 发布成功: ${cid.substring(0, 20)}...`);
+            }
+            catch (ipfsErr) {
+                console.warn('[iroh API] IPFS 不可用，跳过 CID 发布:', ipfsErr.message);
+                // 生成一个假的 CID 用于本地测试（格式：Qm + 44个随机字符）
+                const randomPart = Array.from({ length: 44 }, () => Math.random().toString(36)[2]).join('').substring(0, 44);
+                cid = `Qm${randomPart}`;
+                console.log(`[iroh API] 使用本地 CID: ${cid.substring(0, 20)}...`);
+            }
+            irohNodeInfo = {
+                did,
+                cid,
+                irohNodeId: nodeId,
+                name: nodeDoc.name,
+                initialized: true
+            };
+            irohInitialized = true;
+            // 设置消息处理
+            irohTransport.onMessage('chat', (msg) => {
+                const content = new TextDecoder().decode(msg.payload);
+                console.log(`[iroh] 收到消息 from ${msg.from.substring(0, 12)}...`);
+                // 通过 SSE 广播给所有客户端
+                broadcast({
+                    type: 'p2p_message',
+                    from: msg.from,
+                    content,
+                    timestamp: Date.now()
+                }, 'p2p-global');
+            });
+            irohTransport.onMessage('ai-dialogue', (msg) => {
+                const content = new TextDecoder().decode(msg.payload);
+                console.log(`[iroh] 收到 AI 对话 from ${msg.from.substring(0, 12)}...`);
+                broadcast({
+                    type: 'p2p_message',
+                    content,
+                    timestamp: Date.now()
+                }, 'p2p-global');
+            });
+            console.log(`[iroh API] 初始化完成: DID=${did}, CID=${cid}`);
+            res.json({ ok: true, ...irohNodeInfo });
+        }
+        catch (err) {
+            console.error('[iroh API] 初始化失败:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 获取 iroh 节点信息
+    app.get('/api/iroh/info', async (_req, res) => {
+        if (!irohInitialized || !irohNodeInfo) {
+            res.json({ initialized: false });
+            return;
+        }
+        res.json({
+            initialized: true,
+            did: irohNodeInfo.did,
+            cid: irohNodeInfo.cid,
+            irohNodeId: irohNodeInfo.irohNodeId,
+            name: irohNodeInfo.name
+        });
+    });
+    // 通过 CID 或 Node ID 连接到其他节点
+    app.post('/api/iroh/connect', async (req, res) => {
+        try {
+            const { cid } = req.body;
+            if (!cid) {
+                return res.status(400).json({ error: 'CID required' });
+            }
+            if (!irohInitialized) {
+                return res.status(500).json({ error: 'iroh not initialized' });
+            }
+            let targetNodeId;
+            let nodeName = 'Unknown';
+            console.log(`[iroh API] 连接到: ${cid}`);
+            // 检查是 Node ID（64字符十六进制）还是 CID
+            const isNodeId = /^[a-f0-9]{64}$/i.test(cid);
+            if (isNodeId) {
+                // 直接使用 Node ID
+                targetNodeId = cid;
+                console.log(`[iroh API] 使用直接 Node ID: ${targetNodeId.substring(0, 20)}...`);
+            }
+            else {
+                // 从 IPFS 获取节点信息
+                try {
+                    const ipfsRes = await fetch(`${IPFS_ENDPOINT}/api/v0/cat?arg=${cid}`, {
+                        method: 'POST'
+                    });
+                    const content = await ipfsRes.text();
+                    const doc = JSON.parse(content);
+                    if (!doc.irohNodeId) {
+                        return res.status(400).json({ error: '节点信息中不包含 irohNodeId' });
+                    }
+                    targetNodeId = doc.irohNodeId;
+                    nodeName = doc.name || 'Unknown';
+                    console.log(`[iroh API] 从 IPFS 获取节点: ${targetNodeId.substring(0, 20)}...`);
+                }
+                catch {
+                    return res.status(400).json({ error: '无法从 CID 获取节点信息，请确认 CID 有效' });
+                }
+            }
+            // 发送连接消息
+            const message = JSON.stringify({
+                type: 'hello',
+                from: irohNodeInfo?.irohNodeId,
+                name: irohNodeInfo?.name,
+                timestamp: Date.now()
+            });
+            const success = await irohTransport.sendMessage(targetNodeId, 'chat', new TextEncoder().encode(message));
+            if (success) {
+                console.log(`[iroh API] 连接成功!`);
+                res.json({
+                    ok: true,
+                    targetNodeId,
+                    nodeName
+                });
+            }
+            else {
+                console.log(`[iroh API] 连接失败（对方可能离线）`);
+                res.json({
+                    ok: false,
+                    error: '连接失败，对方可能离线',
+                    targetNodeId
+                });
+            }
+        }
+        catch (err) {
+            console.error('[iroh API] 连接错误:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 发送消息给指定节点
+    app.post('/api/iroh/send', async (req, res) => {
+        try {
+            const { targetNodeId, type, content } = req.body;
+            if (!targetNodeId || !content) {
+                return res.status(400).json({ error: 'targetNodeId and content required' });
+            }
+            if (!irohInitialized) {
+                return res.status(500).json({ error: 'iroh not initialized' });
+            }
+            const messageType = type || 'chat';
+            const success = await irohTransport.sendMessage(targetNodeId, messageType, new TextEncoder().encode(content));
+            res.json({ ok: success });
+        }
+        catch (err) {
+            console.error('[iroh API] 发送消息错误:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 获取已连接的 iroh 节点列表
+    app.get('/api/iroh/peers', async (_req, res) => {
+        try {
+            if (!irohInitialized) {
+                res.json([]);
+                return;
+            }
+            const peers = irohTransport.getConnectedPeers();
+            res.json(peers.map((nodeId) => ({
+                nodeId,
+                shortId: nodeId.substring(0, 16)
+            })));
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 获取离线消息数量
+    app.get('/api/iroh/offline-count', async (_req, res) => {
+        try {
+            if (!irohInitialized) {
+                res.json({ count: 0 });
+                return;
+            }
+            const count = irohTransport.getPendingOfflineCount();
+            res.json({ count });
+        }
+        catch (err) {
+            res.json({ count: 0 });
+        }
+    });
+    // 获取当前频道的身份信息
+    app.get('/api/channel-identity/:channelId', async (req, res) => {
+        try {
+            const { channelId } = req.params;
+            const channels = await loadChannels();
+            const channel = channels.find(c => c.id === channelId);
+            if (!channel) {
+                return res.status(404).json({ error: 'Channel not found' });
+            }
+            res.json({
+                did: channel.did || '',
+                cid: channel.cid || '',
+                publicKey: channel.publicKey || '',
+                name: channel.name
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 通过 DID/CID 连接远程智能体
+    app.post('/api/connect', async (req, res) => {
+        try {
+            const { did, cid, ipnsName } = req.body;
+            if (!did && !cid && !ipnsName) {
+                return res.status(400).json({ error: 'DID, CID or IPNS name required' });
+            }
+            console.log(`[连接] 尝试连接 DID: ${did}, CID: ${cid}, IPNS: ${ipnsName}`);
+            let doc = null;
+            // 1. 通过 CID 或 IPNS 解析 DiapDoc
+            if (cid || ipnsName) {
+                try {
+                    const { IpfsClient } = await import('@diap/sdk');
+                    const ipfs = new IpfsClient('http://127.0.0.1:5001', null);
+                    let resolvedCid = cid;
+                    if (ipnsName) {
+                        resolvedCid = await ipfs.resolveIpns(ipnsName);
+                    }
+                    if (resolvedCid) {
+                        const content = await ipfs.get(resolvedCid);
+                        doc = JSON.parse(content);
+                        console.log(`[连接] 解析 DiapDoc 成功: ${doc.name}`);
+                    }
+                }
+                catch (e) {
+                    console.warn(`[连接] 解析 IPFS 内容失败:`, e);
+                }
+            }
+            // 2. 如果有 DID，检查是否已连接
+            if (did) {
+                // 广播连接请求
+                if (p2pCommunicator) {
+                    const payload = JSON.stringify({
+                        type: 'connect_request',
+                        requesterDid: did,
+                        targetDid: did,
+                        timestamp: Date.now()
+                    });
+                    // 广播到网络
+                    console.log(`[连接] 广播连接请求: ${did}`);
+                }
+            }
+            // 3. 将解析的文档添加到已发现列表
+            if (doc) {
+                const discovered = global.discoveredAgents || [];
+                const existing = discovered.findIndex((a) => a.did === doc.id);
+                if (existing >= 0) {
+                    discovered[existing] = { ...discovered[existing], ...doc, lastSeen: Date.now() };
+                }
+                else {
+                    discovered.push({
+                        did: doc.id || doc.did,
+                        name: doc.name,
+                        capabilities: doc.capabilities || [],
+                        interests: doc.interests || [],
+                        channels: doc.channels || [],
+                        cid: cid,
+                        ipnsName: ipnsName,
+                        lastSeen: Date.now()
+                    });
+                }
+                global.discoveredAgents = discovered;
+                // 广播发现事件到前端
+                broadcast({ type: 'peer_discovered', peer: doc });
+            }
+            res.json({
+                ok: true,
+                did: doc?.id || did,
+                name: doc?.name,
+                capabilities: doc?.capabilities || [],
+                channels: doc?.channels || [],
+                message: doc ? 'DiapDoc 解析成功' : '连接请求已发送'
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 发送 P2P 消息
+    app.post('/api/message-p2p', async (req, res) => {
+        try {
+            const { peerId, did, message } = req.body;
+            if (!message) {
+                return res.status(400).json({ error: 'message required' });
+            }
+            let targetPeerId = peerId;
+            // 如果没有 peerId，通过 DID 查找
+            if (!targetPeerId && did) {
+                const discovered = global.discoveredAgents || [];
+                const peer = discovered.find((a) => a.did === did);
+                if (peer) {
+                    targetPeerId = peer.peerId;
+                }
+            }
+            if (!targetPeerId) {
+                // 如果没有 P2P 连接，将消息存储到本地队列
+                const messageQueue = global.messageQueue || [];
+                messageQueue.push({
+                    did,
+                    message,
+                    timestamp: Date.now(),
+                    status: 'pending'
+                });
+                global.messageQueue = messageQueue;
+                res.json({ ok: true, queued: true, message: '消息已加入队列，等待对方上线' });
+                return;
+            }
+            // 通过 P2P 发送消息（如果可用）
+            try {
+                const comm = p2pCommunicator;
+                if (comm && typeof comm.send === 'function') {
+                    await comm.send(message, targetPeerId);
+                    res.json({ ok: true, sent: true });
+                    return;
+                }
+            }
+            catch { }
+            // 如果 P2P 不可用，消息已在上面加入队列
+            res.json({ ok: true, queued: true, message: '消息已加入队列，等待对方上线' });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 获取待接收的消息队列
+    app.get('/api/peer-messages', async (_req, res) => {
+        try {
+            const messageQueue = global.messageQueue || [];
+            const pendingMessages = messageQueue.filter((m) => m.status === 'pending');
+            res.json(pendingMessages);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 标记消息已读
+    app.post('/api/peer-messages/:messageId/read', async (req, res) => {
+        try {
+            const { messageId } = req.params;
+            const messageQueue = global.messageQueue || [];
+            const msg = messageQueue.find((m) => m.id === messageId);
+            if (msg) {
+                msg.status = 'read';
+            }
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ==================== P2P 连接进度 SSE ====================
+    // 连接进度流（用于实时显示解析进度）
+    const connectProgressClients = new Map();
+    app.get('/api/p2p/connect/progress', async (req, res) => {
+        const sessionId = crypto.randomUUID();
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.write(`data: ${JSON.stringify({ type: 'start', sessionId })}\n\n`);
+        connectProgressClients.set(sessionId, res);
+        req.on('close', () => {
+            connectProgressClients.delete(sessionId);
+        });
+    });
+    function emitConnectProgress(sessionId, data) {
+        const client = connectProgressClients.get(sessionId);
+        if (client) {
+            client.write(`data: ${JSON.stringify(data)}\n\n`);
+        }
+    }
+    // 取消连接
+    app.post('/api/p2p/connect/cancel', async (req, res) => {
+        const { sessionId } = req.body;
+        if (sessionId && connectProgressClients.has(sessionId)) {
+            connectProgressClients.get(sessionId).end();
+            connectProgressClients.delete(sessionId);
+        }
+        res.json({ ok: true });
+    });
+    // ==================== P2P 连接历史 API ====================
+    const P2P_HISTORY_PATH = path.join(SHARED_SESSION_PATH, 'p2p-history.json');
+    async function loadP2PHistory() {
+        try {
+            const data = await fs.readFile(P2P_HISTORY_PATH, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return [];
+        }
+    }
+    async function saveP2PHistory(history) {
+        await fs.writeFile(P2P_HISTORY_PATH, JSON.stringify(history, null, 2));
+    }
+    // 获取连接历史
+    app.get('/api/p2p/history', async (_req, res) => {
+        try {
+            const history = await loadP2PHistory();
+            res.json(history);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 添加到连接历史
+    app.post('/api/p2p/history', async (req, res) => {
+        try {
+            const history = await loadP2PHistory();
+            const entry = req.body;
+            // 检查是否已存在
+            const existingIndex = history.findIndex((h) => h.did === entry.did);
+            if (existingIndex >= 0) {
+                history[existingIndex] = { ...history[existingIndex], ...entry, lastConnectedAt: Date.now() };
+            }
+            else {
+                history.unshift({ ...entry, id: crypto.randomUUID(), lastConnectedAt: Date.now(), lastMessageAt: 0, totalMessages: 0 });
+            }
+            await saveP2PHistory(history);
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 更新连接历史
+    app.patch('/api/p2p/history/:id', async (req, res) => {
+        try {
+            const history = await loadP2PHistory();
+            const { id } = req.params;
+            const updates = req.body;
+            const index = history.findIndex((h) => h.id === id);
+            if (index >= 0) {
+                history[index] = { ...history[index], ...updates };
+                await saveP2PHistory(history);
+            }
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 删除连接历史
+    app.delete('/api/p2p/history/:id', async (req, res) => {
+        try {
+            const history = await loadP2PHistory();
+            const { id } = req.params;
+            const filtered = history.filter((h) => h.id !== id);
+            await saveP2PHistory(filtered);
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ==================== P2P 偏好设置 API ====================
+    const P2P_PREFS_PATH = path.join(SHARED_SESSION_PATH, 'p2p-preferences.json');
+    async function loadP2PPreferences() {
+        try {
+            const data = await fs.readFile(P2P_PREFS_PATH, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return {
+                autoReconnect: true,
+                autoConnectOnStartup: true,
+                preferredNodes: [],
+                maxOfflineQueue: 100,
+                notifications: {
+                    newMessage: true,
+                    connectionEstablished: true,
+                    peerWentOnline: true,
+                    peerWentOffline: true
+                }
+            };
+        }
+    }
+    async function saveP2PPreferences(prefs) {
+        await fs.writeFile(P2P_PREFS_PATH, JSON.stringify(prefs, null, 2));
+    }
+    app.get('/api/p2p/preferences', async (_req, res) => {
+        try {
+            const prefs = await loadP2PPreferences();
+            res.json(prefs);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.patch('/api/p2p/preferences', async (req, res) => {
+        try {
+            const current = await loadP2PPreferences();
+            const updates = req.body;
+            await saveP2PPreferences({ ...current, ...updates });
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 获取持久连接列表
+    app.get('/api/p2p/persistent-connections', async (_req, res) => {
+        try {
+            const sessionProvider = app.locals.sessionProvider;
+            if (!sessionProvider) {
+                return res.json([]);
+            }
+            const channels = sessionProvider.getAllChannels().filter((ch) => ch.peerId);
+            res.json(channels.map((ch) => ({
+                id: ch.id,
+                peerId: ch.peerId || '',
+                peerDid: ch.peerDid || '',
+                peerName: ch.peerName || 'Unknown',
+                cid: ch.cid || '',
+                status: ch.peerId ? 'connected' : 'disconnected',
+                lastConnectedAt: new Date(ch.updatedAt).getTime(),
+                channelId: ch.id,
+                isAutoConnect: false
+            })));
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 更新连接状态
+    app.post('/api/p2p/connection-status', async (req, res) => {
+        try {
+            const { id, status, channelId } = req.body;
+            const sessionProvider = app.locals.sessionProvider;
+            if (sessionProvider && channelId) {
+                await sessionProvider.setChannelInfo(channelId, {
+                    peerId: status === 'connected' ? (req.body.peerId || 'connected') : undefined
+                });
+            }
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 创建对话通道
+    app.post('/api/p2p/create-channel', async (req, res) => {
+        try {
+            const { peerDid, peerName, cid, peerId } = req.body;
+            const sessionProvider = app.locals.sessionProvider;
+            if (!sessionProvider) {
+                return res.status(500).json({ error: 'sessionProvider not available' });
+            }
+            const channel = await sessionProvider.getOrCreatePeerChannel(peerDid, peerName);
+            await sessionProvider.setChannelInfo(channel.id, { peerId: peerId || '', cid: cid || '' });
+            res.json({ channelId: channel.id });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // CID 解析
+    app.post('/api/p2p/resolve-cid', async (req, res) => {
+        try {
+            const { cid } = req.body;
+            const { DiapDocParser } = await import('../social/channels/diap-doc-parser.js');
+            const parser = new DiapDocParser();
+            const result = await parser.parseFromCID(cid);
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // P2P 工具调用
+    app.post('/api/p2p/tool-call', async (req, res) => {
+        try {
+            const { tool, targetDid, payload } = req.body;
+            let result;
+            switch (tool) {
+                case 'system_info':
+                    const { getLocalSystemInfo } = await import('./components/p2p/p2p-tools.js');
+                    result = getLocalSystemInfo();
+                    break;
+                case 'file_list':
+                    const { getLocalFileList } = await import('./components/p2p/p2p-tools.js');
+                    result = getLocalFileList(payload?.path || '/');
+                    break;
+                default:
+                    return res.status(400).json({ error: `Unknown tool: ${tool}` });
+            }
+            res.json({ success: true, data: result });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ==================== 24h Heartbeat System ====================
+    let healthMonitor = null;
+    let watchdog = null;
+    // 延迟导入避免循环依赖
+    try {
+        const { createHealthMonitor, createWatchdog } = await import('../heartbeat/index.js');
+        healthMonitor = createHealthMonitor();
+        watchdog = createWatchdog();
+        console.log('[24h] Heartbeat modules loaded');
+    }
+    catch (err) {
+        console.warn('[24h] Failed to load heartbeat modules:', err);
+    }
+    // 健康检查端点
+    app.get('/api/health', async (req, res) => {
+        try {
+            if (!healthMonitor) {
+                res.status(503).json({ error: 'Health monitor not initialized' });
+                return;
+            }
+            const status = await healthMonitor.check();
+            // 记录心跳活跃
+            healthMonitor.recordHeartbeat?.();
+            watchdog?.recordActivity?.('health_check');
+            // 根据状态返回不同 HTTP 状态码
+            const httpStatus = status.status === 'healthy' ? 200 :
+                status.status === 'degraded' ? 200 : 503;
+            res.status(httpStatus).json(status);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 看门狗状态
+    app.get('/api/watchdog', async (req, res) => {
+        try {
+            if (!watchdog) {
+                res.status(503).json({ error: 'Watchdog not initialized' });
+                return;
+            }
+            const state = watchdog.getState();
+            res.json(state);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 看门狗重置
+    app.post('/api/watchdog/reset', async (req, res) => {
+        try {
+            if (watchdog) {
+                watchdog.reset();
+            }
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 启动看门狗监控
+    if (watchdog) {
+        watchdog.start();
+        console.log('[24h] Watchdog started');
+    }
+    // 定期健康检查（不阻塞主服务器启动）
+    if (healthMonitor) {
+        healthMonitor.startPeriodicCheck(60000);
+        console.log('[24h] Health monitor periodic check started');
+    }
+    return new Promise((resolve) => {
+        server.listen(port, () => {
+            console.log(`Web 服务器启动完成: http://localhost:${port}`);
+            console.log('服务器已监听');
+            setInterval(() => {
+                for (const client of sseClients) {
+                    client.res.write(': ping\n\n');
+                }
+            }, 30000);
+            resolve({ app, server });
+        });
+    });
+}
+function broadcast(data, channelId) {
+    const envelope = { ...data, channelId };
+    const message = `data: ${JSON.stringify(envelope)}\n\n`;
+    console.log(`[broadcast] type=${data.type}, channelId=${channelId}, clients=${sseClients.size}`);
+    for (const client of sseClients) {
+        if (!channelId || client.channelId === channelId) {
+            try {
+                client.res.write(message);
+            }
+            catch (e) {
+                console.error(`[broadcast] 写入失败:`, e.message);
+            }
+        }
+    }
+}
+function getUserName() {
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    const match = home.match(/\/Users\/(\w+)/);
+    if (match)
+        return match[1];
+    const user = process.env.USERNAME || process.env.USER || 'user';
+    return user.toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+export async function bootstrapIdentity() {
+    console.log('🔐 身份生成...');
+    const kp = KeyManager.generate();
+    const did = kp.did;
+    const username = getUserName();
+    const suffix = did.split(':').pop()?.substring(0, 4);
+    const name = `blln-${username}-${suffix}`;
+    console.log(`   DID: ${did.substring(0, 30)}...`);
+    return { keypair: kp, did, name };
+}
+export function publishDIDBackground(name, kp) {
+    console.log('📝 IPNS注册(后台)...');
+    let retries = 0;
+    const attempt = async () => {
+        try {
+            const auth = await AgentAuthManager.newWithRemoteIpfs('http://127.0.0.1:5001', 'http://127.0.0.1:8080');
+            await auth.registerAgent({ name, services: [] }, kp, '');
+            console.log('✅ IPNS注册成功');
+        }
+        catch (e) {
+            retries++;
+            if (retries < 10) {
+                setTimeout(attempt, 60000);
+            }
+        }
+    };
+    setTimeout(attempt, 100);
+}
+export async function bootstrapP2P(verifier) {
+    console.log('🌐 P2P连接...');
+    const rawSeed = crypto.getRandomValues(new Uint8Array(32));
+    const comm = createHyperswarmCommunicator({ server: true, client: true, autoConnect: true, maxConnections: 50, seed: rawSeed });
+    await comm.start();
+    const topic = createTopic('bolloon-agent-harness');
+    await comm.joinTopic(topic);
+    console.log('   P2P已就绪');
+    return comm;
+}
+export async function openBrowser(url) {
+    const { exec } = await import('child_process');
+    const { platform } = await import('os');
+    const p = platform();
+    let cmd;
+    if (p === 'darwin') {
+        cmd = `open ${url}`;
+    }
+    else if (p === 'win32') {
+        cmd = `start ${url}`;
+    }
+    else {
+        cmd = `xdg-open ${url}`;
+    }
+    exec(cmd, (err) => {
+        if (err) {
+            console.error('打开浏览器失败:', err.message);
+        }
+    });
+}