@bolloon/bolloon-agent 0.1.0

package/src/web/server.ts

@@ -0,0 +1,1878 @@
+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 {
+  HyperswarmCommunicator,
+  createHyperswarmCommunicator,
+  createTopic,
+  KeyManager,
+  AgentAuthManager,
+  type P2PConnection,
+} from '@diap/sdk';
+import type { AgentVerificationManager } from '@diap/sdk';
+import { documentReader } from '../documents/reader.js';
+import { initMinimax, getMinimax } from '../constraints/index.js';
+import { createAgentSession, type AgentSession, type StreamCallback, type StreamEvent } from '../agents/pi-sdk.js';
+import { llmConfigStore, type ModelProvider, PROVIDER_INFO } 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';
+
+// iroh P2P 状态
+interface IrohNodeInfo {
+  did: string;
+  cid: string;
+  irohNodeId: string;
+  name: string;
+  initialized: boolean;
+}
+let irohNodeInfo: IrohNodeInfo | null = null;
+let irohInitialized = false;
+
+interface Channel {
+  id: string;
+  name: string;
+  agentId: string;
+  did?: string;
+  publicKey?: string;
+  cid?: string;
+  didDocument?: any;
+  createdAt: string;
+  updatedAt: string;
+}
+
+interface SessionMessage {
+  id: string;
+  type: 'user' | 'ai';
+  content: string;
+  timestamp: string;
+}
+
+interface Session {
+  channelId: string;
+  messages: SessionMessage[];
+  lastUpdated: string;
+}
+
+async function ensureSessionDirs() {
+  await fs.mkdir(SESSION_CACHE_PATH, { recursive: true });
+}
+
+async function loadChannels(): Promise<Channel[]> {
+  try {
+    const data = await fs.readFile(CHANNELS_PATH, 'utf-8');
+    return JSON.parse(data);
+  } catch {
+    return [];
+  }
+}
+
+async function saveChannels(channels: Channel[]): Promise<void> {
+  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: Channel, i: number) => {
+    console.log(`  [${i}] ${ch.name}: did=${ch.did || '无'}`);
+  });
+}
+
+async function loadSession(channelId: string): Promise<Session | null> {
+  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: Session): Promise<void> {
+  const sessionPath = path.join(SESSION_CACHE_PATH, `${session.channelId}.json`);
+  await fs.writeFile(sessionPath, JSON.stringify(session, null, 2));
+}
+
+async function loadTheme(): Promise<{ theme: 'light' | 'dark'; agentId: string }> {
+  try {
+    const data = await fs.readFile(THEME_PATH, 'utf-8');
+    return JSON.parse(data);
+  } catch {
+    return { theme: 'light', agentId: '' };
+  }
+}
+
+async function saveTheme(theme: 'light' | 'dark', agentId: string): Promise<void> {
+  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');
+
+interface Task {
+  id: string;
+  type: 'read' | 'summarize' | 'improve' | 'chat' | 'workflow';
+  title: string;
+  description?: string;
+  status: 'pending' | 'running' | 'completed' | 'failed' | 'paused';
+  progress: number; // 0-100
+  result?: string;
+  error?: string;
+  createdAt: string;
+  updatedAt: string;
+  steps?: TaskStep[];
+  currentStep?: number;
+}
+
+interface TaskStep {
+  id: string;
+  name: string;
+  status: 'pending' | 'running' | 'completed' | 'failed';
+  result?: string;
+}
+
+interface WorkflowState {
+  channelId: string;
+  tasks: Task[];
+  lastUpdated: string;
+}
+
+async function loadTaskQueue(): Promise<Task[]> {
+  try {
+    const data = await fs.readFile(TASK_QUEUE_PATH, 'utf-8');
+    return JSON.parse(data);
+  } catch {
+    return [];
+  }
+}
+
+async function saveTaskQueue(tasks: Task[]): Promise<void> {
+  await fs.writeFile(TASK_QUEUE_PATH, JSON.stringify(tasks, null, 2));
+}
+
+async function loadWorkflowState(channelId: string): Promise<WorkflowState | null> {
+  try {
+    const data = await fs.readFile(WORKFLOW_STATE_PATH, 'utf-8');
+    const states = JSON.parse(data) as WorkflowState[];
+    return states.find(s => s.channelId === channelId) || null;
+  } catch {
+    return null;
+  }
+}
+
+async function saveWorkflowState(state: WorkflowState): Promise<void> {
+  try {
+    const data = await fs.readFile(WORKFLOW_STATE_PATH, 'utf-8');
+    const states = JSON.parse(data) as WorkflowState[];
+    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: string | null = null;
+
+async function executeTask(task: Task, channelId: string): Promise<void> {
+  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: any) {
+    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;
+}
+
+interface SSEClient {
+  res: express.Response;
+  channelId?: string;
+}
+
+let sseClients: Set<SSEClient> = new Set();
+let channelSessions: Map<string, AgentSession> = new Map();
+
+async function getAgentForChannel(
+  channelId: string,
+  channelDid?: string,
+  channelName?: string,
+  channelDidDoc?: any
+): Promise<AgentSession> {
+  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 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;
+}
+
+export async function createWebServer(port: number = 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 as any
+  };
+  let p2pCommunicator: HyperswarmCommunicator | null = 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
+      } as any);
+
+      p2pCommunicator.on('connection', (conn: P2PConnection) => {
+        console.log(`P2P 连接: ${conn.publicKey.substring(0, 8)}...`);
+      });
+
+      p2pCommunicator.on('message', async (msg: any, conn: P2PConnection) => {
+        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') as Buffer;
+      await p2pCommunicator.joinTopic(topic);
+      console.log(`P2P 网络已就绪`);
+    } catch (e: any) {
+      console.log(`P2P 网络初始化失败: ${e.message}`);
+    }
+  } catch (e: any) {
+    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 as string;
+    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 as any);
+
+    req.on('close', () => {
+      sseClients.delete(clientInfo as any);
+    });
+  });
+
+  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: StreamCallback = (event: StreamEvent) => {
+        // 同时发送给流式显示和工作流显示
+        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: Session = existingSession || { channelId, messages: [], lastUpdated: new Date().toISOString() };
+      session.messages.push({ id: crypto.randomUUID(), type: 'user' as const, content: text, timestamp: new Date().toISOString() });
+      session.messages.push({ id: crypto.randomUUID(), type: 'ai' as const, 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: any) {
+      broadcast({ type: 'error', content: err.message }, channelId);
+      broadcast({ type: 'done' }, channelId);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 获取频道并确保每个频道都有 DID
+async function getChannelsWithDID(): Promise<Channel[]> {
+  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: any) {
+    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: 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 = 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: any) {
+      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: any) {
+      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: any) {
+      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: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.get('/theme', async (req, res) => {
+    try {
+      const themeData = await loadTheme();
+      res.json(themeData);
+    } catch (err: any) {
+      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: any) {
+      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: StreamCallback = (event: StreamEvent) => {
+        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: any) => m.type).lastIndexOf('ai');
+        if (lastAiIndex !== -1) {
+          existingSession.messages = existingSession.messages.slice(0, lastAiIndex);
+        }
+        existingSession.messages.push({
+          id: crypto.randomUUID(),
+          type: 'ai' as const,
+          content: fullResponse,
+          timestamp: new Date().toISOString()
+        });
+        existingSession.lastUpdated = new Date().toISOString();
+        await saveSession(existingSession);
+      }
+
+      broadcast({ type: 'done' }, channelId);
+      res.json({ ok: true });
+    } catch (err: any) {
+      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: any) {
+      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: 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: string, i: number) => ({
+          id: `step_${i}`,
+          name: s,
+          status: 'pending'
+        }))
+      };
+
+      tasks.push(task);
+      await saveTaskQueue(tasks);
+
+      res.json(task);
+    } catch (err: any) {
+      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: any) {
+      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: any) {
+      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: any) {
+      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: any) {
+      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: any) {
+      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: 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: string, i: number) => ({
+          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: any) {
+      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: any) {
+      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: any) {
+      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 as ModelProvider);
+
+      // 重新初始化 Pi SDK
+      const config = await llmConfigStore.getActiveProviderConfig();
+      if (config) {
+        initMinimax({
+          provider: provider as ModelProvider,
+          apiKey: config.apiKey || undefined,
+          baseUrl: config.baseUrl || undefined,
+          model: config.model || undefined
+        });
+      }
+
+      res.json({ ok: true, provider });
+    } catch (err: any) {
+      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 as ModelProvider);
+      res.json(result);
+    } catch (err: any) {
+      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: any) {
+      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: P2PConnection) => ({
+        id: conn.publicKey.substring(0, 16),
+        publicKey: conn.publicKey,
+        peerId: conn.publicKey
+      }));
+      res.json(peers);
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 获取已发现的所有节点（包括通过 CID 解析的）
+  app.get('/api/discovered-peers', async (_req, res) => {
+    try {
+      // 从全局状态获取已发现的节点
+      const discovered = (global as any).discoveredAgents || [];
+      res.json(discovered);
+    } catch (err: any) {
+      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
+      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;
+
+      // 设置消息处理
+      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: any) {
+      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 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: any) {
+      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: any) {
+      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: string) => ({
+        nodeId,
+        shortId: nodeId.substring(0, 16)
+      })));
+    } catch (err: any) {
+      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: any) {
+      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: any) {
+      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: any = 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 as any).discoveredAgents || [];
+        const existing = discovered.findIndex((a: any) => 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 as any).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: any) {
+      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 as any).discoveredAgents || [];
+        const peer = discovered.find((a: any) => a.did === did);
+        if (peer) {
+          targetPeerId = peer.peerId;
+        }
+      }
+
+      if (!targetPeerId) {
+        // 如果没有 P2P 连接，将消息存储到本地队列
+        const messageQueue = (global as any).messageQueue || [];
+        messageQueue.push({
+          did,
+          message,
+          timestamp: Date.now(),
+          status: 'pending'
+        });
+        (global as any).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: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 获取待接收的消息队列
+  app.get('/api/peer-messages', async (_req, res) => {
+    try {
+      const messageQueue = (global as any).messageQueue || [];
+      const pendingMessages = messageQueue.filter((m: any) => m.status === 'pending');
+      res.json(pendingMessages);
+    } catch (err: any) {
+      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 as any).messageQueue || [];
+      const msg = messageQueue.find((m: any) => m.id === messageId);
+      if (msg) {
+        msg.status = 'read';
+      }
+      res.json({ ok: true });
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ==================== P2P 连接进度 SSE ====================
+
+  // 连接进度流（用于实时显示解析进度）
+  const connectProgressClients = new Map<string, any>();
+
+  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: string, data: any) {
+    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: any[]) {
+    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: any) {
+      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: any) => 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: any) {
+      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: any) => h.id === id);
+      if (index >= 0) {
+        history[index] = { ...history[index], ...updates };
+        await saveP2PHistory(history);
+      }
+
+      res.json({ ok: true });
+    } catch (err: any) {
+      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: any) => h.id !== id);
+      await saveP2PHistory(filtered);
+
+      res.json({ ok: true });
+    } catch (err: any) {
+      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: any) {
+    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: any) {
+      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: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return new Promise<{ app: express.Express; server: typeof server }>((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: object, channelId?: string) {
+  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(): string {
+  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: string, kp: any) {
+  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: any) {
+      retries++;
+      if (retries < 10) {
+        setTimeout(attempt, 60000);
+      }
+    }
+  };
+
+  setTimeout(attempt, 100);
+}
+
+export async function bootstrapP2P(verifier: AgentVerificationManager): Promise<HyperswarmCommunicator> {
+  console.log('🌐 P2P连接...');
+  const rawSeed = crypto.getRandomValues(new Uint8Array(32));
+  const comm = createHyperswarmCommunicator({ server: true, client: true, autoConnect: true, maxConnections: 50, seed: rawSeed } as any);
+
+  await comm.start();
+  const topic = createTopic('bolloon-agent-harness') as Buffer;
+  await comm.joinTopic(topic);
+  console.log('   P2P已就绪');
+
+  return comm;
+}
+
+export async function openBrowser(url: string) {
+  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);
+    }
+  });
+}