@bolloon/bolloon-agent 0.1.0

package/dist/web/server.js

@@ -0,0 +1,1647 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebServer = createWebServer;
+exports.bootstrapIdentity = bootstrapIdentity;
+exports.publishDIDBackground = publishDIDBackground;
+exports.bootstrapP2P = bootstrapP2P;
+exports.openBrowser = openBrowser;
+const express_1 = __importDefault(require("express"));
+const http_1 = require("http");
+const path_1 = require("path");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const sdk_1 = require("@diap/sdk");
+const reader_js_1 = require("../documents/reader.js");
+const index_js_1 = require("../constraints/index.js");
+const pi_sdk_js_1 = require("../agents/pi-sdk.js");
+const config_store_js_1 = require("../llm/config-store.js");
+const iroh_transport_js_1 = require("../network/iroh-transport.js");
+// 前端资源路径：在打包后会通过 CommonJS require 加载，使用全局 __dirname
+// @ts-ignore - __dirname is available in CommonJS
+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) {
+    const sessionPath = path.join(SESSION_CACHE_PATH, `${channelId}.json`);
+    try {
+        const data = await fs.readFile(sessionPath, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+async function saveSession(session) {
+    const sessionPath = path.join(SESSION_CACHE_PATH, `${session.channelId}.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 reader_js_1.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 reader_js_1.documentReader.read(task.description);
+                    const llm = (0, index_js_1.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();
+async function getAgentForChannel(channelId, channelDid, channelName, channelDidDoc) {
+    const existingSession = channelSessions.get(channelId);
+    // 如果已有 session，检查是否需要更新 identity
+    if (existingSession) {
+        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;
+    const session = await (0, pi_sdk_js_1.createAgentSession)({
+        cwd: process.cwd(),
+        peerId: `channel-${channelId}`,
+        identityDoc
+    });
+    channelSessions.set(channelId, session);
+    if (channelDid) {
+        console.log(`[Agent] 新建频道 ${channelId} session, DID = ${channelDid}, CID = ${channelDidDoc?.cid || '无'}`);
+    }
+    else {
+        console.log(`[Agent] 新建频道 ${channelId} session, 使用默认身份`);
+    }
+    return session;
+}
+async function createWebServer(port = 3000) {
+    // 防止 P2P DHT 超时等错误导致进程崩溃
+    process.on('unhandledRejection', (reason, promise) => {
+        console.error('[警告] 未处理的 Promise 拒绝:', reason);
+    });
+    // 重置旧的 agent session，确保使用新的 LLM 配置
+    const { resetAgentSession } = await Promise.resolve().then(() => __importStar(require('../agents/pi-sdk.js')));
+    resetAgentSession();
+    // 初始化 LLM（从配置文件读取 MiniMax 配置）
+    (0, index_js_1.initMinimax)();
+    // ==================== P2P DIAP 身份初始化 ====================
+    let p2pIdentity = {
+        did: '',
+        name: '',
+        publicKey: '',
+        keypair: null
+    };
+    let p2pCommunicator = null;
+    try {
+        console.log('开始生成 P2P 身份...');
+        // 生成 DIAP 身份
+        const kp = sdk_1.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 sdk_1.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 = (0, sdk_1.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 = (0, sdk_1.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 = (0, express_1.default)();
+    const server = (0, http_1.createServer)(app);
+    await ensureSessionDirs();
+    app.use(express_1.default.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_1.default.static(webRoot));
+    app.get('/', (req, res) => {
+        res.sendFile((0, path_1.join)(webRoot, 'index.html'));
+    });
+    app.get('/api-config', (req, res) => {
+        res.sendFile((0, path_1.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 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);
+                }
+                else if (event.type === 'error') {
+                    broadcast({ type: 'error', content: event.content }, channelId);
+                }
+            };
+            // 将真实 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);
+            const session = existingSession || { channelId, messages: [], lastUpdated: new Date().toISOString() };
+            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 = sdk_1.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 sdk_1.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(),
+            };
+            console.log(`[创建频道] 先保存频道 ID: ${id}`);
+            channels.push(channel);
+            await saveChannels(channels);
+            await saveSession({ channelId: id, messages: [], lastUpdated: new Date().toISOString() });
+            res.json(channel);
+            // 后台生成 DID
+            console.log(`[创建频道] 后台生成 DID...`);
+            setTimeout(async () => {
+                try {
+                    const kp = sdk_1.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 sdk_1.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 });
+        }
+    });
+    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 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);
+            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 config_store_js_1.llmConfigStore.getConfig();
+            const providerInfo = config_store_js_1.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 config_store_js_1.llmConfigStore.updateProvider(provider, config);
+            // 如果是活跃供应商，重新初始化 Pi SDK
+            const currentActive = await config_store_js_1.llmConfigStore.getActiveProvider();
+            if (provider === currentActive) {
+                const newConfig = await config_store_js_1.llmConfigStore.getActiveProviderConfig();
+                if (newConfig) {
+                    (0, index_js_1.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 config_store_js_1.llmConfigStore.setActiveProvider(provider);
+            // 重新初始化 Pi SDK
+            const config = await config_store_js_1.llmConfigStore.getActiveProviderConfig();
+            if (config) {
+                (0, index_js_1.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 config_store_js_1.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 iroh_transport_js_1.irohTransport.start(undefined, true);
+            const nodeId = iroh_transport_js_1.irohTransport.getNodeId() || '';
+            console.log(`[iroh API] iroh 节点 ID: ${nodeId.substring(0, 20)}...`);
+            // 生成 DID
+            const keyPair = sdk_1.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
+            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
+            });
+            const ipfsResult = await ipfsRes.text();
+            const cidMatch = ipfsResult.match(/"Hash":"([^"]+)"/);
+            const cid = cidMatch ? cidMatch[1] : '';
+            irohNodeInfo = {
+                did,
+                cid,
+                irohNodeId: nodeId,
+                name: nodeDoc.name,
+                initialized: true
+            };
+            irohInitialized = true;
+            // 设置消息处理
+            iroh_transport_js_1.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');
+            });
+            iroh_transport_js_1.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 连接到其他节点
+    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' });
+            }
+            console.log(`[iroh API] 连接到 CID: ${cid}`);
+            // 从 IPFS 获取节点信息
+            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' });
+            }
+            const targetNodeId = doc.irohNodeId;
+            console.log(`[iroh API] 目标节点: ${targetNodeId.substring(0, 20)}...`);
+            // 发送连接消息
+            const message = JSON.stringify({
+                type: 'hello',
+                from: irohNodeInfo?.irohNodeId,
+                name: irohNodeInfo?.name,
+                timestamp: Date.now()
+            });
+            const success = await iroh_transport_js_1.irohTransport.sendMessage(targetNodeId, 'chat', new TextEncoder().encode(message));
+            if (success) {
+                console.log(`[iroh API] 连接成功!`);
+                res.json({
+                    ok: true,
+                    targetNodeId,
+                    nodeName: doc.name || 'Unknown'
+                });
+            }
+            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 iroh_transport_js_1.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 = iroh_transport_js_1.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 = iroh_transport_js_1.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 Promise.resolve().then(() => __importStar(require('@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 发送消息
+            if (p2pCommunicator) {
+                const payload = JSON.stringify({
+                    from: 'bolloon-web',
+                    content: message,
+                    timestamp: Date.now()
+                });
+                // 找到连接并发送
+                const connections = p2pCommunicator.getConnections();
+                for (const conn of connections) {
+                    if (conn.publicKey.includes(targetPeerId) || targetPeerId.includes(conn.publicKey.substring(0, 16))) {
+                        conn.send(payload);
+                        res.json({ ok: true, sent: true });
+                        return;
+                    }
+                }
+            }
+            res.json({ ok: true, sent: false, 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 });
+        }
+    });
+    return new Promise((resolve) => {
+        server.listen(port, () => {
+            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`;
+    for (const client of sseClients) {
+        if (!channelId || client.channelId === channelId) {
+            client.res.write(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, '');
+}
+async function bootstrapIdentity() {
+    console.log('🔐 身份生成...');
+    const kp = sdk_1.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 };
+}
+function publishDIDBackground(name, kp) {
+    console.log('📝 IPNS注册(后台)...');
+    let retries = 0;
+    const attempt = async () => {
+        try {
+            const auth = await sdk_1.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);
+}
+async function bootstrapP2P(verifier) {
+    console.log('🌐 P2P连接...');
+    const rawSeed = crypto.getRandomValues(new Uint8Array(32));
+    const comm = (0, sdk_1.createHyperswarmCommunicator)({ server: true, client: true, autoConnect: true, maxConnections: 50, seed: rawSeed });
+    await comm.start();
+    const topic = (0, sdk_1.createTopic)('bolloon-agent-harness');
+    await comm.joinTopic(topic);
+    console.log('   P2P已就绪');
+    return comm;
+}
+async function openBrowser(url) {
+    const { exec } = await Promise.resolve().then(() => __importStar(require('child_process')));
+    const { platform } = await Promise.resolve().then(() => __importStar(require('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);
+        }
+    });
+}
+//# sourceMappingURL=server.js.map