filepizza-client 2.0.1 → 2.1.0

package/src/filepizza-uploader.ts

@@ -1,210 +1,161 @@
 // src/filepizza-uploader.ts
 import Peer, { DataConnection } from 'peerjs'
 import { EventEmitter } from './event-emitter'
-import { FileInfo, ProgressInfo, ConnectionInfo, ConnectionStatus, MessageType } from './types';
+import {
+  FileInfo,
+  ProgressInfo,
+  ConnectionInfo,
+  ConnectionStatus,
+  MessageType,
+  PeerJSSignalingServer,
+} from './types'
+import { createPeer } from './peerjs'
+
+type ChannelInfo = {
+  longSlug: string
+  shortSlug: string
+  secret?: string
+}
+
+type UploaderOptions = {
+  filePizzaServerUrl?: string
+  password?: string
+  sharedSlug?: string
+  peerJSSignalingServer?: PeerJSSignalingServer
+  discoverPeerJSSignalingServer?: boolean
+}
 
 /**
- * FilePizza Uploader - connects to the FilePizza server and uploads files
+ * FilePizza Uploader - connects to the FilePizza server and uploads files.
  */
 export class FilePizzaUploader extends EventEmitter {
-  private peer?: Peer;
-  private connections: Map<string, any> = new Map();
-  private connectionInfoMap = new Map<string, any>();
-  private files: File[] = [];
-  private password?: string;
-  private filePizzaServerUrl: string;
-  private channelInfo?: { longSlug: string; shortSlug: string; secret?: string };
-  private sharedSlug?: string;
-  private iceServers?: RTCIceServer[];
-  private renewalTimer?: NodeJS.Timeout;
-
-  /**
-   * Create a new FilePizza uploader
-   * @param options Configuration options
-   */
-  constructor(options: {
-    filePizzaServerUrl?: string;
-    password?: string;
-    sharedSlug?: string;
-  } = {}) {
-    super();
-    this.filePizzaServerUrl = options.filePizzaServerUrl || 'http://localhost:8081';
-    this.password = options.password;
-    this.sharedSlug = options.sharedSlug;
+  private peer?: Peer
+  private connections: Map<string, any> = new Map()
+  private connectionInfoMap = new Map<string, any>()
+  private files: File[] = []
+  private password?: string
+  private filePizzaServerUrl: string
+  private channelInfo?: ChannelInfo
+  private sharedSlug?: string
+  private renewalTimer?: NodeJS.Timeout
+  private peerJSSignalingServer?: PeerJSSignalingServer
+  private discoverPeerJSSignalingServer: boolean
+
+  constructor(options: UploaderOptions = {}) {
+    super()
+    this.filePizzaServerUrl = options.filePizzaServerUrl || 'http://localhost:8081'
+    this.password = options.password
+    this.sharedSlug = options.sharedSlug
+    this.peerJSSignalingServer = options.peerJSSignalingServer
+    this.discoverPeerJSSignalingServer =
+      options.discoverPeerJSSignalingServer ?? true
   }
 
-  /**
-   * Initialize the uploader
-   */
   async initialize(): Promise<void> {
     if (this.peer) {
-      return;
+      return
     }
 
-    // Get ICE servers
-    await this.getIceServers();
+    this.peer = await createPeer({
+      filePizzaServerUrl: this.filePizzaServerUrl,
+      peerJSSignalingServer: this.peerJSSignalingServer,
+      discoverPeerJSSignalingServer: this.discoverPeerJSSignalingServer,
+    })
 
-    // Initialize PeerJS
-    this.peer = new Peer({
-      config: {
-        iceServers: this.iceServers || [{ urls: 'stun:stun.l.google.com:19302' }],
-      },
-      debug: 2,
-    });
-
-    // Wait for peer to be ready
-    if (!this.peer.id) {
-      await new Promise<void>((resolve) => {
-        const onOpen = () => {
-          this.peer?.off('open', onOpen);
-          resolve();
-        };
-        this.peer?.on('open', onOpen);
-      });
-    }
+    this.peer.on('connection', this.handleConnection.bind(this))
 
-    // Set up connection handling
-    this.peer.on('connection', this.handleConnection.bind(this));
-
-    // Create channel
-    if (this.peer.id) {
-      await this.createChannel(this.peer.id, this.sharedSlug || undefined);
-      this.startChannelRenewal();
-    }
+    await this.createChannel(this.peer.id, this.sharedSlug || undefined)
+    this.startChannelRenewal()
   }
 
   setPassword(password: string): void {
     this.password = password
   }
 
-  /**
-   * Set files to be shared
-   */
   setFiles(files: File[]): void {
-    this.files = Array.from(files);
+    this.files = Array.from(files)
 
-    // Update file info for existing connections
     if (this.files.length > 0) {
-      for (const [_, connection] of this.connections.entries()) {
+      for (const [, connection] of this.connections.entries()) {
         if (connection.status === ConnectionStatus.Ready) {
           connection.dataConnection.send({
             type: MessageType.Info,
             files: this.getFileInfo(),
-          });
+          })
         }
       }
     }
   }
 
-  /**
-   * Get shareable links for the current channel
-   */
   getShareableLinks(): { long: string; short: string } | null {
     if (!this.channelInfo) {
-      return null;
+      return null
     }
 
     return {
       long: `${this.filePizzaServerUrl}/download/${this.channelInfo.longSlug}`,
       short: `${this.filePizzaServerUrl}/download/${this.channelInfo.shortSlug}`,
-    };
+    }
   }
 
