share-home 1.0.0

package/src/services/mdnsService.ts

@@ -0,0 +1,284 @@
+import { Bonjour, Service } from 'bonjour-service';
+import os from 'os';
+import { Peer } from '../types/peer';
+
+export class MdnsService {
+  private bonjour: InstanceType<typeof Bonjour> | null = null;
+  private publishedService: InstanceType<typeof Service> | null = null;
+  private browser: any = null;
+  
+  // 维护局域网在线节点，Key 为 Peer ID
+  private peers: Map<string, Peer> = new Map();
+  private onPeersChangeCallbacks: Array<(peers: Peer[]) => void> = [];
+  
+  private selfId: string = '';
+  private localIp: string = '';
+
+  private constructor() {
+    this.localIp = this.detectLocalIp();
+    this.selfId = `peer_${this.localIp.replace(/\./g, '_')}`;
+  }
+
+  public static getInstance(): MdnsService {
+    const globalSymbols = global as any;
+    if (!globalSymbols.__mdns_service_instance__) {
+      globalSymbols.__mdns_service_instance__ = new MdnsService();
+    }
+    return globalSymbols.__mdns_service_instance__;
+  }
+
+  /**
+   * 启动本机的 mDNS 服务广播与局域网节点发现
+   */
+  public start(nickname: string, avatar: string, webPort: number): void {
+    if (this.bonjour) {
+      // 已经启动，则更新广播元数据
+      this.updateBroadcast(nickname, avatar);
+      return;
+    }
+
+    this.bonjour = new Bonjour();
+    this.localIp = this.detectLocalIp();
+
+    console.log(`[mDNS] 正在启动自发现服务. 本机IP: ${this.localIp}, 端口: ${webPort}`);
+
+    // 1. 广播本机服务
+    this.publishedService = this.bonjour.publish({
+      name: `ShareHome-${this.selfId}`,
+      type: 'sharehome',
+      port: webPort,
+      txt: {
+        id: this.selfId,
+        nickname: nickname,
+        avatar: avatar,
+        ip: this.localIp,
+      }
+    });
+
+    this.publishedService.on('error', (err) => {
+      console.error('[mDNS] 广播服务发生异常:', err);
+    });
+
+    // 2. 扫描局域网内的其他 ShareHome 服务
+    this.browser = this.bonjour.find({ type: 'sharehome' });
+
+    this.browser.on('up', (service: InstanceType<typeof Service>) => {
+      const txt = service.txt || {};
+      const peerId = txt.id;
+      const peerIp = txt.ip || service.referer?.address;
+
+      if (!peerId || !peerIp || peerId === this.selfId) {
+        return; // 忽略本机以及无效广播
+      }
+
+      const newPeer: Peer = {
+        id: peerId,
+        nickname: txt.nickname || '局域网伙伴',
+        avatar: txt.avatar || 'avatar-1',
+        ip: peerIp,
+        port: service.port,
+        lastSeen: Date.now(),
+        isSelf: false,
+      };
+
+      this.peers.set(peerId, newPeer);
+      console.log(`[mDNS] 发现新设备上线: ${newPeer.nickname} (${newPeer.ip})`);
+      this.notifyListeners();
+    });
+
+    this.browser.on('down', (service: InstanceType<typeof Service>) => {
+      // 寻找对应的节点移出
+      const txt = service.txt || {};
+      const peerId = txt.id;
+      if (peerId && this.peers.has(peerId)) {
+        const removedPeer = this.peers.get(peerId);
+        this.peers.delete(peerId);
+        console.log(`[mDNS] 设备下线: ${removedPeer?.nickname}`);
+        this.notifyListeners();
+      }
+    });
+  }
+
+  /**
+   * 更新广播的昵称和头像元数据
+   */
+  public updateBroadcast(nickname: string, avatar: string): void {
+    if (this.publishedService) {
+      console.log(`[mDNS] 正在更新本机广播元数据: ${nickname}`);
+      // bonjour-service 允许动态更新 TXT 记录
+      try {
+        // @ts-ignore
+        this.publishedService.updateTxt({
+          id: this.selfId,
+          nickname: nickname,
+          avatar: avatar,
+          ip: this.localIp,
+        });
+      } catch (err) {
+        console.error('[mDNS] 更新 TXT 记录失败，执行重启广播。');
+      }
+    }
+  }
+
+  /**
+   * 关闭 mDNS 服务
+   */
+  public stop(): void {
+    if (this.browser) {
+      this.browser.stop();
+    }
+    if (this.publishedService) {
+      this.publishedService.stop(() => {
+        console.log('[mDNS] 停止本机广播服务。');
+      });
+    }
+    if (this.bonjour) {
+      this.bonjour.destroy();
+      this.bonjour = null;
+    }
+    this.peers.clear();
+    this.notifyListeners();
+  }
+
+  /**
+   * 注册由 Web 浏览器访问建立的虚拟 Peer
+   */
+  public registerWebPeer(id: string, ip: string, nickname: string, avatar: string, port = 3000, os = 'Windows'): void {
+    if (id === this.selfId) return;
+    
+    // 智能修正：若 Web 客户端通过本地回环地址访问，将其 IP 修正为本机的物理局域网 IP
+    let clientIp = ip;
+    if (clientIp === '127.0.0.1' || clientIp === '::1' || clientIp === 'localhost') {
+      clientIp = this.localIp;
+    }
+    
+    const newPeer: Peer = {
+      id,
+      nickname,
+      avatar,
+      ip: clientIp,
+      port,
+      lastSeen: Date.now(),
+      isSelf: false,
+      os
+    };
+    
+    this.peers.set(id, newPeer);
+    console.log(`[mDNS] 收到 Web 浏览器虚拟终端注册: ${nickname} (${clientIp}), OS: ${os}`);
+    this.notifyListeners();
+  }
+
+  /**
+   * 注销指定 Web 虚拟 Peer
+   */
+  public unregisterWebPeer(id: string): void {
+    if (this.peers.has(id)) {
+      const removedPeer = this.peers.get(id);
+      this.peers.delete(id);
+      console.log(`[mDNS] Web 浏览器虚拟终端下线: ${removedPeer?.nickname}`);
+      this.notifyListeners();
+    }
+  }
+
+  /**
+   * 获取所有在线设备列表
+   */
+  public getPeers(): Peer[] {
+    return Array.from(this.peers.values());
+  }
+
+  public getSelfId(): string {
+    return this.selfId;
+  }
+
+  public getLocalIp(): string {
+    return this.localIp;
+  }
+
+  /**
+   * 监听列表变化
+   */
+  public onPeersChange(callback: (peers: Peer[]) => void): void {
+    this.onPeersChangeCallbacks.push(callback);
+    // 立即触发一次初始数据
+    callback(this.getPeers());
+  }
+
+  private notifyListeners(): void {
+    const peersList = this.getPeers();
+    for (const callback of this.onPeersChangeCallbacks) {
+      callback(peersList);
+    }
+  }
+
+  /**
+   * 获取本机的局域网 IPv4 地址 (智能过滤虚拟网卡，优先获取物理 WLAN/以太网网口 IP)
+   */
+  private detectLocalIp(): string {
+    const interfaces = os.networkInterfaces();
+    const candidates: Array<{ name: string; address: string; isVirtual: boolean; isPreferred: boolean }> = [];
+
+    // 虚拟/代理/虚拟网卡等常见关键字过滤
+    const virtualKeywords = [
+      'vmware', 'virtualbox', 'vbox', 'wsl', 'vethernet', 
+      'meta', 'clash', 'zerotier', 'tailscale', 'tun', 
+      'tap', 'loopback', 'vpn', 'host-only', 'sandbox'
+    ];
+
+    // 物理网卡优先关键字
+    const physicalKeywords = [
+      'wlan', 'wifi', 'wireless', '无线', 'ethernet', 
+      '以太', '乙太', '本地连接', '区域连接'
+    ];
+
+    for (const devName in interfaces) {
+      const iface = interfaces[devName];
+      if (!iface) continue;
+
+      const nameLower = devName.toLowerCase();
+      const isVirtual = virtualKeywords.some(keyword => nameLower.includes(keyword));
+      const isPreferred = physicalKeywords.some(keyword => nameLower.includes(keyword));
+
+      for (let i = 0; i < iface.length; i++) {
+        const alias = iface[i];
+        if (alias.family === 'IPv4' && alias.address !== '127.0.0.1' && !alias.internal) {
+          candidates.push({
+            name: devName,
+            address: alias.address,
+            isVirtual,
+            isPreferred
+          });
+        }
+      }
+    }
+
+    // 1. 优先筛选出非虚拟且被选为 Preferred 的物理网卡
+    const preferredPhysical = candidates.filter(c => !c.isVirtual && c.isPreferred);
+    if (preferredPhysical.length > 0) {
+      console.log(`[mDNS] 精准选择物理网卡: ${preferredPhysical[0].name} (${preferredPhysical[0].address})`);
+      return preferredPhysical[0].address;
+    }
+
+    // 2. 其次筛选出非虚拟的其他网卡
+    const realCandidates = candidates.filter(c => !c.isVirtual);
+    if (realCandidates.length > 0) {
+      console.log(`[mDNS] 选择非虚拟网卡: ${realCandidates[0].name} (${realCandidates[0].address})`);
+      return realCandidates[0].address;
+    }
+
+    // 3. 如果全部是虚拟网卡，看是否有 Preferred 的虚拟网卡
+    const preferredVirtual = candidates.filter(c => c.isPreferred);
+    if (preferredVirtual.length > 0) {
+      console.log(`[mDNS] 未检测到物理网卡，选择首选虚拟网卡: ${preferredVirtual[0].name} (${preferredVirtual[0].address})`);
+      return preferredVirtual[0].address;
+    }
+
+    // 4. 兜底返回第一个非本地回环地址
+    if (candidates.length > 0) {
+      console.log(`[mDNS] 未检测到匹配网卡，使用首个 IPv4 网卡: ${candidates[0].name} (${candidates[0].address})`);
+      return candidates[0].address;
+    }
+
+    return '127.0.0.1';
+  }
+}

