@bolloon/bolloon-agent 0.1.0

package/src/web/components/p2p/p2p-connection.ts

@@ -0,0 +1,186 @@
+/**
+ * P2P 连接管理
+ */
+
+import type { ConnectResult, ConnectProgress, ParsedInput, ConnectedPeer } from './types.js';
+import { ConnectionStatus } from './types.js';
+import { p2pStore } from './p2p-store-memory.js';
+
+const CID_REGEX = /^Qm[a-zA-Z0-9]{44}$|^bafy[a-zA-Z0-9]{59}$|^bafk[a-zA-Z0-9]{59}$/;
+const DID_REGEX = /^did:[a-z]+:[a-zA-Z0-9]+$/;
+
+export class P2PConnectionManager {
+  private peers: Map<string, ConnectedPeer> = new Map();
+  private reconnectTimers: Map<string, number> = new Map();
+  private connectionAttempts: Map<string, number> = new Map();
+
+  // 解析输入
+  parseInput(input: string): ParsedInput {
+    const trimmed = input.trim();
+
+    // URL scheme
+    if (trimmed.startsWith('bolloon://connect')) {
+      try {
+        const url = new URL(trimmed);
+        return {
+          type: 'link',
+          value: {
+            did: url.searchParams.get('did') ?? undefined,
+            cid: url.searchParams.get('cid') ?? undefined
+          }
+        };
+      } catch {
+        return { type: 'invalid', error: '无效的链接格式' };
+      }
+    }
+
+    // 纯 CID
+    if (CID_REGEX.test(trimmed)) {
+      return { type: 'cid', value: trimmed };
+    }
+
+    // JSON DiapDoc
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed.id || parsed.did) {
+        return { type: 'diapDoc', value: parsed };
+      }
+    } catch {}
+
+    return { type: 'invalid', error: '无法识别的格式' };
+  }
+
+  // 连接到节点
+  async connect(
+    input: string,
+    onProgress?: (progress: ConnectProgress) => void
+  ): Promise<ConnectResult> {
+    const parsed = this.parseInput(input);
+    if (parsed.type === 'invalid') {
+      return { success: false, error: parsed.error };
+    }
+
+    onProgress?.({ stage: 'validating', percent: 10, message: '验证输入格式...' });
+
+    let cid = '';
+    const value = parsed.value;
+    if (parsed.type === 'link' && typeof value !== 'string') {
+      cid = (value as { did?: string; cid?: string }).cid || '';
+    } else if (parsed.type === 'cid' && typeof value === 'string') {
+      cid = value;
+    } else if (parsed.type === 'diapDoc' && typeof value !== 'string') {
+      cid = (value as { id?: string; did?: string; cid?: string }).cid || '';
+    }
+
+    if (!cid) {
+      return { success: false, error: '未找到 CID' };
+    }
+
+    onProgress?.({ stage: 'ipfs_fetch', percent: 40, message: '从 IPFS 获取节点文档...' });
+
+    try {
+      const res = await fetch('/api/iroh/connect', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ cid })
+      });
+
+      const data = await res.json();
+
+      if (res.ok) {
+        onProgress?.({ stage: 'connecting', percent: 80, message: '建立 P2P 连接...' });
+
+        // 保存到连接历史
+        if (data.did) {
+          await p2pStore.addToHistory({
+            did: data.did,
+            name: data.name || 'Unknown',
+            cid: cid,
+            irohNodeId: data.irohNodeId || '',
+            lastConnectedAt: Date.now(),
+            lastMessageAt: Date.now(),
+            totalMessages: 0,
+            isPinned: false,
+            tags: []
+          });
+        }
+
+        // 更新本地状态
+        this.peers.set(data.irohNodeId, {
+          nodeId: data.irohNodeId,
+          status: ConnectionStatus.CONNECTED,
+          info: data,
+          lastSeen: Date.now()
+        });
+
+        onProgress?.({ stage: 'complete', percent: 100, message: '连接成功!' });
+
+        return { success: true, ...data };
+      } else {
+        onProgress?.({ stage: 'error', percent: 0, message: data.error || '连接失败' });
+        return { success: false, error: data.error };
+      }
+    } catch (e) {
+      return { success: false, error: (e as Error).message };
+    }
+  }
+
+  // 断开连接
+  async disconnect(nodeId: string): Promise<void> {
+    try {
+      await fetch('/api/iroh/disconnect', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ nodeId })
+      });
+    } catch {}
+
+    this.peers.delete(nodeId);
+    this.clearReconnectTimer(nodeId);
+  }
+
+  // 获取所有已连接节点
+  getConnectedPeers(): ConnectedPeer[] {
+    const connected: ConnectedPeer[] = [];
+    this.peers.forEach((peer, peerNodeId) => {
+      if (peer.status === ConnectionStatus.CONNECTED) {
+        connected.push({ nodeId: peerNodeId, status: peer.status, info: peer.info, lastSeen: peer.lastSeen });
+      }
+    });
+    return connected;
+  }
+
+  // 清除重连定时器
+  private clearReconnectTimer(nodeId: string): void {
+    const timerId = this.reconnectTimers.get(nodeId);
+    if (timerId !== undefined) {
+      clearTimeout(timerId);
+      this.reconnectTimers.delete(nodeId);
+    }
+  }
+
+  // 获取节点数量
+  getPeerCount(): number {
+    return this.peers.size;
+  }
+
+  // 更新节点状态
+  updatePeerStatus(nodeId: string, status: ConnectionStatus, info?: any): void {
+    const peer = this.peers.get(nodeId) || { nodeId, status, info: {}, lastSeen: 0 };
+    this.peers.set(nodeId, {
+      ...peer,
+      status,
+      info: info || peer.info,
+      lastSeen: Date.now()
+    });
+  }
+
+  // 销毁
+  destroy(): void {
+    this.reconnectTimers.forEach((timerId) => clearTimeout(timerId));
+    this.reconnectTimers.clear();
+    this.peers.clear();
+  }
+}
+
+export const p2pConnection = new P2PConnectionManager();