-  /**
-   * Stop sharing and clean up
-   */
   async stop(): Promise<void> {
-    // Stop channel renewal
     if (this.renewalTimer) {
-      clearTimeout(this.renewalTimer);
-      this.renewalTimer = undefined;
+      clearTimeout(this.renewalTimer)
+      this.renewalTimer = undefined
     }
 
-    // Destroy channel if we have one
     if (this.channelInfo) {
       try {
-        await this.destroyChannel(this.channelInfo.shortSlug);
+        await this.destroyChannel(this.channelInfo.shortSlug)
       } catch (error) {
-        console.error('Error destroying channel:', error);
+        console.error('Error destroying channel:', error)
       }
     }
 
-    // Close all connections
-    for (const [_, connection] of this.connections.entries()) {
+    for (const [, connection] of this.connections.entries()) {
       if (connection.dataConnection.open) {
-        connection.dataConnection.close();
+        connection.dataConnection.close()
       }
     }
 
-    // Clear connections
-    this.connections.clear();
+    this.connections.clear()
 
-    // Destroy peer
     if (this.peer) {
-      this.peer.destroy();
-      this.peer = undefined;
+      this.peer.destroy()
+      this.peer = undefined
     }
 
-    // Reset state
-    this.channelInfo = undefined;
+    this.channelInfo = undefined
   }
 
-  /**
-   * Get ICE servers from the FilePizza server
-   */
-  private async getIceServers(): Promise<RTCIceServer[]> {
-    try {
-      const response = await fetch(`${this.filePizzaServerUrl}/api/ice`, {
-        method: 'POST',
-      });
-
-      if (!response.ok) {
-        throw new Error(`Failed to get ICE servers: ${response.status}`);
-      }
-
-      const data = await response.json();
-      this.iceServers = data.iceServers;
-      return data.iceServers;
-    } catch (error) {
-      console.error('Error getting ICE servers:', error);
-      return [{ urls: 'stun:stun.l.google.com:19302' }];
+  private async createChannel(
+    uploaderPeerID: string,
+    sharedSlug?: string,
+  ): Promise<void> {
+    const payload: { uploaderPeerID: string; sharedSlug?: string } = {
+      uploaderPeerID,
     }
-  }
-
-  /**
-   * Create a new channel on the FilePizza server
-   */
-  private async createChannel(uploaderPeerID: string, sharedSlug?: string): Promise<void> {
-    try {
-      const payload: { uploaderPeerID: string; sharedSlug?: string } = { uploaderPeerID };
 
-      if (sharedSlug) {
-        payload.sharedSlug = sharedSlug;
-      }
-
-      const response = await fetch(`${this.filePizzaServerUrl}/api/create`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(payload),
-      });
+    if (sharedSlug) {
+      payload.sharedSlug = sharedSlug
+    }
 
-      if (!response.ok) {
-        throw new Error(`Failed to create channel: ${response.status}`);
-      }
+    const response = await fetch(`${this.filePizzaServerUrl}/api/create`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    })
 
-      this.channelInfo = await response.json();
-    } catch (error) {
-      console.error('Error creating channel:', error);
-      throw error;
+    if (!response.ok) {
+      throw new Error(`Failed to create channel: ${response.status}`)
     }
+
+    this.channelInfo = await response.json()
   }
 
-  /**
-   * Renew the channel to keep it alive
-   */
   private async renewChannel(): Promise<void> {
     if (!this.channelInfo || !this.channelInfo.secret) {
-      return;
+      return
     }
 
     try {
@@ -215,63 +166,51 @@ export class FilePizzaUploader extends EventEmitter {
           slug: this.channelInfo.shortSlug,
           secret: this.channelInfo.secret,
         }),
-      });
+      })
 
       if (!response.ok) {
-        throw new Error(`Failed to renew channel: ${response.status}`);
+        throw new Error(`Failed to renew channel: ${response.status}`)
       }
     } catch (error) {
-      console.error('Error renewing channel:', error);
+      console.error('Error renewing channel:', error)
     }
   }
 
