@bolloon/bolloon-agent 0.1.36 → 0.1.37

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

@@ -1,92 +0,0 @@
-/**
- * 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

@@ -1,147 +0,0 @@
-/**
- * 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,
-  PersistentConnection,
-  CIDResolveResult
-} 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();
-  }
-
-  // 获取持久连接列表
-  async getPersistentConnections(): Promise<PersistentConnection[]> {
-    return this.connection.getPersistentConnections();
-  }
-
-  // 更新连接状态
-  async updateConnectionStatus(
-    id: string,
-    status: string,
-    channelId?: string
-  ): Promise<void> {
-    await fetch('/api/p2p/connection-status', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ id, status, channelId })
-    });
-  }
-
-  // 切换连接状态
-  async toggleConnection(connection: PersistentConnection, enable: boolean): Promise<boolean> {
-    return this.connection.toggleConnection(connection, enable);
-  }
-
-  // CID 解析
-  async resolveFromCID(cid: string): Promise<CIDResolveResult> {
-    return this.connection.resolveFromCID(cid);
-  }
-
-  // 连接并创建对话通道
-  async connectAndCreateChannel(
-    input: string,
-    onProgress?: (progress: ConnectProgress) => void
-  ): Promise<ConnectResult> {
-    return this.connection.connectAndCreateChannel(input, onProgress);
-  }
-}
-
-// 全局单例
-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

@@ -1,219 +0,0 @@
-/**
- * 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();