@bolloon/bolloon-agent 0.1.0 → 0.1.2

package/src/web/server.ts

@@ -51,6 +51,15 @@ interface Channel {
   didDocument?: any;
   createdAt: string;
   updatedAt: string;
+  currentSessionId?: string;
+  sessions?: SessionSummary[];
+}
+
+interface SessionSummary {
+  id: string;
+  createdAt: string;
+  messageCount: number;
+  preview: string;
 }
 
 interface SessionMessage {
@@ -315,7 +324,8 @@ interface SSEClient {
 }
 
 let sseClients: Set<SSEClient> = new Set();
-let channelSessions: Map<string, AgentSession> = new Map();
+let channelSessions: Map<string, AgentSession> = new Map(); // key: channelId
+let sessionMessages: Map<string, any[]> = new Map(); // key: channelId + sessionId
 
 async function getAgentForChannel(
   channelId: string,
@@ -323,10 +333,19 @@ async function getAgentForChannel(
   channelName?: string,
   channelDidDoc?: any
 ): Promise<AgentSession> {
-  const existingSession = channelSessions.get(channelId);
+  // 获取当前 channel 的 currentSessionId
+  const channels = await loadChannels();
+  const channel = channels.find(c => c.id === channelId);
+  const currentSessionId = channel?.currentSessionId || 'default';
+  const sessionKey = `${channelId}:${currentSessionId}`;
+
+  console.log(`[Agent] 获取频道 ${channelId} 的 session, sessionKey = ${sessionKey}`);
+
+  const existingSession = channelSessions.get(sessionKey);
 
   // 如果已有 session，检查是否需要更新 identity
   if (existingSession) {
+    console.log(`[Agent] 找到现有 session: ${sessionKey}`);
     const currentIdentity = existingSession.getIdentity();
 
     // 如果当前 identity 没有真实 DID，或者 DID 与频道的 DID 不匹配，需要重建
@@ -362,17 +381,18 @@ async function getAgentForChannel(
     ipnsName: channelDidDoc?.ipnsName
   } : undefined;
 
+  console.log(`[Agent] 创建新 session: ${sessionKey}`);
   const session = await createAgentSession({
     cwd: process.cwd(),
-    peerId: `channel-${channelId}`,
+    peerId: `channel-${channelId}:${currentSessionId}`,
     identityDoc
-  });
-  channelSessions.set(channelId, session);
+  }, true); // forceNew: true 强制创建新实例
+  channelSessions.set(sessionKey, session);
 
   if (channelDid) {
-    console.log(`[Agent] 新建频道 ${channelId} session, DID = ${channelDid}, CID = ${channelDidDoc?.cid || '无'}`);
+    console.log(`[Agent] 新建频道 ${channelId} session, DID = ${channelDid}, sessionId = ${currentSessionId}`);
   } else {
-    console.log(`[Agent] 新建频道 ${channelId} session, 使用默认身份`);
+    console.log(`[Agent] 新建频道 ${channelId} session, 使用默认身份, sessionId = ${currentSessionId}`);
   }
 
   return session;
@@ -541,12 +561,15 @@ export async function createWebServer(port: number = 3000) {
           }
         } 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);
+          broadcast({ type: 'workflow_step', step: event.tool || '系统', content: event.content }, channelId);
+          console.log(`[SSE 广播] workflow_step: step=${event.tool}, content="${event.content?.substring(0, 80)}..."`);
         } else if (event.type === 'error') {
           broadcast({ type: 'error', content: event.content }, channelId);
         }
       };
 
+      console.log(`[消息处理] 开始处理用户消息, channelId: ${channelId}`);
+
       // 将真实 DID 作为上下文前缀，让 AI 使用真实的 DID 而不是自己编造的
       const contextHint = realChannelDid ? `[系统上下文] 当前频道名称: ${realChannelName}, 你的真实 DID: ${realChannelDid}\n\n` : '';
       fullResponse = await agent.promptStream(contextHint + text, streamCallback);
@@ -672,6 +695,13 @@ app.get('/channels', async (_req, res) => {
         agentId,
         createdAt: new Date().toISOString(),
         updatedAt: new Date().toISOString(),
+        currentSessionId: `sess_${Date.now()}`,
+        sessions: [{
+          id: `sess_${Date.now()}`,
+          createdAt: new Date().toISOString(),
+          messageCount: 0,
+          preview: ''
+        }]
       };
 
       console.log(`[创建频道] 先保存频道 ID: ${id}`);
@@ -714,6 +744,85 @@ app.get('/channels', async (_req, res) => {
     }
   });
 