-  /**
-   * Destroy a channel
-   */
   private async destroyChannel(slug: string): Promise<void> {
     try {
       const response = await fetch(`${this.filePizzaServerUrl}/api/destroy`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ slug }),
-      });
+      })
 
       if (!response.ok) {
-        throw new Error(`Failed to destroy channel: ${response.status}`);
+        throw new Error(`Failed to destroy channel: ${response.status}`)
       }
     } catch (error) {
-      console.error('Error destroying channel:', error);
+      console.error('Error destroying channel:', error)
     }
   }
 
-  /**
-   * Start channel renewal
-   */
   private startChannelRenewal(): void {
     if (!this.channelInfo || !this.channelInfo.secret) {
-      return;
+      return
     }
 
-    // Renew every 30 minutes
-    const renewalInterval = 30 * 60 * 1000;
-
-    this.renewalTimer = setInterval(() => {
-      this.renewChannel();
-    }, renewalInterval);
+    this.renewalTimer = setInterval(
+      () => {
+        this.renewChannel()
+      },
+      30 * 60 * 1000,
+    )
   }
 
-  /**
-   * Handle new connection
-   */
   private handleConnection(conn: DataConnection): void {
-    // Ignore connections for reporting (handled separately)
     if (conn.metadata?.type === 'report') {
-      this.emit('report', conn.peer);
-      return;
+      this.emit('report', conn.peer)
+      return
     }
 
-    console.log(`[FilePizzaUploader] New connection from ${conn.peer}`);
-
     const connectionContext = {
       status: ConnectionStatus.Pending,
       dataConnection: conn,
@@ -281,105 +220,81 @@ export class FilePizzaUploader extends EventEmitter {
       bytesTransferred: 0,
       totalBytes: this.getTotalBytes(),
       currentFileProgress: 0,
-    };
+      acknowledgedBytes: 0,
+    }
 
-    this.connections.set(conn.peer, connectionContext);
+    this.connections.set(conn.peer, connectionContext)
 
-    // Set up event handlers
-    conn.on('data', (data) => this.handleData(conn, data));
-    conn.on('close', () => this.handleClose(conn));
-    conn.on('error', (error) => this.handleError(conn, error));
+    conn.on('data', (data) => this.handleData(conn, data))
+    conn.on('close', () => this.handleClose(conn))
+    conn.on('error', (error) => this.handleError(conn, error))
 
-    // Emit connection event
-    this.emit('connection', this.getConnectionInfo(conn.peer));
+    this.emit('connection', this.getConnectionInfo(conn.peer))
   }
 