package/src/services/socketService.ts

@@ -0,0 +1,214 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import { Peer } from '../types/peer';
+import { MdnsService } from './mdnsService';
+import { FileService } from './fileService';
+
+export class SocketService {
+  private wss: WebSocketServer | null = null;
+  private clients: Set<WebSocket> = new Set();
+  private isStarted = false;
+
+  private constructor() {}
+
+  public static getInstance(): SocketService {
+    const globalSymbols = global as any;
+    if (!globalSymbols.__socket_service_instance__) {
+      globalSymbols.__socket_service_instance__ = new SocketService();
+    }
+    return globalSymbols.__socket_service_instance__;
+  }
+
+  /**
+   * 在指定端口启动 WebSocket 服务器，服务于本机浏览器前端 (绑定 0.0.0.0 以支持局域网外端穿透)
+   */
+  public start(port: number): void {
+    if (this.isStarted) {
+      console.log(`[WebSocket] 通信服务已在运行中，无需重复启动。`);
+      return;
+    }
+
+    console.log(`[WebSocket] 正在启动通信服务, 监听端口: ${port}, 绑定 Host: 0.0.0.0`);
+    try {
+      this.wss = new WebSocketServer({ port, host: '0.0.0.0' });
+
+      this.wss.on('connection', (ws: WebSocket, req: any) => {
+        this.clients.add(ws);
+        
+        let clientId: string | null = null;
+        let nickname = '局域网伙伴';
+        let avatar = 'avatar-1';
+        let os = 'Windows';
+        try {
+          const urlObj = new URL(req.url || '', 'http://localhost');
+          clientId = urlObj.searchParams.get('clientId');
+          nickname = urlObj.searchParams.get('nickname') || '局域网伙伴';
+          avatar = urlObj.searchParams.get('avatar') || 'avatar-1';
+          os = urlObj.searchParams.get('os') || 'Windows';
+        } catch (e) {}
+
+        console.log(`[WebSocket] 客户端已建立连接. ClientId: ${clientId || 'unknown'}. 当前连接数: ${this.clients.size}`);
+
+        // 精准获取局域网内客户端物理 IPv4 地址 (处理本地 IPv6 回环前缀及反向代理转发字段)
+        let clientIp = req.socket.remoteAddress || '127.0.0.1';
+        if (clientIp.startsWith('::ffff:')) {
+          clientIp = clientIp.substring(7);
+        }
+        
+        const forwardedFor = req.headers['x-forwarded-for'];
+        if (forwardedFor) {
+          const ip = typeof forwardedFor === 'string' ? forwardedFor.split(',')[0].trim() : forwardedFor[0].trim();
+          if (ip) {
+            clientIp = ip;
+          }
+        }
+
+        const mdns = MdnsService.getInstance();
+        
+        // 智能修正：若 WebSocket 客户端来自本机本地回环，将其映射为局域网物理 IP 以支持外部网络通信
+        if (clientIp === '::1' || clientIp === '127.0.0.1' || clientIp === 'localhost') {
+          clientIp = mdns.getLocalIp();
+        }
+
+        if (clientId) {
+          (ws as any).clientId = clientId;
+        }
+
+        if (clientId && clientId !== mdns.getSelfId()) {
+          mdns.registerWebPeer(clientId, clientIp, nickname, avatar, 3000, os);
+        }
+
+        // 监听客户端发来的测试或控制指令
+        ws.on('message', (message: string) => {
+          try {
+            const parsed = JSON.parse(message);
+            console.log('[WebSocket] 收到前端控制消息:', parsed);
+            
+            // 收到前端中转互传握手请求：'transfer:request'
+            if (parsed.event === 'transfer:request') {
+              const { targetClientId, ...metadata } = parsed.data;
+              console.log(`[WebSocket] 转发文件传输申请，目标客户端: ${targetClientId}`);
+              this.sendToClient(targetClientId, 'transfer:request', metadata);
+            }
+
+            // 收到接收端点击“拒绝文件接收”：'transfer:reject'
+            if (parsed.event === 'transfer:reject') {
+              const { taskId } = parsed.data;
+              console.log(`[WebSocket] 收到互传任务拒绝信令: ${taskId}`);
+              // 广播给所有人，同步前端任务列表状态
+              this.broadcast('transfer:reject', { taskId });
+            }
+          } catch (e) {
+            // 忽略非 JSON 数据
+          }
+        });
+
+        ws.on('close', () => {
+          this.clients.delete(ws);
+          console.log(`[WebSocket] 客户端已断开连接. ClientId: ${clientId || 'unknown'}. 当前连接数: ${this.clients.size}`);
+          
+          if (clientId) {
+            const mdns = MdnsService.getInstance();
+            if (clientId !== mdns.getSelfId()) {
+              mdns.unregisterWebPeer(clientId);
+            }
+          }
+        });
+
+        ws.on('error', (err) => {
+          console.error('[WebSocket] 连接出现异常:', err);
+          this.clients.delete(ws);
+        });
+        
+        // 建立连接后，给前端发送一个欢迎及就绪包
+        this.sendTo(ws, 'system:ready', { timestamp: Date.now() });
+
+        // 智能自愈补发：当客户端重新连入或刷新页面时，若有针对它的 pending（待接收）传输任务，补发 WS 握手提示
+        if (clientId) {
+          const pendingTasks = FileService.getInstance().getPendingTasksForClient(clientId);
+          for (const task of pendingTasks) {
+            console.log(`[WebSocket] [自愈补发] 客户端 ${clientId} 上线，重新推送待接收任务: ${task.fileName}`);
+            this.sendTo(ws, 'transfer:request', {
+              taskId: task.id,
+              senderId: task.senderId,
+              senderName: task.senderName,
+              fileName: task.fileName,
+              fileSize: task.fileSize,
+              downloadUrl: task.downloadUrl
+            });
+          }
+        }
+      });
+
+      this.wss.on('error', (err: any) => {
+        if (err.code === 'EADDRINUSE') {
+          console.warn(`[WebSocket] 端口 ${port} 已被占用，可能之前的热更新进程仍在活动中。将跳过重新绑定。`);
+          this.isStarted = true;
+        } else {
+          console.error('[WebSocket] 服务端捕获到未知异常:', err);
+        }
+      });
+
+      this.isStarted = true;
+    } catch (err: any) {
+      console.error('[WebSocket] 服务启动发生异常:', err);
+    }
+  }
+
+  /**
+   * 关闭 WebSocket 服务
+   */
+  public stop(): void {
+    if (this.wss) {
+      this.wss.close(() => {
+        console.log('[WebSocket] 通信服务已关闭。');
+      });
+      this.wss = null;
+    }
+    this.clients.clear();
+    this.isStarted = false;
+  }
+
+  /**
+   * 向所有连接的前端页面广播事件
+   * @param event 事件名
+   * @param data 附带的数据体
+   */
+  public broadcast(event: string, data: any): void {
+    const payload = JSON.stringify({ event, data });
+    for (const client of this.clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(payload);
+      }
+    }
+
+    // 智能自愈：当传输任务完成 (transfer:complete)，自动物理清理发送端暂存大文件
+    if (event === 'transfer:complete' && data && data.taskId) {
+      console.log(`[WebSocket] 检测到互传完成广播，自动启动发送端物理暂存文件自愈清理. TaskId: ${data.taskId}`);
+      FileService.getInstance().cleanupTransferFile(data.taskId);
+    }
+  }
+
+  /**
+   * 向单个连接发送消息
+   */
+  private sendTo(ws: WebSocket, event: string, data: any): void {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ event, data }));
+    }
+  }
+
+  /**
+   * 向指定 clientId 定向发送消息
+   */
+  public sendToClient(targetClientId: string, event: string, data: any): boolean {
+    const payload = JSON.stringify({ event, data });
+    let sent = false;
+    for (const client of this.clients) {
+      if ((client as any).clientId === targetClientId && client.readyState === WebSocket.OPEN) {
+        client.send(payload);
+        sent = true;
+      }
+    }
+    return sent;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+  "exclude": ["node_modules"]
+}