@bolloon/bolloon-agent 0.1.27 → 0.1.29

package/src/web/server.ts

@@ -74,6 +74,10 @@ interface Channel {
   sessions?: SessionSummary[];
   /** 用户在盾牌里手动绑定的判断力 (LLM 跑 channel 时会注入). 默认 []. */
   bound_judgment_ids?: string[];
+  /** v3: 显式共享给哪些 P2P 好友 (peerPublicKey 列表). 只有这些 peer 能看到这个 channel. */
+  shared_with_peers?: string[];
+  /** v3: 自动生成的 share ID (短字符串), 方便分享给 P2P 好友. */
+  share_id?: string;
 }
 
 interface SessionSummary {
@@ -385,6 +389,10 @@ let sseClients: Set<SSEClient> = new Set();
 // v3: 远端 channel UI 元数据缓存 — key: peerId, value: sanitize 过的 channel 列表
 // in-memory only, 进程重启清空 (judgment 内容永远不在这里)
 let remoteChannelCache: Map<string, Array<Record<string, unknown>>> = new Map();
+// v3: P2PDirect 引用 (Hyperswarm 薄包装) - 模块级, 因为 web server 闭包里不可用
+let v3P2PRef: import('../network/p2p-direct.js').P2PDirect | null = null;
+// v3: 等待中的 history RPC (B 端 chat-history endpoint 用) — rpcId → { resolve, reject }
+const v3PendingHistoryGets: Map<string, { resolve: (data: any) => void; reject: (err: Error) => void }> = new Map();
 let channelSessions: Map<string, AgentSession> = new Map(); // key: channelId
 let sessionMessages: Map<string, any[]> = new Map(); // key: channelId + sessionId
 
@@ -400,8 +408,21 @@ let sessionMessages: Map<string, any[]> = new Map(); // key: channelId + session
  * v3: 过滤 channel 元数据, 只返回对远端 peer 安全的字段.
  * 关键: bound_judgment_ids / walletBinding / autoInvokeTools 内部状态不外传.
  * judgment 内容永远不会出现在 RPC 响应里 (judgment 始终在 A 节点内存, 由 A 跑 LLM).
+ *
+ * Phase 3 分享模式: 加 peerPublicKey 参数 — 只有 shared_with_peers 包含此 peer 的 channel 才返回.
+ * peerPublicKey 不传 = admin 路径, 返回所有 channel (老行为).
  */
-function sanitizeChannelForPeer(ch: Channel): Record<string, unknown> {
+function sanitizeChannelForPeer(
+  ch: Channel,
+  peerPublicKey?: string
+): Record<string, unknown> | null {
+  // Phase 3 核心: 分享过滤
+  if (peerPublicKey) {
+    const shared = Array.isArray(ch.shared_with_peers) ? ch.shared_with_peers : [];
+    if (!shared.includes(peerPublicKey)) {
+      return null; // 没分享给这个 peer, 不返回
+    }
+  }
   return {
     id: ch.id,
     name: ch.name,
@@ -409,12 +430,284 @@ function sanitizeChannelForPeer(ch: Channel): Record<string, unknown> {
     publicKey: ch.publicKey,
     createdAt: ch.createdAt,
     updatedAt: ch.updatedAt,
-    hasWallet: !!ch.walletAddress,    // 只告诉 B "有没有钱包", 不传地址
+    hasWallet: !!ch.walletAddress,
     boundJudgmentCount: Array.isArray(ch.bound_judgment_ids) ? ch.bound_judgment_ids.length : 0,
-    // 🔒 不返回: bound_judgment_ids, walletAddress, walletBinding, autoInvokeTools, sessions
+    share_id: ch.share_id,
+    // 🔒 不返回: bound_judgment_ids, walletAddress, walletBinding, autoInvokeTools, sessions, shared_with_peers
   };
 }
 
+/** v3 新增: 判断 channel 是否分享给 peerPublicKey */
+function isSharedWith(ch: Channel, peerPublicKey: string): boolean {
+  const shared = Array.isArray(ch.shared_with_peers) ? ch.shared_with_peers : [];
+  return shared.includes(peerPublicKey);
+}
+
+/**
+ * v3: 处理 Hyperswarm 通道收到的 v3 RPC 消息
+ * 设计: 用 HyperswarmCommunicator (DHT topic 自动发现) 取代 iroh 直接 connect
+ *   - A 启动 → broadcast(agent.meta.list.reply) → 所有已连接 peer 缓存 A 的 channel
+ *   - B 启动 → 同样 broadcast
+ *   - 任何节点收到 list 请求 → 回 list.reply
+ */
+async function handleV3P2PMessage(parsed: any, conn: P2PConnection, comm: HyperswarmCommunicator): Promise<void> {
+  const op = parsed.op;
+  const peerKey = conn.publicKey;
+
+  if (op === 'agent.meta.list') {
+    // 对方问我的 channel 列表 — 只返回分享给他的
+    try {
+      const channels = await loadChannels();
+      const publicMeta = channels
+        .map(ch => sanitizeChannelForPeer(ch, peerKey))
+        .filter((x): x is Record<string, unknown> => x !== null);
+      const reply = JSON.stringify({ v: 3, op: 'agent.meta.list.reply', payload: { channels: publicMeta } });
+      await comm.sendToConnection(conn.id, reply);
+      console.log(`[v3] 回 ${peerKey.substring(0,12)}... list.reply (${publicMeta.length} 个分享给 ta)`);
+    } catch (err) {
+      console.error('[v3] 处理 agent.meta.list 失败:', (err as Error).message);
+    }
+    return;
+  }
+
+  if (op === 'agent.meta.list.reply') {
+    // 对方把他自己的 channel 列表推给我 — 缓存
+    const list = parsed.payload?.channels || [];
+    remoteChannelCache.set(peerKey, list);
+    console.log(`[v3] 收到 ${peerKey.substring(0,12)}... 的 ${list.length} 个 channel, 已缓存`);
+    broadcast({
+      type: 'remote-channel-update',
+      peerId: peerKey,
+      channels: list
+    }, 'p2p-global');
+    return;
+  }
+
+  if (op === 'agent.meta.get') {
+    // 对方问单条 channel — 回
+    const channelId = parsed.payload?.channelId;
+    if (channelId) {
+      const channels = await loadChannels();
+      const ch = channels.find(c => c.id === channelId);
+      if (ch) {
+        // Phase 3: 分享过滤 — 必须分享给该 peer
+        const sanitized = sanitizeChannelForPeer(ch, peerKey);
+        if (sanitized) {
+          const reply = JSON.stringify({ v: 3, op: 'agent.meta.get.reply', payload: { channel: sanitized } });
+          await comm.sendToConnection(conn.id, reply);
+        } else {
+          const reply = JSON.stringify({ v: 3, op: 'agent.meta.get.reply', payload: { error: 'not shared with you' } });
+          await comm.sendToConnection(conn.id, reply);
+        }
+      }
+    }
+    return;
+  }
+
+  if (op === 'agent.meta.get.reply') {
+    const ch = parsed.payload?.channel;
+    if (ch && ch.id) {
+      const list = remoteChannelCache.get(peerKey) || [];
+      const idx = list.findIndex((c: any) => c.id === ch.id);
+      if (idx >= 0) list[idx] = ch;
+      else list.push(ch);
+      remoteChannelCache.set(peerKey, list);
+      broadcast({
+        type: 'remote-channel-update',
+        peerId: peerKey,
+        channels: list
+      }, 'p2p-global');
+    }
+    return;
+  }
+
+  if (op === 'agent.chat.send') {
+    // B 端发来: 在 A 节点上对 channelId 跑 LLM, 结果回 B
+    // judgment 永远在 A 节点 (buildJudgmentHint 已经用 bound_judgment_ids)
+    const { channelId, text, fromPublicKey } = parsed.payload || {};
+    if (!channelId || !text) {
+      console.warn(`[v3] agent.chat.send 缺少 channelId/text`);
+      return;
+    }
+    const senderKey = fromPublicKey || peerKey;
+    console.log(`[v3] 收到 ${senderKey.substring(0,12)}... 对 channel ${channelId} 的 chat: "${text.substring(0, 40)}..."`);
+    try {
+      // 1. 找到 channel
+      const channels = await loadChannels();
+      const ch = channels.find(c => c.id === channelId);
+      if (!ch) {
+        const reply = JSON.stringify({
+          v: 3, op: 'agent.chat.reply',
+          payload: { channelId, fromPublicKey: v3P2PRef?.getPublicKey() || '', error: 'channel not found', text: '' }
+        });
+        await comm.sendToConnection(conn.id, reply);
+        return;
+      }
+      // v3 新增: 持久化 B 的 user 消息到 A 的 session — 让历史可拉
+      try {
+        const existing = await loadSession(channelId, 'default');
+        const session: Session = existing || {
+          channelId, sessionId: 'default', messages: [], lastUpdated: new Date().toISOString()
+        };
+        session.messages.push({
+          id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+          type: 'user',
+          content: text,
+          timestamp: new Date().toISOString()
+        });
+        session.lastUpdated = new Date().toISOString();
+        await saveSession(session);
+        console.log(`[v3] (${channelId}) 存 user 消息 (${text.length} chars) 到 A 的 session`);
+      } catch (saveErr) {
+        console.warn(`[v3] 存 user 消息失败 (不影响 chat):`, (saveErr as Error).message);
+      }
+
+      // v3 新增: 告诉 B "我开始想了, 用了哪些 judgment" — 让 B 看到决策依据
+      const judgmentHint = await buildJudgmentHint(ch, channelId);
+      const usedJudgments = await extractJudgmentsFromHint(ch);
+      try {
+        const thinkingStart = JSON.stringify({
+          v: 3, op: 'agent.chat.thinking',
+          payload: {
+            channelId,
+            phase: 'start',
+            fromPublicKey: v3P2PRef?.getPublicKey() || '',
+            hint: judgmentHint,
+            usedJudgments,
+            userText: text
+          }
+        });
+        await comm.sendToConnection(conn.id, thinkingStart);
+      } catch {}
+
+      // 2. 跑 LLM (复用 Phase 1 的 buildJudgmentHint — 注入 channel 的 judgment)
+      const { getMinimax } = await import('../constraints/index.js');
+      const llm = getMinimax();
+      const fullPrompt = `${judgmentHint}${text}`;
+      let fullResponse = '';
+      // v3 新增: 流式 token 节流推给 B — 让 B 看到过程
+      let lastFlushAt = 0;
+      const streamCallback: any = (event: any) => {
+        if (event.type === 'token') {
+          fullResponse += event.content;
+          if (fullResponse.length - lastFlushAt >= 20) {
+            lastFlushAt = fullResponse.length;
+            const msg = JSON.stringify({
+              v: 3, op: 'agent.chat.thinking',
+              payload: { channelId, phase: 'token', partial: fullResponse, fromPublicKey: v3P2PRef?.getPublicKey() || '' }
+            });
+            comm.sendToConnection(conn.id, msg).catch(() => {});
+          }
+        }
+      };
+      const agent = await getAgentForChannel(channelId, ch.did || '', ch.name, ch.didDocRef);
+      fullResponse = await agent.promptStream(fullPrompt, streamCallback);
+
+      // v3 新增: 存 A 的 assistant 消息到 session — B 拉历史时能看到完整对话
+      try {
+        const existing = await loadSession(channelId, 'default');
+        const session: Session = existing || {
+          channelId, sessionId: 'default', messages: [], lastUpdated: new Date().toISOString()
+        };
+        session.messages.push({
+          id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+          type: 'ai',
+          content: fullResponse,
+          timestamp: new Date().toISOString()
+        });
+        session.lastUpdated = new Date().toISOString();
+        await saveSession(session);
+        console.log(`[v3] (${channelId}) 存 assistant 回复 (${fullResponse.length} chars) 到 A 的 session`);
+      } catch (saveErr) {
+        console.warn(`[v3] 存 assistant 消息失败 (不影响):`, (saveErr as Error).message);
+      }
+
+      // 3. 把完整回复发给 B
+      const reply = JSON.stringify({
+        v: 3, op: 'agent.chat.reply',
+        payload: {
+          channelId,
+          fromPublicKey: v3P2PRef?.getPublicKey() || '',
+          text: fullResponse
+        }
+      });
+      await comm.sendToConnection(conn.id, reply);
+      console.log(`[v3] 回 chat.reply 给 ${senderKey.substring(0,12)}... (${fullResponse.length} chars)`);
+    } catch (err) {
+      console.error(`[v3] agent.chat.send 处理失败:`, (err as Error).message);
+      try {
+        const reply = JSON.stringify({
+          v: 3, op: 'agent.chat.reply',
+          payload: { channelId, fromPublicKey: v3P2PRef?.getPublicKey() || '', error: (err as Error).message, text: '' }
+        });
+        await comm.sendToConnection(conn.id, reply);
+      } catch {}
+    }
+    return;
+  }
+
+  if (op === 'agent.history.get') {
+    // v3 新增: B 拉 A 的 channel 历史 (含所有 message + judgment hint)
+    // 共享过滤: 只返回 B 可见的 channel + 包含的 judgment
+    const { channelId, rpcId, fromPublicKey } = parsed.payload || {};
+    if (!channelId || !rpcId) {
+      console.warn(`[v3] agent.history.get 缺少 channelId/rpcId`);
+      return;
+    }
+    try {
+      const channels = await loadChannels();
+      const ch = channels.find(c => c.id === channelId);
+      if (!ch) {
+        const err = JSON.stringify({
+          v: 3, op: 'agent.history.get.reply',
+          payload: { rpcId, error: 'channel not found', messages: [], judgments: { bound: [], candidates: [] } }
+        });
+        await comm.sendToConnection(conn.id, err);
+        return;
+      }
+      // 共享过滤: 必须 peerKey 在 shared_with_peers 里 (避免泄露未分享的 channel)
+      const peerKey = fromPublicKey;
+      if (!peerKey || !isSharedWith(ch, peerKey)) {
+        const err = JSON.stringify({
+          v: 3, op: 'agent.history.get.reply',
+          payload: { rpcId, error: 'channel not shared with you', messages: [], judgments: { bound: [], candidates: [] } }
+        });
+        await comm.sendToConnection(conn.id, err);
+        return;
+      }
+      // 加载 A 端 session
+      const session = await loadSession(channelId, 'default');
+      // 加载 channel 用到的 judgment
+      const judgments = await extractJudgmentsFromHint(ch);
+      const reply = JSON.stringify({
+        v: 3, op: 'agent.history.get.reply',
+        payload: {
+          rpcId,
+          channelId,
+          messages: session?.messages || [],
+          lastUpdated: session?.lastUpdated,
+          judgments,
+          channelName: ch.name
+        }
+      });
+      await comm.sendToConnection(conn.id, reply);
+      console.log(`[v3] 回 history.reply 给 ${peerKey.substring(0,12)}... (channelId=${channelId}, ${session?.messages?.length || 0} messages)`);
+    } catch (err) {
+      console.error(`[v3] agent.history.get 处理失败:`, (err as Error).message);
+      try {
+        const errMsg = JSON.stringify({
+          v: 3, op: 'agent.history.get.reply',
+          payload: { rpcId, error: (err as Error).message, messages: [], judgments: { bound: [], candidates: [] } }
+        });
+        await comm.sendToConnection(conn.id, errMsg);
+      } catch {}
+    }
+    return;
+  }
+
+  console.log(`[v3] 收到未知 op: ${op}`);
+}
+
 async function buildJudgmentHint(
   channel: Channel | undefined | null,
   channelIdForLog: string
@@ -469,6 +762,47 @@ async function buildJudgmentHint(
   }
 }
 
+/**
+ * v3 新增: 把 channel 当前用到的 judgment 提取成结构化数据, 给 B 端 UI 显示.
+ * 返回 { bound: [...], candidates: [...] } — bound 是硬绑定, candidates 是参考池.
+ */
+async function extractJudgmentsFromHint(
+  channel: Channel | undefined | null
+): Promise<{ bound: any[]; candidates: any[] }> {
+  try {
+    const { loadAllJudgments, initializeValueStore } = await import(
+      '../pi-ecosystem-judgment/human-value-store.js'
+    );
+    await initializeValueStore();
+    const allJudgments = await loadAllJudgments();
+    if (allJudgments.length === 0) return { bound: [], candidates: [] };
+
+    const boundIds = new Set(
+      channel && Array.isArray(channel.bound_judgment_ids) ? channel.bound_judgment_ids : []
+    );
+
+    const summarize = (j: any) => ({
+      id: j.id,
+      decision: (j.decision || '').toString().slice(0, 200),
+      reasons: Array.isArray(j.reasons) ? j.reasons : [],
+      domain: j.domain,
+      stakes: j.stakes
+    });
+
+    const bound = allJudgments
+      .filter((j: any) => j.id !== undefined && boundIds.has(j.id))
+      .map(summarize);
+    const candidates = allJudgments
+      .filter((j: any) => j.id !== undefined && !boundIds.has(j.id))
+      .map(summarize);
+
+    return { bound, candidates };
+  } catch (err) {
+    console.warn(`[v3] extractJudgmentsFromHint 失败:`, (err as Error).message);
+    return { bound: [], candidates: [] };
+  }
+}
+
 async function getAgentForChannel(
   channelId: string,
   channelDid?: string,
@@ -602,7 +936,157 @@ export async function createWebServer(port: number = 3000, options: CreateWebSer
       console.log('P2P DID 本地模式运行');
     }
 
-    // 初始化 P2P 通信器
+    // v3: 完全用 P2PDirect 取代 @diap/sdk 的 HyperswarmCommunicator
+    // 原因: @diap/sdk 的 sendToConnection 是 stub, 不真发数据
+    // 这里故意不启动 p2pCommunicator (保持 null), 让 P2PDirect 独占 hyperswarm 通道
+    try {
+      const { P2PDirect } = await import('../network/p2p-direct.js');
+      v3P2PRef = new P2PDirect({ name: 'v3' });
+      await v3P2PRef.start();
+      await v3P2PRef.joinTopic(Buffer.from('bolloon-agent-harness'));
+
+      v3P2PRef.on('data', (evt: any) => {
+        try {
+          const parsed = JSON.parse(evt.data.toString('utf-8'));
+          if (parsed && parsed.v === 3 && parsed.op) {
+            // v3 跨用户 chat: B 端收到 A 的 chat.reply, 直接 SSE 推给前端
+            if (parsed.op === 'agent.chat.reply') {
+              console.log(`[v3] 收到来自 ${evt.fromPublicKey.substring(0,12)}... 的 chat.reply (${(parsed.payload?.text || '').length} chars)`);
+              broadcast({
+                type: 'remote-chat-reply',
+                fromPublicKey: evt.fromPublicKey,
+                channelId: parsed.payload?.channelId,
+                text: parsed.payload?.text || '',
+                error: parsed.payload?.error
+              }, 'p2p-global');
+              return;
+            }
+            // v3 新增: B 端收到 A 的 thinking (开始 + 流式 token)
+            if (parsed.op === 'agent.chat.thinking') {
+              const phase = parsed.payload?.phase;
+              if (phase === 'start') {
+                console.log(`[v3] 收到来自 ${evt.fromPublicKey.substring(0,12)}... 的 thinking start (judgments: bound=${(parsed.payload?.usedJudgments?.bound || []).length}, candidates=${(parsed.payload?.usedJudgments?.candidates || []).length})`);
+              }
+              broadcast({
+                type: 'remote-chat-thinking',
+                fromPublicKey: evt.fromPublicKey,
+                channelId: parsed.payload?.channelId,
+                phase: parsed.payload?.phase,
+                partial: parsed.payload?.partial,
+                hint: parsed.payload?.hint,
+                usedJudgments: parsed.payload?.usedJudgments,
+                userText: parsed.payload?.userText
+              }, 'p2p-global');
+              return;
+            }
+            // v3 新增: B 端收到 A 的 history reply → resolve pending promise
+            if (parsed.op === 'agent.history.get.reply') {
+              const rpcId = parsed.payload?.rpcId;
+              if (rpcId && v3PendingHistoryGets.has(rpcId)) {
+                const pending = v3PendingHistoryGets.get(rpcId)!;
+                v3PendingHistoryGets.delete(rpcId);
+                if (parsed.payload?.error) {
+                  pending.reject(new Error(parsed.payload.error));
+                } else {
+                  pending.resolve({
+                    channelId: parsed.payload.channelId,
+                    messages: parsed.payload.messages || [],
+                    lastUpdated: parsed.payload.lastUpdated,
+                    judgments: parsed.payload.judgments || { bound: [], candidates: [] },
+                    channelName: parsed.payload.channelName
+                  });
+                }
+              }
+              return;
+            }
+            const commShim = {
+              sendToConnection: (_id: string, data: string) => {
+                v3P2PRef!.sendTo(evt.fromPublicKey, data);
+                return Promise.resolve();
+              }
+            };
+            handleV3P2PMessage(parsed, { id: evt.fromPublicKey, publicKey: evt.fromPublicKey } as any, commShim as any);
+          }
+        } catch (err) {
+          console.error('[v3-P2PDirect] 解析/处理消息失败:', (err as Error).message);
+        }
+      });
+
+      // 新连接进来 → 主动发我分享给 ta 的 channel 列表
+      v3P2PRef.on('connection', (evt: any) => {
+        setTimeout(async () => {
+          try {
+            const channels = await loadChannels();
+            const publicMeta = channels
+              .map(ch => sanitizeChannelForPeer(ch, evt.remotePublicKey))
+              .filter((x): x is Record<string, unknown> => x !== null);
+            const msg = JSON.stringify({ v: 3, op: 'agent.meta.list.reply', payload: { channels: publicMeta } });
+            v3P2PRef!.sendTo(evt.remotePublicKey, msg);
+            console.log(`[v3] 新连接 ${evt.remotePublicKey.substring(0,12)}... → 发 ${publicMeta.length} 个分享给 ta`);
+          } catch (err) {
+            console.error('[v3] 新连接发 list.reply 失败:', (err as Error).message);
+          }
+        }, 500);
+      });
+
+      console.log(`[v3] P2PDirect 已启动, role=${v3P2PRef.getRole()}, publicKey=${v3P2PRef.getPublicKey().substring(0,12)}...`);
+
+      // v3: 启动后自动重连 known peers — 让"启动就互联"成为现实
+      setTimeout(async () => {
+        try {
+          const { listPeers, markConnected } = await import('../network/known-peers.js');
+          const peers = await listPeers();
+          if (peers.length === 0) {
+            console.log(`[v3] 没有 known peers, 跳过自动重连`);
+            return;
+          }
+          const swarm = (v3P2PRef as any).swarm;
+          if (!swarm) return;
+          for (const peer of peers) {
+            try {
+              await swarm.joinPeer(Buffer.from(peer.publicKey, 'hex'));
+              await markConnected(peer.name || '');
+              console.log(`[v3] 自动重连 ${peer.name} (${peer.publicKey.substring(0, 12)}...) ✓`);
+            } catch (err) {
+              console.warn(`[v3] 自动重连 ${peer.name} 失败:`, (err as Error).message);
+            }
+          }
+          // 触发一次 broadcast 推送给所有重连的 peer
+          setTimeout(() => v3BroadcastOwn(), 2000);
+        } catch (err) {
+          console.error('[v3] 自动重连失败:', (err as Error).message);
+        }
+      }, 5000); // 5s 后再重连, 让 swarm 充分 bootstrap
+    } catch (err) {
+      console.error('[v3] P2PDirect 启动失败:', (err as Error).message);
+      v3P2PRef = null;
+    }
+
+    // v3: 定期 broadcast — 每个 peer 只收到分享给他的 channel (按 peer 个性化)
+    const v3BroadcastOwn = () => {
+      if (!v3P2PRef) return;
+      loadChannels().then(channels => {
+        const conns = (v3P2PRef as any).conns as Map<string, any>;
+        if (!conns) return;
+        for (const [peerPk, conn] of conns.entries()) {
+          if (conn?.destroyed) continue;
+          const sharedForPeer = channels
+            .map(ch => sanitizeChannelForPeer(ch, peerPk))
+            .filter((x): x is Record<string, unknown> => x !== null);
+          if (sharedForPeer.length > 0) {
+            const msg = JSON.stringify({ v: 3, op: 'agent.meta.list.reply', payload: { channels: sharedForPeer } });
+            try { conn.write(Buffer.from(msg)); } catch {}
+          }
+        }
+        console.log(`[v3] broadcast 个性化: ${conns.size} 个 peer, 各自收到分享的 channel`);
+      }).catch(err => console.error('[v3] broadcast 失败:', (err as Error).message));
+    };
+    setTimeout(v3BroadcastOwn, 3000);
+    setTimeout(v3BroadcastOwn, 10000);
+    setTimeout(v3BroadcastOwn, 20000);
+    setTimeout(v3BroadcastOwn, 40000);
+
+    // 保留 @diap/sdk 的旧实例 (它的 Hyperswarm 实例能帮 P2PDirect 做 DHT bootstrap)
     try {
       const rawSeed = crypto.getRandomValues(new Uint8Array(32));
       p2pCommunicator = createHyperswarmCommunicator({
@@ -612,24 +1096,19 @@ export async function createWebServer(port: number = 3000, options: CreateWebSer
         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) => {
+        // 旧 p2p_message 路径 (非 v3)
         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 网络已就绪`);
+      // @diap/sdk 也 join topic — 它的 Hyperswarm 实例帮 P2PDirect 做 DHT 引导
+      // @diap/sdk 收到的数据是 mock (不真发), 但 DHT 发现 + 节点连接是 OK 的
+      const oldTopic = createTopic('bolloon-agent-harness') as Buffer;
+      await p2pCommunicator.joinTopic(oldTopic);
+      console.log(`P2P 老通道已就绪 (DHT bootstrap 帮 P2PDirect, 实际数据走 P2PDirect)`);
     } catch (e: any) {
-      console.log(`P2P 网络初始化失败: ${e.message}`);
+      console.log(`P2P 老通道初始化失败: ${e.message}`);
     }
   } catch (e: any) {
     console.log(`P2P 身份初始化失败: ${e.message}`);
@@ -944,6 +1423,25 @@ app.get('/channels', async (_req, res) => {
   // 用法: B 端用户点 "刷新远端智能体" → 触发本 endpoint
   app.post('/api/remote-channels/refresh', async (_req, res) => {
     try {
+      // Phase 3: 优先用 P2PDirect conns (Phase 2/3 的真实通道)
+      if (v3P2PRef) {
+        const conns = (v3P2PRef as any).conns as Map<string, any>;
+        const peerIds = Array.from(conns.keys()).filter(pk => {
+          const c = conns.get(pk);
+          return c && !c.destroyed;
+        });
+        if (peerIds.length === 0) {
+          return res.json({ ok: true, sent: 0, note: 'no connected peers (P2PDirect)' });
+        }
+        // 让每个 peer 拉 list — Phase 3 个性化分享过滤
+        let sent = 0;
+        for (const peerPk of peerIds) {
+          const ok = await (v3P2PRef as any).sendTo(peerPk, JSON.stringify({ v: 3, op: 'agent.meta.list', payload: {} }));
+          if (ok) sent++;
+        }
+        return res.json({ ok: true, sent, total: peerIds.length });
+      }
+      // Fallback: 老 iroh 路径
       const peers = irohTransport.getPeers ? irohTransport.getPeers() : [];
       const peerIds = Array.isArray(peers) ? peers.map((p: any) => p.nodeId || p) : [];
       if (peerIds.length === 0) {
@@ -964,6 +1462,40 @@ app.get('/channels', async (_req, res) => {
     }
   });
 
+  // ===== v3: 主动 connect 到对端, 再发 agent.meta.list =====
+  // 用法: POST /api/remote-channels/connect { targetAddr: "<完整 EndpointAddr 含 relay URL>" }
+  // targetAddr 应来自对端 GET /api/iroh-addr (完整字符串, 不只是 nodeId)
+  // 兼容旧用法: 也接受 targetNodeId, 但只有 nodeId 不一定能 connect 成功
+  app.post('/api/remote-channels/connect', async (req, res) => {
+    try {
+      const { targetAddr, targetNodeId } = req.body || {};
+      const target = targetAddr || targetNodeId;
+      if (!target || typeof target !== 'string') {
+        return res.status(400).json({ error: 'targetAddr (or targetNodeId) required' });
+      }
+      console.log(`[v3] 主动 connect 到 ${target.substring(0, 32)}...`);
+      // iroh connect 接受 nodeId 或完整 addr 字符串 — 用完整 addr 才会成功
+      const ok = await irohTransport.connect(target);
+      if (!ok) {
+        return res.status(502).json({
+          error: 'connect failed',
+          hint: '传 targetAddr (完整 EndpointAddr 字符串, 含 relay URL) 而非仅 nodeId'
+        });
+      }
+      // 立即发 agent.meta.list 请求对端返回元数据
+      const sent = await irohTransport.sendMessage(
+        target,
+        'agent.meta.list',
+        new TextEncoder().encode('{}')
+      );
+      console.log(`[v3] connect+list 发送结果: connect=ok, list=${sent}`);
+      res.json({ ok: true, connected: true, sent, target });
+    } catch (err: any) {
+      console.error('[v3] /api/remote-channels/connect 失败:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
   app.post('/channels', async (req, res) => {
     try {
       const { name, agentId, walletAddress, autoInvokeTools, bound_judgment_ids } = req.body;
@@ -1172,7 +1704,7 @@ app.get('/channels', async (_req, res) => {
   app.patch('/channels/:channelId', async (req, res) => {
     try {
       const { channelId } = req.params;
-      const { name, walletAddress, autoInvokeTools, bound_judgment_ids } = req.body;
+      const { name, walletAddress, autoInvokeTools, bound_judgment_ids, shared_with_peers } = req.body;
       const channels = await loadChannels();
       const channel = channels.find(c => c.id === channelId);
       if (!channel) {
@@ -1211,6 +1743,24 @@ app.get('/channels', async (_req, res) => {
         }
         console.log(`[Channel ${channelId}] 绑定判断力: ${channel.bound_judgment_ids.length} 条`);
       }
+      // Phase 3: shared_with_peers (显式分享给指定 peerPublicKey 列表)
+      if (shared_with_peers !== undefined) {
+        if (shared_with_peers === null) {
+          channel.shared_with_peers = [];
+        } else if (Array.isArray(shared_with_peers)) {
+          channel.shared_with_peers = shared_with_peers.filter(
+            (x: unknown) => typeof x === 'string' && (x as string).length === 64  // iroh/hyperswarm pubkey 32 字节 = 64 hex
+          );
+        } else {
+          return res.status(400).json({ error: 'shared_with_peers must be array of publicKey hex' });
+        }
+        console.log(`[Channel ${channelId}] 分享给 ${channel.shared_with_peers.length} 个 peer`);
+      }
+      // 首次保存时自动生成 share_id (短字符串, 方便粘贴)
+      if (!channel.share_id) {
+        channel.share_id = `shr_${channelId.slice(3, 12)}_${Math.random().toString(36).substring(2, 8)}`;
+        console.log(`[Channel ${channelId}] 自动生成 share_id: ${channel.share_id}`);
+      }
       channel.updatedAt = new Date().toISOString();
       await saveChannels(channels);
       res.json(channel);
@@ -1796,6 +2346,184 @@ app.get('/channels', async (_req, res) => {
     }
   });
 
+  // v3 测试: 返回 iroh endpoint 完整地址 (含 relay URL), 这才是 connect() 真正需要的
+  app.get('/api/iroh-addr', async (_req, res) => {
+    try {
+      const addr = irohTransport.getEndpointAddr
+        ? irohTransport.getEndpointAddr()
+        : irohTransport.getNodeId();
+      res.json({ addr });
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // v3: 暴露 P2PDirect 自己的 publicKey, 对方可用它主动 connect
+  app.get('/api/p2p-publickey', async (_req, res) => {
+    try {
+      if (!v3P2PRef) {
+        return res.status(503).json({ error: 'P2PDirect not started' });
+      }
+      res.json({ publicKey: v3P2PRef.getPublicKey() });
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // v3: known peers CRUD (持久化到 ~/.bolloon/known_peers.json)
+  // GET 列表, POST 加/更新, DELETE 删, PATCH 重命名
+  app.get('/api/p2p-peers', async (_req, res) => {
+    try {
+      const { listPeers } = await import('../network/known-peers.js');
+      const peers = await listPeers();
+      res.json({ count: peers.length, peers });
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+  app.post('/api/p2p-peers', async (req, res) => {
+    try {
+      const { name, publicKey, notes } = req.body || {};
+      if (!name || !publicKey) return res.status(400).json({ error: 'name and publicKey required' });
+      if (typeof publicKey !== 'string' || publicKey.length !== 64) {
+        return res.status(400).json({ error: 'publicKey must be 64-char hex (32 bytes)' });
+      }
+      const { addOrUpdatePeer } = await import('../network/known-peers.js');
+      await addOrUpdatePeer(name, publicKey, notes);
+      res.json({ ok: true });
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+  app.delete('/api/p2p-peers/:name', async (req, res) => {
+    try {
+      const { removePeer } = await import('../network/known-peers.js');
+      await removePeer(req.params.name);
+      res.json({ ok: true });
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // v3: 主动 connect 到对端的 P2PDirect publicKey
+  // 用法: POST /api/remote-channels/p2p-connect { targetPublicKey: "<hex>" }
+  app.post('/api/remote-channels/p2p-connect', async (req, res) => {
+    try {
+      if (!v3P2PRef) {
+        return res.status(503).json({ error: 'P2PDirect not started' });
+      }
+      const { targetPublicKey, name, persist } = req.body || {};
+      if (!targetPublicKey || typeof targetPublicKey !== 'string') {
+        return res.status(400).json({ error: 'targetPublicKey required (hex)' });
+      }
+      // v3P2PRef 直接连到目标 publicKey (用 hyperswarm 的 joinPeer API)
+      const swarm = (v3P2PRef as any).swarm;
+      if (!swarm) return res.status(503).json({ error: 'swarm not available' });
+      const conn = await swarm.joinPeer(Buffer.from(targetPublicKey, 'hex'));
+      console.log(`[v3] 已主动 joinPeer ${targetPublicKey.substring(0, 12)}...`);
+
+      // 自动持久化 (默认开启) — 之后启动自动重连
+      let persistedAs: string | null = null;
+      if (persist !== false) {
+        const { addOrUpdatePeer, findNameByPublicKey } = await import('../network/known-peers.js');
+        // 优先用客户端传的 name, 否则用 publicKey 前 8 位
+        const peerName = name || `peer-${targetPublicKey.substring(0, 8)}`;
+        // 如果 publicKey 已被别的 name 占用, 用现有 name
+        const existingName = await findNameByPublicKey(targetPublicKey);
+        persistedAs = existingName ?? peerName ?? `peer-${targetPublicKey.substring(0, 8)}`;
+        await addOrUpdatePeer(persistedAs, targetPublicKey);
+        console.log(`[v3] 自动持久化 peer: ${persistedAs}`);
+      }
+
+      res.json({ ok: true, target: targetPublicKey, persistedAs });
+    } catch (err: any) {
+      console.error('[v3] p2p-connect 失败:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // v3: 给远端 channel 发消息 (B 节点) - 通过 P2PDirect 转发到 A, A 跑 LLM, 回 B
+  // 用法: POST /api/remote-channels/chat-send
+  //   { targetPublicKey, channelId, text }
+  app.post('/api/remote-channels/chat-send', async (req, res) => {
+    try {
+      if (!v3P2PRef) {
+        return res.status(503).json({ error: 'P2PDirect not started' });
+      }
+      const { targetPublicKey, channelId, text } = req.body || {};
+      if (!targetPublicKey || !channelId || !text) {
+        return res.status(400).json({ error: 'targetPublicKey, channelId, text required' });
+      }
+      if (typeof text !== 'string' || text.length === 0 || text.length > 8000) {
+        return res.status(400).json({ error: 'text length must be 1-8000' });
+      }
+      const fromPk = v3P2PRef.getPublicKey();
+      const msg = JSON.stringify({
+        v: 3,
+        op: 'agent.chat.send',
+        payload: { channelId, text, fromPublicKey: fromPk }
+      });
+      const ok = v3P2PRef.sendTo(targetPublicKey, msg);
+      if (!ok) {
+        return res.status(502).json({
+          error: 'peer not connected. POST /api/remote-channels/p2p-connect first.'
+        });
+      }
+      console.log(`[v3] chat-send 转发到 ${targetPublicKey.substring(0, 12)}... (channelId=${channelId})`);
+      res.json({ ok: true, sent: true });
+    } catch (err: any) {
+      console.error('[v3] chat-send 失败:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // v3 新增: B 拉 A 的 channel 历史 + 用了哪些 judgment
+  // GET /api/remote-channels/chat-history?targetPublicKey=...&channelId=...
+  // 实现: B → POST 给 A 一个 agent.history.get RPC → A 把 session 返回 → B 渲染
+  app.get('/api/remote-channels/chat-history', async (req, res) => {
+    try {
+      if (!v3P2PRef) {
+        return res.status(503).json({ error: 'P2PDirect not started' });
+      }
+      const targetPublicKey = String(req.query.targetPublicKey || '');
+      const channelId = String(req.query.channelId || '');
+      if (!targetPublicKey || !channelId) {
+        return res.status(400).json({ error: 'targetPublicKey, channelId required' });
+      }
+
+      // 通过 RPC 拉 A 的 session — A 端收到后异步回复
+      const fromPk = v3P2PRef.getPublicKey();
+      const rpcId = `hist-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      const msg = JSON.stringify({
+        v: 3,
+        op: 'agent.history.get',
+        payload: { rpcId, channelId, fromPublicKey: fromPk }
+      });
+      const ok = v3P2PRef.sendTo(targetPublicKey, msg);
+      if (!ok) {
+        return res.status(502).json({ error: 'peer not connected' });
+      }
+
+      // 等待 A 异步回复 (15s timeout) — 用一个 Promise 等
+      const result = await new Promise<any>((resolve, reject) => {
+        const timer = setTimeout(() => {
+          v3PendingHistoryGets.delete(rpcId);
+          reject(new Error('A 端 15s 内未回复, 可能未分享该 channel'));
+        }, 15000);
+        v3PendingHistoryGets.set(rpcId, {
+          resolve: (data) => { clearTimeout(timer); resolve(data); },
+          reject: (err) => { clearTimeout(timer); reject(err); }
+        });
+      });
+
+      console.log(`[v3] chat-history 从 ${targetPublicKey.substring(0,12)}... 拉到 ${(result.messages || []).length} 条`);
+      res.json(result);
+    } catch (err: any) {
+      console.error('[v3] chat-history 失败:', err.message);
+      res.status(504).json({ error: err.message });
+    }
+  });
+
   // 获取已连接的节点
   app.get('/api/peers', async (_req, res) => {
     try {
@@ -1969,7 +2697,8 @@ app.get('/channels', async (_req, res) => {
         console.log(`[v3] 收到 agent.meta.list from ${msg.from.substring(0, 12)}...`);
         try {
           const channels = await loadChannels();
-          const publicMeta = channels.map(sanitizeChannelForPeer);
+          // iroh 路径保留 (admin / debug 用, 不走分享过滤)
+          const publicMeta = channels.map((ch) => sanitizeChannelForPeer(ch));
           const response = JSON.stringify({ ok: true, channels: publicMeta });
           const encoded = new TextEncoder().encode(response);
           // 沿用 msg.from 路由回去