package/src/web/components/p2p/p2p-identity.ts

@@ -0,0 +1,92 @@
+/**
+ * P2P 身份管理
+ */
+
+import type { P2PIdentity } from './types.js';
+import { p2pStore } from './p2p-store-memory.js';
+
+export class P2PIdentityManager {
+  private identity: P2PIdentity | null = null;
+  private initialized: boolean = false;
+
+  // 初始化身份
+  async init(): Promise<P2PIdentity> {
+    if (this.initialized && this.identity) {
+      return this.identity;
+    }
+
+    try {
+      const res = await fetch('/api/iroh/init', { method: 'POST' });
+      const data = await res.json();
+
+      if (res.ok) {
+        this.identity = {
+          did: data.did,
+          cid: data.cid,
+          irohNodeId: data.irohNodeId,
+          name: data.name || `bolloon-${Date.now()}`
+        };
+        this.initialized = true;
+
+        // 保存到历史
+        await p2pStore.addToHistory({
+          did: this.identity.did,
+          name: '我的设备',
+          cid: this.identity.cid,
+          irohNodeId: this.identity.irohNodeId,
+          lastConnectedAt: Date.now(),
+          lastMessageAt: 0,
+          totalMessages: 0,
+          isPinned: true,
+          tags: ['self']
+        });
+
+        console.log('[P2P Identity] 初始化成功:', this.identity.did?.substring(0, 20));
+      }
+
+      return this.identity!;
+    } catch (e) {
+      console.error('[P2P Identity] 初始化失败:', e);
+      throw e;
+    }
+  }
+
+  // 获取身份
+  get(): P2PIdentity | null {
+    return this.identity;
+  }
+
+  // 是否已初始化
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+
+  // 生成分享链接
+  generateShareLink(): string | null {
+    if (!this.identity?.cid || !this.identity?.did) {
+      return null;
+    }
+    return `bolloon://connect?did=${encodeURIComponent(this.identity.did)}&cid=${encodeURIComponent(this.identity.cid)}`;
+  }
+
+  // 导出身份文件
+  exportIdentityFile(): void {
+    if (!this.identity) return;
+
+    const data = JSON.stringify({
+      did: this.identity.did,
+      cid: this.identity.cid,
+      irohNodeId: this.identity.irohNodeId
+    }, null, 2);
+
+    const blob = new Blob([data], { type: 'application/json' });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = 'bolloon-identity.json';
+    a.click();
+    URL.revokeObjectURL(url);
+  }
+}
+
+export const p2pIdentity = new P2PIdentityManager();

package/src/web/components/p2p/p2p-manager.ts