-  /**
-   * Handle data messages from connection
-   */
   private handleData(conn: DataConnection, data: unknown): void {
-    const context = this.connections.get(conn.peer);
-    if (!context) return;
+    const context = this.connections.get(conn.peer)
+    if (!context) return
 
     try {
-      // WebRTC messages follow a specific format with a type field
-      const message = data as any;
+      const message = data as any
 
       switch (message.type) {
         case MessageType.RequestInfo:
-          this.handleRequestInfo(conn, context, message);
-          break;
+          this.handleRequestInfo(conn, context, message)
+          break
 
         case MessageType.UsePassword:
-          this.handleUsePassword(conn, context, message);
-          break;
+          this.handleUsePassword(conn, context, message)
+          break
 
         case MessageType.Start:
-          this.handleStart(conn, context, message);
-          break;
+          this.handleStart(conn, context, message)
+          break
 
         case MessageType.Pause:
-          this.handlePause(conn, context);
-          break;
+          this.handlePause(conn, context)
+          break
 
-        case MessageType.Resume:
-          this.handleResume(conn, context, message);
-          break;
+        case MessageType.ChunkAck:
+          this.handleChunkAck(conn, context, message)
+          break
 
         case MessageType.Done:
-          this.handleDone(conn, context);
-          break;
+          this.handleDone(conn, context)
+          break
       }
     } catch (error) {
-      console.error('[FilePizzaUploader] Error handling message:', error);
+      console.error('[FilePizzaUploader] Error handling message:', error)
       conn.send({
         type: MessageType.Error,
         error: 'Failed to process message',
-      });
+      })
     }
   }
 
-  /**
-   * Handle connection close
-   */
   private handleClose(conn: DataConnection): void {
-    const context = this.connections.get(conn.peer);
-    if (!context) return;
+    const context = this.connections.get(conn.peer)
+    if (!context) return
 
-    // Update connection status
-    context.status = ConnectionStatus.Closed;
-
-    // Emit connection closed event
-    this.emit('disconnection', conn.peer);
-
-    // Remove connection
-    this.connections.delete(conn.peer);
+    context.status = ConnectionStatus.Closed
+    this.emit('disconnection', conn.peer)
+    this.connections.delete(conn.peer)
   }
 
-  /**
-   * Handle connection error
-   */
   private handleError(conn: DataConnection, error: Error): void {
-    const context = this.connections.get(conn.peer);
-    if (!context) return;
-
-    // Update connection status
-    context.status = ConnectionStatus.Error;
+    const context = this.connections.get(conn.peer)
+    if (!context) return
 
-    // Emit error event
-    this.emit('error', { connectionId: conn.peer, error });
+    context.status = ConnectionStatus.Error
+    this.emit('error', { connectionId: conn.peer, error })
 
-    // Close connection
     if (conn.open) {
-      conn.close();
+      conn.close()
     }
   }
 
-  /**
-   * Handle RequestInfo message
-   */
   private handleRequestInfo(conn: DataConnection, context: any, message: any): void {
-    // Store browser info in connection metadata
     this.connectionInfoMap.set(conn.connectionId, {
       browserName: message.browserName,
       browserVersion: message.browserVersion,
@@ -387,273 +302,204 @@ export class FilePizzaUploader extends EventEmitter {
       osVersion: message.osVersion,
       mobileVendor: message.mobileVendor,
       mobileModel: message.mobileModel,
-    });
+    })
+
+    const connectionInfo = {
+      browserName: message.browserName,
+      browserVersion: message.browserVersion,
+      osName: message.osName,
+      osVersion: message.osVersion,
+      mobileVendor: message.mobileVendor,
+      mobileModel: message.mobileModel,
+    }
 