+  // 创建新 Session（在现有 Channel 下）
+  app.post('/channels/:channelId/sessions', async (req, res) => {
+    try {
+      const { channelId } = req.params;
+      const channels = await loadChannels();
+      const channel = channels.find(c => c.id === channelId);
+
+      if (!channel) {
+        return res.status(404).json({ error: 'Channel not found' });
+      }
+
+      const sessionId = `sess_${Date.now()}`;
+      const session: SessionSummary = {
+        id: sessionId,
+        createdAt: new Date().toISOString(),
+        messageCount: 0,
+        preview: ''
+      };
+
+      if (!channel.sessions) {
+        channel.sessions = [];
+      }
+      channel.sessions.push(session);
+      channel.currentSessionId = sessionId;
+      channel.updatedAt = new Date().toISOString();
+
+      await saveChannels(channels);
+      await saveSession({ channelId, sessionId, messages: [], lastUpdated: new Date().toISOString() });
+
+      res.json({ session, currentSessionId: sessionId });
+    } catch (err: any) {
+      console.error('[创建Session] 错误:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 获取 Channel 下的所有 Sessions
+  app.get('/channels/:channelId/sessions', async (req, res) => {
+    try {
+      const { channelId } = req.params;
+      const channels = await loadChannels();
+      const channel = channels.find(c => c.id === channelId);
+
+      if (!channel) {
+        return res.status(404).json({ error: 'Channel not found' });
+      }
+
+      res.json({
+        sessions: channel.sessions || [],
+        currentSessionId: channel.currentSessionId
+      });
+    } catch (err: any) {
+      console.error('[获取Sessions] 错误:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 切换 Session
+  app.post('/channels/:channelId/sessions/:sessionId/switch', async (req, res) => {
+    try {
+      const { channelId, sessionId } = req.params;
+      const channels = await loadChannels();
+      const channel = channels.find(c => c.id === channelId);
+
+      if (!channel) {
+        return res.status(404).json({ error: 'Channel not found' });
+      }
+
+      channel.currentSessionId = sessionId;
+      channel.updatedAt = new Date().toISOString();
+      await saveChannels(channels);
+
+      res.json({ ok: true, currentSessionId: sessionId });
+    } catch (err: any) {
+      console.error('[切换Session] 错误:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
   app.delete('/channels/:channelId', async (req, res) => {
     try {
       const { channelId } = req.params;
@@ -1229,18 +1338,29 @@ app.get('/channels', async (_req, res) => {
         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] : '';
+      // 发布到 IPFS（可选，如果 IPFS 不可用则跳过）
+      let cid = '';
+      try {
+        const formData = new FormData();
+        const blob = new Blob([JSON.stringify(nodeDoc)], { type: 'application/json' });
+        formData.append('file', blob, 'node-info.json');
+
+        const ipfsRes = await fetch(`${IPFS_ENDPOINT}/api/v0/add`, {
+          method: 'POST',
+          body: formData,
+          signal: AbortSignal.timeout(5000)
+        });
+        const ipfsResult = await ipfsRes.text();
+        const cidMatch = ipfsResult.match(/"Hash":"([^"]+)"/);
+        cid = cidMatch ? cidMatch[1] : '';
+        console.log(`[iroh API] CID 发布成功: ${cid.substring(0, 20)}...`);
+      } catch (ipfsErr) {
+        console.warn('[iroh API] IPFS 不可用，跳过 CID 发布:', (ipfsErr as Error).message);
+        // 生成一个假的 CID 用于本地测试（格式：Qm + 44个随机字符）
+        const randomPart = Array.from({ length: 44 }, () => Math.random().toString(36)[2]).join('').substring(0, 44);
+        cid = `Qm${randomPart}`;
+        console.log(`[iroh API] 使用本地 CID: ${cid.substring(0, 20)}...`);
+      }
 
       irohNodeInfo = {
         did,
@@ -1300,7 +1420,7 @@ app.get('/channels', async (_req, res) => {
     });
   });
 
-  // 通过 CID 连接到其他节点
+  // 通过 CID 或 Node ID 连接到其他节点
   app.post('/api/iroh/connect', async (req, res) => {
     try {
       const { cid } = req.body;
@@ -1313,21 +1433,38 @@ app.get('/channels', async (_req, res) => {
         return res.status(500).json({ error: 'iroh not initialized' });
       }
 
-      console.log(`[iroh API] 连接到 CID: ${cid}`);
+      let targetNodeId: string;
+      let nodeName = 'Unknown';
 
-      // 从 IPFS 获取节点信息
-      const ipfsRes = await fetch(`${IPFS_ENDPOINT}/api/v0/cat?arg=${cid}`, {
-        method: 'POST'
-      });
-      const content = await ipfsRes.text();
-      const doc = JSON.parse(content);
+      console.log(`[iroh API] 连接到: ${cid}`);
 
-      if (!doc.irohNodeId) {
-        return res.status(400).json({ error: '节点信息中不包含 irohNodeId' });
-      }
+      // 检查是 Node ID（64字符十六进制）还是 CID
+      const isNodeId = /^[a-f0-9]{64}$/i.test(cid);
 
-      const targetNodeId = doc.irohNodeId;
-      console.log(`[iroh API] 目标节点: ${targetNodeId.substring(0, 20)}...`);
+      if (isNodeId) {
+        // 直接使用 Node ID
+        targetNodeId = cid;
+        console.log(`[iroh API] 使用直接 Node ID: ${targetNodeId.substring(0, 20)}...`);
+      } else {
+        // 从 IPFS 获取节点信息
+        try {
+          const ipfsRes = await fetch(`${IPFS_ENDPOINT}/api/v0/cat?arg=${cid}`, {
+            method: 'POST'
+          });
+          const content = await ipfsRes.text();
+          const doc = JSON.parse(content);
+
+          if (!doc.irohNodeId) {
+            return res.status(400).json({ error: '节点信息中不包含 irohNodeId' });
+          }
+
+          targetNodeId = doc.irohNodeId;
+          nodeName = doc.name || 'Unknown';
+          console.log(`[iroh API] 从 IPFS 获取节点: ${targetNodeId.substring(0, 20)}...`);
+        } catch {
+          return res.status(400).json({ error: '无法从 CID 获取节点信息，请确认 CID 有效' });
+        }
+      }
 
       // 发送连接消息
       const message = JSON.stringify({
@@ -1348,7 +1485,7 @@ app.get('/channels', async (_req, res) => {
         res.json({
           ok: true,
           targetNodeId,
-          nodeName: doc.name || 'Unknown'
+          nodeName
         });
       } else {
         console.log(`[iroh API] 连接失败（对方可能离线）`);
@@ -1780,6 +1917,181 @@ app.get('/channels', async (_req, res) => {
     }
   });
 
+  // 获取持久连接列表
+  app.get('/api/p2p/persistent-connections', async (_req, res) => {
+    try {
+      const sessionProvider = app.locals.sessionProvider;
+      if (!sessionProvider) {
+        return res.json([]);
+      }
+      const channels = sessionProvider.getAllChannels().filter((ch: any) => ch.peerId);
+      res.json(
+        channels.map((ch: any) => ({
+          id: ch.id,
+          peerId: ch.peerId || '',
+          peerDid: ch.peerDid || '',
+          peerName: ch.peerName || 'Unknown',
+          cid: ch.cid || '',
+          status: ch.peerId ? 'connected' : 'disconnected',
+          lastConnectedAt: new Date(ch.updatedAt).getTime(),
+          channelId: ch.id,
+          isAutoConnect: false
+        }))
+      );
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 更新连接状态
+  app.post('/api/p2p/connection-status', async (req, res) => {
+    try {
+      const { id, status, channelId } = req.body;
+      const sessionProvider = app.locals.sessionProvider;
+      if (sessionProvider && channelId) {
+        await sessionProvider.setChannelInfo(channelId, {
+          peerId: status === 'connected' ? (req.body.peerId || 'connected') : undefined
+        });
+      }
+      res.json({ ok: true });
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 创建对话通道
+  app.post('/api/p2p/create-channel', async (req, res) => {
+    try {
+      const { peerDid, peerName, cid, peerId } = req.body;
+      const sessionProvider = app.locals.sessionProvider;
+      if (!sessionProvider) {
+        return res.status(500).json({ error: 'sessionProvider not available' });
+      }
+      const channel = await sessionProvider.getOrCreatePeerChannel(peerDid, peerName);
+      await sessionProvider.setChannelInfo(channel.id, { peerId: peerId || '', cid: cid || '' });
+      res.json({ channelId: channel.id });
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // CID 解析
+  app.post('/api/p2p/resolve-cid', async (req, res) => {
+    try {
+      const { cid } = req.body;
+      const { DiapDocParser } = await import('../social/channels/diap-doc-parser.js');
+      const parser = new DiapDocParser();
+      const result = await parser.parseFromCID(cid);
+      res.json(result);
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // P2P 工具调用
+  app.post('/api/p2p/tool-call', async (req, res) => {
+    try {
+      const { tool, targetDid, payload } = req.body;
+
+      let result;
+      switch (tool) {
+        case 'system_info':
+          const { getLocalSystemInfo } = await import('./components/p2p/p2p-tools.js');
+          result = getLocalSystemInfo();
+          break;
+        case 'file_list':
+          const { getLocalFileList } = await import('./components/p2p/p2p-tools.js');
+          result = getLocalFileList(payload?.path || '/');
+          break;
+        default:
+          return res.status(400).json({ error: `Unknown tool: ${tool}` });
+      }
+
+      res.json({ success: true, data: result });
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ==================== 24h Heartbeat System ====================
+
+  let healthMonitor: any = null;
+  let watchdog: any = null;
+
+  // 延迟导入避免循环依赖
+  try {
+    const { createHealthMonitor, createWatchdog } = await import('../heartbeat/index.js');
+    healthMonitor = createHealthMonitor();
+    watchdog = createWatchdog();
+
+    console.log('[24h] Heartbeat modules loaded');
+  } catch (err) {
+    console.warn('[24h] Failed to load heartbeat modules:', err);
+  }
+
+  // 健康检查端点
+  app.get('/api/health', async (req, res) => {
+    try {
+      if (!healthMonitor) {
+        res.status(503).json({ error: 'Health monitor not initialized' });
+        return;
+      }
+
+      const status = await healthMonitor.check();
+
+      // 记录心跳活跃
+      healthMonitor.recordHeartbeat?.();
+      watchdog?.recordActivity?.('health_check');
+
+      // 根据状态返回不同 HTTP 状态码
+      const httpStatus = status.status === 'healthy' ? 200 :
+                         status.status === 'degraded' ? 200 : 503;
+
+      res.status(httpStatus).json(status);
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 看门狗状态
+  app.get('/api/watchdog', async (req, res) => {
+    try {
+      if (!watchdog) {
+        res.status(503).json({ error: 'Watchdog not initialized' });
+        return;
+      }
+
+      const state = watchdog.getState();
+      res.json(state);
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 看门狗重置
+  app.post('/api/watchdog/reset', async (req, res) => {
+    try {
+      if (watchdog) {
+        watchdog.reset();
+      }
+      res.json({ ok: true });
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 启动看门狗监控
+  if (watchdog) {
+    watchdog.start();
+    console.log('[24h] Watchdog started');
+  }
+
+  // 定期健康检查（不阻塞主服务器启动）
+  if (healthMonitor) {
+    healthMonitor.startPeriodicCheck(60000);
+    console.log('[24h] Health monitor periodic check started');
+  }
+
   return new Promise<{ app: express.Express; server: typeof server }>((resolve) => {
     server.listen(port, () => {
       console.log(`Web 服务器启动完成: http://localhost:${port}`);
@@ -1794,12 +2106,17 @@ app.get('/channels', async (_req, res) => {
   });
 }
 
-function broadcast(data: object, channelId?: string) {
+function broadcast(data: { type: string; [key: string]: unknown }, channelId?: string) {
   const envelope = { ...data, channelId };
   const message = `data: ${JSON.stringify(envelope)}\n\n`;
+  console.log(`[broadcast] type=${data.type}, channelId=${channelId}, clients=${sseClients.size}`);
   for (const client of sseClients) {
     if (!channelId || client.channelId === channelId) {
-      client.res.write(message);
+      try {
+        client.res.write(message);
+      } catch (e: unknown) {
+        console.error(`[broadcast] 写入失败:`, (e as Error).message);
+      }
     }
   }
 }

package/src/web/style.css

@@ -594,6 +594,21 @@ body {
   border-radius: 3px;
 }
 
+/* Channel messages container */
+.channel-messages {
+  display: none;
+  flex: 1;
+  overflow-y: auto;
+  padding: 24px;
+  flex-direction: column;
+  gap: 20px;
+}
+
+.channel-messages.active,
+.channel-messages:not([style*="display: none"]) {
+  display: flex;
+}
+
 .message {
   display: flex;
   flex-direction: column;
@@ -3231,6 +3246,109 @@ body {
   cursor: pointer;
 }
 
+/* Persistent Peers Section */
+.persistent-peers-section {
+  margin: 16px 0;
+  padding: 12px;
+  background: var(--bg-secondary);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+}
+
+.persistent-peers-section h4 {
+  margin-bottom: 12px;
+  font-size: 14px;
+  color: var(--text);
+}
+
+.persistent-peer-item {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 12px;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  margin-bottom: 8px;
+  background: var(--bg-primary);
+  transition: var(--transition);
+}
+
+.persistent-peer-item:last-child {
+  margin-bottom: 0;
+}
+
+.persistent-peer-item.connected {
+  border-color: var(--success);
+  background: rgba(76, 175, 80, 0.05);
+}
+
+.persistent-peer-item.disconnected {
+  opacity: 0.8;
+}
+
+.persistent-peer-item.reconnecting {
+  border-color: var(--warning);
+  animation: pulse 2s infinite;
+}
+
+@keyframes pulse {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.6; }
+}
+
+.peer-status-indicator {
+  flex-shrink: 0;
+}
+
+.peer-status-indicator .dot {
+  display: block;
+  width: 10px;
+  height: 10px;
+  border-radius: 50%;
+}
+
+.peer-status-indicator .dot.online {
+  background: var(--success);
+  box-shadow: 0 0 6px var(--success);
+}
+
+.peer-status-indicator .dot.offline {
+  background: var(--text-muted);
+}
+
+.auto-badge {
+  display: inline-block;
+  padding: 2px 6px;
+  font-size: 10px;
+  background: var(--accent);
+  color: var(--bg-primary);
+  border-radius: 4px;
+  margin-left: 6px;
+}
+
+.peer-info .peer-name {
+  display: flex;
+  align-items: center;
+  font-weight: 500;
+}
+
+.peer-info .peer-meta {
+  font-size: 12px;
+  color: var(--text-secondary);
+  display: flex;
+  gap: 12px;
+  margin-top: 4px;
+}
+
+.btn-danger {
+  background: var(--error);
+  color: white;
+}
+
+.btn-danger:hover {
+  background: #c62828;
+}
+
 /* Modal Small */
 .modal-sm {
   max-width: 300px !important;

package/tsconfig.cli.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "outDir": "./bin",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/cli-entry.ts"],
+  "exclude": ["node_modules"]
+}

package/tsconfig.electron.json

@@ -16,5 +16,5 @@
     "types": ["node"]
   },
   "include": ["src/electron.ts", "src/electron-preload.ts"],
-  "exclude": ["node_modules", "dist", "src/constraint-runtime", "src/agents", "src/web"]
+  "exclude": ["node_modules", "dist", "src/constraint-runtime", "src/agents", "src/web", "src/bollharness"]
 }

package/tsconfig.json

@@ -10,10 +10,9 @@
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "resolveJsonModule": true,
-    "ignoreDeprecations": "6.0",
     "jsx": "react-jsx",
     "jsxImportSource": "react"
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules"]
+  "exclude": ["node_modules", "src/bollharness/node_modules"]
 }

package/dist/constraint-runtime/tests/agent.test.js

@@ -1,16 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { AgentCoordinator } from '../src/agent/coordinator.js';
-describe('AgentCoordinator', () => {
-    it('dispatches parallel tasks', async () => {
-        const coordinator = new AgentCoordinator(2);
-        const results = await coordinator.dispatch('one two three four', 2);
-        expect(results.length).toBe(2);
-        expect(results.every(r => r.success)).toBe(true);
-    });
-    it('aggregates results in order', async () => {
-        const coordinator = new AgentCoordinator(2);
-        const results = await coordinator.dispatch('a b c d', 3);
-        const ids = results.map(r => r.taskId);
-        expect(ids).toEqual(ids.sort());
-    });
-});