@@ -0,0 +1,109 @@
+/**
+ * P2P 核心管理器
+ */
+
+import { p2pStore } from './p2p-store-memory.js';
+import { p2pIdentity } from './p2p-identity.js';
+import { p2pConnection } from './p2p-connection.js';
+import { p2pMessages } from './p2p-messages.js';
+import type {
+  P2PIdentity,
+  ConnectResult,
+  ConnectProgress,
+  P2PMessage,
+  ConnectionHistoryEntry
+} from './types.js';
+
+export class P2PManager {
+  readonly identity = p2pIdentity;
+  readonly connection = p2pConnection;
+  readonly messages = p2pMessages;
+
+  // 初始化
+  async init(): Promise<P2PIdentity> {
+    const identity = await this.identity.init();
+    this.messages.startListening();
+    return identity;
+  }
+
+  // 连接到节点
+  async connect(input: string, onProgress?: (progress: ConnectProgress) => void): Promise<ConnectResult> {
+    return this.connection.connect(input, onProgress);
+  }
+
+  // 断开连接
+  async disconnect(nodeId: string): Promise<void> {
+    return this.connection.disconnect(nodeId);
+  }
+
+  // 发送消息
+  async sendMessage(content: string, targetNodeId: string) {
+    return this.messages.send(content, targetNodeId);
+  }
+
+  // 获取连接历史
+  async getHistory(): Promise<ConnectionHistoryEntry[]> {
+    return p2pStore.getHistory();
+  }
+
+  // 更新历史条目
+  async updateHistory(id: string, updates: Partial<ConnectionHistoryEntry>): Promise<void> {
+    return p2pStore.updateHistory(id, updates);
+  }
+
+  // 删除历史条目
+  async deleteHistory(id: string): Promise<void> {
+    return p2pStore.deleteHistory(id);
+  }
+
+  // 获取收到的消息
+  async getMessages(): Promise<P2PMessage[]> {
+    return this.messages.getReceivedMessages();
+  }
+
+  // 监听消息
+  onMessage(handler: (msg: P2PMessage) => void): void {
+    this.messages.onMessage(handler);
+  }
+
+  // 获取未读数
+  getUnreadCount(): number {
+    return this.messages.getUnreadCount();
+  }
+
+  // 获取已连接节点
+  getConnectedPeers() {
+    return this.connection.getConnectedPeers();
+  }
+
+  // 获取节点数量
+  getPeerCount(): number {
+    return this.connection.getPeerCount();
+  }
+
+  // 获取离线队列
+  async getOfflineQueue() {
+    return this.messages.getOfflineQueue();
+  }
+
+  // 获取离线消息数量
+  async getOfflineQueueCount(): Promise<number> {
+    return p2pStore.getQueueCount();
+  }
+
+  // 销毁
+  destroy(): void {
+    this.connection.destroy();
+    this.messages.destroy();
+  }
+}
+
+// 全局单例
+export const p2pManager = new P2PManager();
+
+// 挂载到全局
+if (typeof window !== 'undefined') {
+  (window as any).p2pManager = p2pManager;
+}
+
+console.log('[P2P Manager] 已初始化');

package/src/web/components/p2p/p2p-messages.ts