-    // Check if password is required
     if (this.password) {
       conn.send({
         type: MessageType.PasswordRequired,
-      });
+      })
 
-      context.status = ConnectionStatus.Authenticating;
-    } else {
-      // Send file info
-      conn.send({
-        type: MessageType.Info,
-        files: context.filesInfo,
-      });
+      context.status = ConnectionStatus.Authenticating
+      Object.assign(context, connectionInfo)
 
-      context.status = ConnectionStatus.Ready;
+      this.emit('connectionUpdate', this.getConnectionInfo(conn.peer))
+      return
     }
 
-    // Emit connection update
-    this.emit('connectionUpdate', this.getConnectionInfo(conn.peer));
+    conn.send({
+      type: MessageType.Info,
+      files: context.filesInfo,
+    })
+
+    context.status = ConnectionStatus.Ready
+    Object.assign(context, connectionInfo)
+
+    this.emit('connectionUpdate', this.getConnectionInfo(conn.peer))
   }
 
-  /**
-   * Handle UsePassword message
-   */
   private handleUsePassword(conn: DataConnection, context: any, message: any): void {
-    // Check password
     if (message.password === this.password) {
-      // Password correct, send file info
       conn.send({
         type: MessageType.Info,
         files: context.filesInfo,
-      });
+      })
 
-      context.status = ConnectionStatus.Ready;
+      context.status = ConnectionStatus.Ready
     } else {
-      // Password incorrect
       conn.send({
         type: MessageType.PasswordRequired,
-        errorMessage: 'Incorrect password',
-      });
+        errorMessage: 'Invalid password',
+      })
 
-      context.status = ConnectionStatus.InvalidPassword;
+      context.status = ConnectionStatus.InvalidPassword
     }
 
-    // Emit connection update
-    this.emit('connectionUpdate', this.getConnectionInfo(conn.peer));
+    this.emit('connectionUpdate', this.getConnectionInfo(conn.peer))
   }
 
-  /**
-   * Handle Start message
-   */
   private handleStart(conn: DataConnection, context: any, message: any): void {
-    // Find the requested file
-    const fileName = message.fileName;
-    const offset = message.offset;
+    const fileName = message.fileName
+    const offset = message.offset
 
-    const file = this.findFile(fileName);
-    if (!file) {
+    const file = this.findFile(fileName)
+    if (!file || offset > file.size) {
       conn.send({
         type: MessageType.Error,
-        error: `File not found: ${fileName}`,
-      });
-      return;
+        error: `Invalid file or offset: ${fileName}`,
+      })
+      return
     }
 
-    // Update connection status
-    context.status = ConnectionStatus.Uploading;
-    context.uploadingFileName = fileName;
-    context.uploadingOffset = offset;
-
-    // Emit status update
-    this.emit('connectionUpdate', this.getConnectionInfo(conn.peer));
+    context.status = ConnectionStatus.Uploading
+    context.uploadingFileName = fileName
+    context.uploadingOffset = offset
+    context.acknowledgedBytes = 0
+    context.currentFileProgress = 0
 
-    // Begin sending file chunks
-    this.sendFileChunks(conn, context, file, offset);
+    this.emit('connectionUpdate', this.getConnectionInfo(conn.peer))
+    this.sendFileChunks(conn, context, file, offset)
   }
 
-  /**
-   * Handle Pause message
-   */
   private handlePause(conn: DataConnection, context: any): void {
-    context.status = ConnectionStatus.Paused;
-    this.emit('connectionUpdate', this.getConnectionInfo(conn.peer));
+    context.status = ConnectionStatus.Paused
+    this.emit('connectionUpdate', this.getConnectionInfo(conn.peer))
   }
 
-  /**
-   * Handle Resume message
-   */
-  private handleResume(conn: DataConnection, context: any, message: any): void {
-    const fileName = message.fileName;
-    const offset = message.offset;
+  private handleChunkAck(conn: DataConnection, context: any, message: any): void {
+    context.acknowledgedBytes =
+      (context.acknowledgedBytes || 0) + message.bytesReceived
 
-    const file = this.findFile(fileName);
-    if (!file) {
-      conn.send({
-        type: MessageType.Error,
-        error: `File not found: ${fileName}`,
-      });
-      return;
+    const file = this.findFile(message.fileName)
+    if (file) {
+      context.currentFileProgress = context.acknowledgedBytes / file.size
     }
 
-    context.status = ConnectionStatus.Uploading;
-    context.uploadingFileName = fileName;
-    context.uploadingOffset = offset;
-
-    this.emit('connectionUpdate', this.getConnectionInfo(conn.peer));
-
-    this.sendFileChunks(conn, context, file, offset);
+    this.emit('progress', this.getProgressInfo(conn.peer))
   }
 
-  /**
-   * Handle Done message
-   */
   private handleDone(conn: DataConnection, context: any): void {
-    context.status = ConnectionStatus.Done;
-    this.emit('connectionUpdate', this.getConnectionInfo(conn.peer));
-    conn.close();
+    context.status = ConnectionStatus.Done
+    this.emit('connectionUpdate', this.getConnectionInfo(conn.peer))
+    conn.close()
   }
 
-  /**
-   * Send file chunks to the downloader
-   */
   private sendFileChunks(
     conn: DataConnection,
     context: any,
     file: File,
-    startOffset: number
+    startOffset: number,
   ): void {
-    let offset = startOffset;
-    const CHUNK_SIZE = 256 * 1024; // 256 KB
+    let offset = startOffset
+    const chunkSize = 256 * 1024
 
     const sendNextChunk = () => {
-      // Check if connection is still open and in uploading state
       if (!conn.open || context.status !== ConnectionStatus.Uploading) {
-        return;
+        return
       }
 
-      const end = Math.min(file.size, offset + CHUNK_SIZE);
-      const chunkSize = end - offset;
-      const final = end >= file.size;
+      const end = Math.min(file.size, offset + chunkSize)
+      const final = end >= file.size
+      const sentBytes = end - offset
 
-      // Create chunk
-      const chunk = file.slice(offset, end);
-
-      // Send chunk
       conn.send({
         type: MessageType.Chunk,
         fileName: file.name,
         offset,
-        bytes: chunk,
+        bytes: file.slice(offset, end),
         final,
-      });
-
-      // Update progress
-      offset = end;
-      context.uploadingOffset = offset;
-      context.currentFileProgress = offset / file.size;
-      context.bytesTransferred += chunkSize;
+      })
 
-      // Emit progress update
-      this.emit('progress', this.getProgressInfo(conn.peer));
+      offset = end
+      context.uploadingOffset = offset
+      context.bytesTransferred += sentBytes
 
-      // If this was the final chunk
       if (final) {
         if (context.fileIndex < context.totalFiles - 1) {
-          // Move to next file
-          context.fileIndex++;
-          context.currentFileProgress = 0;
-          context.status = ConnectionStatus.Ready;
-
-          // Emit update
-          this.emit('connectionUpdate', this.getConnectionInfo(conn.peer));
+          context.fileIndex += 1
+          context.currentFileProgress = 0
+          context.status = ConnectionStatus.Ready
         } else {
-          // All files completed
-          context.fileIndex = context.totalFiles;
-          context.currentFileProgress = 1;
-          context.status = ConnectionStatus.Done;
-
-          // Emit update
-          this.emit('connectionUpdate', this.getConnectionInfo(conn.peer));
+          context.fileIndex = context.totalFiles
+          context.currentFileProgress = 1
+          context.status = ConnectionStatus.Ready
         }
+
+        this.emit('connectionUpdate', this.getConnectionInfo(conn.peer))
       } else {
-        // Schedule next chunk
-        setTimeout(sendNextChunk, 0);
+        setTimeout(sendNextChunk, 0)
       }
-    };
+    }
 