@@ -0,0 +1,219 @@
+/**
+ * P2P 消息管理
+ */
+
+import type { P2PMessage } from './types.js';
+import { MessageStatus } from './types.js';
+import { p2pStore } from './p2p-store-memory.js';
+
+interface PendingMessage {
+  status: MessageStatus;
+  retries: number;
+  createdAt: number;
+  content: string;
+  targetNodeId: string;
+}
+
+export class P2PMessagesManager {
+  private pendingMessages: Map<string, PendingMessage> = new Map();
+  private messageHandlers: Array<(msg: P2PMessage) => void> = [];
+  private sseConnected: boolean = false;
+  private eventSource: EventSource | null = null;
+  private maxRetries: number = 3;
+
+  // 发送消息
+  async send(content: string, targetNodeId: string): Promise<{ success: boolean; messageId: string; queued?: boolean }> {
+    const messageId = crypto.randomUUID();
+
+    this.pendingMessages.set(messageId, {
+      status: MessageStatus.SENDING,
+      retries: 0,
+      createdAt: Date.now(),
+      content,
+      targetNodeId
+    });
+
+    try {
+      const res = await fetch('/api/message-p2p', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          id: messageId,
+          type: 'chat',
+          content,
+          target: targetNodeId || 'broadcast',
+          requireReceipt: true
+        })
+      });
+
+      if (res.ok) {
+        this.updateStatus(messageId, MessageStatus.SENT);
+        return { success: true, messageId };
+      } else {
+        await this.queueMessage(content, targetNodeId);
+        this.updateStatus(messageId, MessageStatus.QUEUED);
+        return { success: false, messageId, queued: true };
+      }
+    } catch (e) {
+      await this.queueMessage(content, targetNodeId);
+      this.updateStatus(messageId, MessageStatus.QUEUED);
+      return { success: false, messageId, queued: true };
+    }
+  }
+
+  private async queueMessage(content: string, targetNodeId: string): Promise<void> {
+    await p2pStore.addToQueue({
+      targetDid: targetNodeId,
+      targetNodeId: targetNodeId,
+      type: 'chat',
+      content
+    });
+  }
+
+  // 重试失败的消息
+  async retry(messageId: string): Promise<{ success: boolean; error?: string }> {
+    const msg = this.pendingMessages.get(messageId);
+    if (!msg) return { success: false, error: '消息不存在' };
+
+    if (msg.retries >= this.maxRetries) {
+      this.updateStatus(messageId, MessageStatus.FAILED);
+      return { success: false, error: '超过最大重试次数' };
+    }
+
+    const result = await this.send(msg.content, msg.targetNodeId);
+    return { success: result.success };
+  }
+
+  // 获取消息状态
+  getStatus(messageId: string): PendingMessage | undefined {
+    return this.pendingMessages.get(messageId);
+  }
+
+  private updateStatus(messageId: string, status: MessageStatus): void {
+    const msg = this.pendingMessages.get(messageId);
+    if (msg) {
+      msg.status = status;
+      if (status === MessageStatus.SENT || status === MessageStatus.QUEUED) {
+        msg.retries++;
+      }
+    }
+  }
+
+  // 监听消息
+  onMessage(handler: (msg: P2PMessage) => void): void {
+    this.messageHandlers.push(handler);
+  }
+
+  // 移除监听
+  offMessage(handler: (msg: P2PMessage) => void): void {
+    const index = this.messageHandlers.indexOf(handler);
+    if (index > -1) {
+      this.messageHandlers.splice(index, 1);
+    }
+  }
+
+  // 启动 SSE 监听
+  startListening(): void {
+    if (this.sseConnected) return;
+
+    this.eventSource = new EventSource('/events?channelId=p2p-global');
+    this.sseConnected = true;
+
+    this.eventSource.onmessage = (e) => {
+      try {
+        const data = JSON.parse(e.data);
+
+        if (data.type === 'p2p_message') {
+          const content = typeof data.content === 'string'
+            ? data.content
+            : JSON.stringify(data.content);
+
+          const msg: P2PMessage = {
+            id: crypto.randomUUID(),
+            fromDid: data.from,
+            fromName: data.fromName || 'Unknown',
+            content: content,
+            type: data.messageType || 'chat',
+            timestamp: data.timestamp || Date.now(),
+            status: MessageStatus.DELIVERED,
+            isRead: false
+          };
+
+          // 保存到存储
+          p2pStore.addMessage({
+            fromDid: msg.fromDid,
+            fromName: msg.fromName,
+            content: msg.content,
+            type: msg.type,
+            timestamp: msg.timestamp,
+            status: msg.status
+          });
+
+          // 更新连接历史
+          p2pStore.getHistory().then(history => {
+            const entry = history.find(h => h.did === msg.fromDid);
+            if (entry) {
+              p2pStore.updateHistory(entry.id, {
+                lastMessageAt: msg.timestamp,
+                totalMessages: (entry.totalMessages || 0) + 1
+              });
+            }
+          });
+
+          // 通知所有处理器
+          this.messageHandlers.forEach(handler => {
+            try {
+              handler(msg);
+            } catch (e) {
+              console.error('[P2P Messages] 处理错误:', e);
+            }
+          });
+        }
+      } catch {}
+    };
+
+    this.eventSource.onerror = () => {
+      console.log('[P2P Messages] SSE 断开，5秒后重连...');
+      this.sseConnected = false;
+      setTimeout(() => this.startListening(), 5000);
+    };
+  }
+
+  // 获取收到的消息
+  async getReceivedMessages(): Promise<P2PMessage[]> {
+    return p2pStore.getMessages();
+  }
+
+  // 获取未读数
+  getUnreadCount(): number {
+    return p2pStore.getUnreadCount();
+  }
+
+  // 标记消息已读
+  async markRead(id: string): Promise<void> {
+    await p2pStore.markRead(id);
+  }
+
+  // 标记全部已读
+  async markAllRead(): Promise<void> {
+    await p2pStore.markAllRead();
+  }
+
+  // 获取离线队列
+  async getOfflineQueue() {
+    return p2pStore.getQueue();
+  }
+
+  // 销毁
+  destroy(): void {
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+    this.sseConnected = false;
+    this.pendingMessages.clear();
+    this.messageHandlers = [];
+  }
+}
+
+export const p2pMessages = new P2PMessagesManager();