-    // Start sending chunks
-    sendNextChunk();
+    sendNextChunk()
   }
 
-  /**
-   * Find a file by name
-   */
   private findFile(fileName: string): File | undefined {
-    return this.files.find(file => file.name === fileName);
+    return this.files.find((file) => file.name === fileName)
   }
 
-  /**
-   * Get file info for all files
-   */
   private getFileInfo(): FileInfo[] {
-    return this.files.map(file => ({
+    return this.files.map((file) => ({
       fileName: file.name,
       size: file.size,
       type: file.type,
-    }));
+    }))
   }
 
-  /**
-   * Get connection info for a specific connection
-   */
   private getConnectionInfo(peerId: string): ConnectionInfo {
-    const context = this.connections.get(peerId);
+    const context = this.connections.get(peerId)
     if (!context) {
-      throw new Error(`Connection not found: ${peerId}`);
+      throw new Error(`Connection not found: ${peerId}`)
     }
 
     return {
       id: peerId,
       status: context.status,
-      browserName: context.dataConnection.metadata?.browserName,
-      browserVersion: context.dataConnection.metadata?.browserVersion,
-      osName: context.dataConnection.metadata?.osName,
-      osVersion: context.dataConnection.metadata?.osVersion,
-      mobileVendor: context.dataConnection.metadata?.mobileVendor,
-      mobileModel: context.dataConnection.metadata?.mobileModel,
-    };
+      browserName: context.browserName,
+      browserVersion: context.browserVersion,
+      osName: context.osName,
+      osVersion: context.osVersion,
+      mobileVendor: context.mobileVendor,
+      mobileModel: context.mobileModel,
+    }
   }
 
-  /**
-   * Get connection info for all connections
-   */
   public getConnectionInfoAll(): ConnectionInfo[] {
-    const connectionInfos: ConnectionInfo[] = [];
-
-    for (const [peerId, context] of this.connections.entries()) {
-      const connectionInfo = this.getConnectionInfo(peerId);
-      connectionInfos.push(connectionInfo);
-    }
-
-    return connectionInfos;
+    return Array.from(this.connections.keys()).map((peerId) =>
+      this.getConnectionInfo(peerId),
+    )
   }
 
-  /**
-   * Remove connection info
-   */
   public removeConnectionInfo(connectionId: string): void {
-    this.connectionInfoMap.delete(connectionId);
+    this.connectionInfoMap.delete(connectionId)
   }
 
-  /**
-   * Get total bytes for all files
-   */
   private getTotalBytes(): number {
-    return this.files.reduce((total, file) => total + file.size, 0);
+    return this.files.reduce((total, file) => total + file.size, 0)
   }
 
-  /**
-   * Get progress info for a specific connection
-   */
   private getProgressInfo(peerId: string): ProgressInfo {
-    const context = this.connections.get(peerId);
+    const context = this.connections.get(peerId)
     if (!context) {
-      throw new Error(`Connection not found: ${peerId}`);
+      throw new Error(`Connection not found: ${peerId}`)
     }
 
     return {
@@ -661,9 +507,9 @@ export class FilePizzaUploader extends EventEmitter {
       fileName: context.uploadingFileName || '',
       totalFiles: context.totalFiles,
       currentFileProgress: context.currentFileProgress,
-      overallProgress: context.bytesTransferred / context.totalBytes,
+      overallProgress: context.bytesTransferred / (context.totalBytes || 1),
       bytesTransferred: context.bytesTransferred,
       totalBytes: context.totalBytes,
-    };
+    }
   }
 }