@trap_stevo/filetide 0.0.39 → 0.0.41

package/dist/cjs/FileMessagerClient.js

@@ -5,11 +5,13 @@ const {
 } = require("@trap_stevo/iotide-client");
 const chalk = require("chalk");
 const path = require("path");
+const fs = require("fs");
 const {
   FileNetUtilityManager,
   significantMessageColors,
   errorMessageColors
 } = require("./HUDManagers/FileNetUtilityManager");
+const FileTransferRecoveryManager = require("./HUDManagers/FileTransferRecoveryManager");
 const {
   FileMessagerConfigManager
 } = require("./HUDManagers/FileMessagerConfigManager");
@@ -19,7 +21,6 @@ const {
 const {
   FileUtilityManager
 } = require("./HUDManagers/FileUtilityManager");
-const ConsoleProgressBarManager = require("./HUDComponents/ConsoleProgressBarManager");
 class FileMessagerClient {
   constructor(options = {}, transportOptions = {
     parallelChunks: 3,
@@ -27,31 +28,35 @@ class FileMessagerClient {
   }) {
     this.clientOptions = FileMessagerConfigManager.getClientOptions(options);
     this.transporter = new FileTransferManager(transportOptions);
-    this.progressBarManager = new ConsoleProgressBarManager([], {
-      completionMessageColor: chalk.blue.bold
-    });
     this.activeTransferTypes = new Map();
     this.clientTide = new HUDIoTide();
     this.clients = new Map();
   }
-  createClientInstance(clientID, clientOptions, options = {}) {
+  createClientInstance(clientID, clientOptions, options = {}, headers = {}, onConnect = null, onDisconnect = null, authURL = "", authHeaders = {}, useAuthentication = false, queryAuthToken = false) {
     this.clientTide.createIO(clientID, clientOptions.url, {
       transports: ["websocket"],
       ...options
+    }, headers, authURL, authHeaders, useAuthentication, queryAuthToken, onConnect, () => {
+      FileTransferRecoveryManager.flushToDisk();
+      if (onDisconnect) {
+        onDisconnect();
+      }
     });
     FileNetUtilityManager.outputGradient(`\n[FileTide ~ File Messager] ~ Created client with ID ${clientID} and socket ${clientID}!`, significantMessageColors);
     return clientID;
   }
-  joinRoom(userID, roomName, options = {}) {
+  joinRoom(userID, roomName, options = {}, headers = {}, onConnect = null, onDisconnect = null, authURL = "", authHeaders = {}, useAuthentication = false, queryAuthToken = false) {
     const socketName = this.createClientInstance(userID, {
       url: this.clientOptions.url
-    }, options);
-    this.clientTide.joinChannel(socketName, roomName, userID, () => {
-      FileNetUtilityManager.outputGradient(`\n[FileTide ~ File Messager] ~ Client ~ ${userID} joined room ${roomName} successfully!`, significantMessageColors);
-      this.clients.set(userID, {
-        roomName
+    }, options, headers, onConnect, onDisconnect, authURL, authHeaders, useAuthentication, queryAuthToken);
+    return () => {
+      this.clientTide.joinChannel(socketName, roomName, userID, () => {
+        FileNetUtilityManager.outputGradient(`\n[FileTide ~ File Messager] ~ Client ~ ${userID} joined room ${roomName} successfully!`, significantMessageColors);
+        this.clients.set(userID, {
+          roomName
+        });
       });
-    });
+    };
   }
   async requestTransfer(clientID, senderID, filePath, destinationPath, filterContent = []) {
     const transferAllowed = await this.allowedTransfer(clientID, senderID, destinationPath, "N/A", "requestSend");
@@ -111,8 +116,11 @@ class FileMessagerClient {
    * @param {Array} filesData - Array of file data objects from the directory.
    * @param {string} baseDirectory - The base directory path that contains the files.
    * @param {string} destinationPath - The path to which the files should be sent.
+   * @param {Number} tideSize - The tide size in sending files (500)
+   * @param {Number} minTideSize - The minimum tide size in sending files (10)
+   * @param {Number} maxTideSize - The maximum tide size in sending files (2000)
    */
-  async sendDirectoryFiles(clientID, recipientId, filesData, baseDirectory, destinationPath) {
+  async sendDirectoryFiles(clientID, recipientId, filesData, baseDirectory, destinationPath, tideSize = 500, minTideSize = 10, maxTideSize = 2000) {
     try {
       const baseDirectoryName = path.basename(baseDirectory);
       const adjustedDestinationPath = FileUtilityManager.normalizePath(path.join(destinationPath, baseDirectoryName));
@@ -131,6 +139,9 @@ class FileMessagerClient {
       const sendFilePromises = filesData.map(async (fileInfo, index) => {
         const relativeFilePath = path.dirname(path.relative(baseDirectory, fileInfo.filePath));
         const fileDestinationPath = FileUtilityManager.normalizePath(path.join(adjustedDestinationPath, relativeFilePath));
+        if (fileInfo.largeFile) {
+          return await this.sendDirectoryLargeFile(clientID, recipientId, fileInfo.fileName, fileInfo.filePath, fileDestinationPath, fileInfo.fileSize, index, tideSize, minTideSize, maxTideSize);
+        }
         return await this.sendDirectoryFile(clientID, recipientId, fileInfo.fileName, fileInfo.fileData, fileDestinationPath, fileInfo.size, adjustedDestinationPath, index);
       });
       Promise.all(sendFilePromises).then(() => console.log("\nAll files in directory transferred successfully!")).catch(error => console.error("Did not transfer directory: ", error));
@@ -138,29 +149,28 @@ class FileMessagerClient {
       FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Refused directory transfer: ${error}`, errorMessageColors);
     }
   }
+  async sendDirectoryLargeFile(clientID, recipientId, fileName, filePath = process.cwd(), destinationPath = null, fileSize, index = 0, tideSize = 500, minTideSize = 10, maxTideSize = 2000) {
+    let initiatingTransfer = false;
+    if (index === 0) {
+      initiatingTransfer = true;
+    }
+    return await this.sendLargeFile(clientID, recipientId, fileName, filePath, destinationPath, fileSize, tideSize, minTideSize, maxTideSize, initiatingTransfer, true);
+  }
   sendDirectoryFile(clientID, recipientId, fileName, file, filePath = process.cwd(), fileSize, directoryPath = null, index = 0) {
     if (!file) {
       return;
     }
     if (index === 0) {
-      this.progressBarManager.completionMessage = `Successfully sent to ${recipientId}!`;
-      this.progressBarManager.displayPage("Page Number:", "Press 'n' for next page, 'p' for previous page.", chalk.blue, chalk.magenta);
-      this.progressBarManager.listenForInput("Page Number:", "Press 'n' for next page, 'p' for previous page.", chalk.blue, chalk.magenta, chalk.yellow);
       this.clientTide.emitEvent(clientID, "transfer-start", {
         fileName,
         senderID: clientID,
         recipientID: recipientId,
-        path: directoryPath || filePath
+        path: directoryPath || filePath,
+        fileSize
       });
     }
     this.transporter.sendFile(file, {
       onSendChunk: (transferId, chunkIndex, chunkSize, chunkData, totalChunks) => {
-        if (chunkIndex === 0) {
-          this.progressBarManager.addTask({
-            name: fileName,
-            size: fileSize
-          });
-        }
         return new Promise((resolve, reject) => {
           this.clientTide.emitEvent(clientID, "client-to-client-transfer", {
             senderID: clientID,
@@ -187,19 +197,124 @@ class FileMessagerClient {
           resolve();
         });
       },
-      onProgress: (progress, chunkSize) => {
-        this.progressBarManager.updateTaskProgress(fileName, chunkSize);
-      },
       originDetails: {
         recipientID: recipientId,
         senderID: clientID
       },
+      recipientID: recipientId,
       fileDetails: {
+        destinationPath: filePath,
         name: fileName,
         path: filePath,
         size: fileSize
       }
-    }).then(() => FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ File ~ ${fileName} transfer complete!`, significantMessageColors)).catch(error => FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Refused file transfer: ${error}`, errorMessageColors));
+    }, this.clientTide).then(() => FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ File ~ ${fileName} transfer complete!`, significantMessageColors)).catch(error => FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Refused file transfer: ${error}`, errorMessageColors));
+  }
+  async sendLargeFile(clientID, recipientId, fileName, filePath = process.cwd(), destination = process.cwd(), fileSize, tideSize = 500, minTideSize = 10, maxTideSize = 2000, initiatingTransfer = true, inDirectory = false) {
+    const destinationPath = FileUtilityManager.normalizePath(path.join(destination, fileName));
+    FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Requesting to transfer large file ~ ${destinationPath} to ${recipientId}!`, significantMessageColors);
+    const incomingType = this.activeTransferTypes.get(filePath);
+    if (!inDirectory && initiatingTransfer) {
+      const transferAllowed = incomingType && incomingType === "requestedTransfer" ? true : await this.allowedTransfer(clientID, recipientId, destinationPath, fileSize, "send");
+      if (incomingType) {
+        this.activeTransferTypes.delete(filePath);
+      }
+      if (!transferAllowed) {
+        return;
+      }
+      this.clientTide.emitEvent(clientID, "transfer-start", {
+        fileName,
+        senderID: clientID,
+        recipientID: recipientId,
+        path: destination,
+        fileSize
+      });
+    } else if (inDirectory && !initiatingTransfer) {
+      if (incomingType) {
+        this.activeTransferTypes.delete(filePath);
+      }
+    }
+    const fileHandle = await fs.promises.open(filePath, "r");
+    const fileDetails = {
+      destinationPath,
+      name: fileName,
+      path: filePath,
+      size: fileSize
+    };
+    try {
+      let lastSendTime = Date.now();
+      const maxBatchSize = maxTideSize;
+      const minBatchSize = minTideSize;
+      let batchSize = tideSize > maxBatchSize || tideSize > minBatchSize ? tideSize : tideSize <= minBatchSize ? minBatchSize : 10;
+      const chunkBatch = [];
+      await this.transporter.sendLargeFile(fileHandle, {
+        recipientID: recipientId,
+        originDetails: {
+          recipientID: recipientId,
+          senderID: clientID
+        },
+        fileDetails,
+        onSendChunk: (transferId, chunkIndex, chunkSize, chunkData, totalChunks, completedChunks) => {
+          return new Promise(resolve => {
+            chunkBatch.push({
+              senderID: clientID,
+              recipientId,
+              fileName,
+              fileChunk: chunkData,
+              completedChunks,
+              totalChunks,
+              chunkIndex,
+              chunkSize,
+              filePath: destination,
+              fileSize
+            });
+            if (chunkBatch.length >= batchSize) {
+              const now = Date.now();
+              const rtt = now - lastSendTime;
+              lastSendTime = now;
+              this.clientTide.emitEvent(clientID, "client-to-client-transfer", {
+                chunkBatch
+              });
+              chunkBatch.length = 0;
+              if (rtt >= 200 && batchSize < maxBatchSize) {
+                batchSize = Math.min(batchSize + 50, maxBatchSize);
+              } else if (rtt < 200 && batchSize > minBatchSize) {
+                batchSize = Math.max(batchSize - 50, minBatchSize);
+              }
+            }
+            resolve();
+          });
+        },
+        onComplete: transferId => {
+          return new Promise(resolve => {
+            if (chunkBatch.length > 0) {
+              this.clientTide.emitEvent(clientID, "client-to-client-transfer", {
+                chunkBatch
+              });
+              chunkBatch.length = 0;
+            }
+            this.clientTide.emitEvent(clientID, "transfer-complete", {
+              senderID: clientID,
+              recipientId,
+              fileName,
+              filePath: destination
+            });
+            resolve();
+          });
+        },
+        onTiding: () => {
+          this.clientTide.emitEvent(clientID, "client-tiding", {
+            senderID: clientID,
+            message: "Transfer ongoing..."
+          });
+        }
+      }, this.clientTide);
+      FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Large file ~ ${fileName} transfer complete!`, significantMessageColors);
+    } catch (error) {
+      FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Error transferring large file: ${error.message}`, errorMessageColors);
+    } finally {
+      await fileHandle.close();
+    }
   }
   async sendFile(clientID, recipientId, fileName, file, filePath = process.cwd(), fileSize) {
     if (!file) {
@@ -215,29 +330,22 @@ class FileMessagerClient {
     if (!transferAllowed) {
       return;
     }
-    this.progressBarManager.completionMessage = `Successfully sent to ${recipientId}!`;
-    this.progressBarManager.displayPage("Page Number:", "Press 'n' for next page, 'p' for previous page.", chalk.blue, chalk.magenta);
-    this.progressBarManager.listenForInput("Page Number:", "Press 'n' for next page, 'p' for previous page.", chalk.blue, chalk.magenta, chalk.yellow);
     this.clientTide.emitEvent(clientID, "transfer-start", {
       fileName,
       senderID: clientID,
       recipientID: recipientId,
-      path: filePath
+      path: filePath,
+      fileSize
     });
-    this.transporter.sendFile(file, {
-      onSendChunk: (transferId, chunkIndex, chunkSize, chunkData, totalChunks) => {
-        if (chunkIndex === 0) {
-          this.progressBarManager.addTask({
-            name: fileName,
-            size: fileSize
-          });
-        }
+    await this.transporter.sendFile(file, {
+      onSendChunk: (transferId, chunkIndex, chunkSize, chunkData, totalChunks, completedChunks) => {
         return new Promise((resolve, reject) => {
           this.clientTide.emitEvent(clientID, "client-to-client-transfer", {
             senderID: clientID,
             recipientId,
             fileName,
             fileChunk: chunkData,
+            completedChunks,
             totalChunks,
             chunkIndex,
             chunkSize,
@@ -258,19 +366,17 @@ class FileMessagerClient {
           resolve();
         });
       },
-      onProgress: (progress, chunkSize) => {
-        this.progressBarManager.updateTaskProgress(fileName, chunkSize);
-      },
       originDetails: {
         recipientID: recipientId,
         senderID: clientID
       },
       fileDetails: {
+        destinationPath,
         name: fileName,
         path: filePath,
         size: fileSize
       }
-    }).then(() => FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ File ~ ${fileName} transfer complete!`, significantMessageColors)).catch(error => FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Refused file transfer: ${error}`, errorMessageColors));
+    }, this.clientTide).then(() => FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ File ~ ${fileName} transfer complete!`, significantMessageColors)).catch(error => FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Refused file transfer ~ ${error}`, errorMessageColors));
   }
 }
 ;

package/dist/cjs/FileTide.js

@@ -15,6 +15,7 @@ const {
 const {
   FileTransferReceiverManager
 } = require("./HUDManagers/FileTransferReceiverManager.js");
+const FileTransferRecoveryManager = require("./HUDManagers/FileTransferRecoveryManager.js");
 const {
   FileNetConfigManager
 } = require("./HUDManagers/FileNetConfigManager.js");
@@ -22,6 +23,7 @@ const {
   FileUtilityManager
 } = require("./HUDManagers/FileUtilityManager.js");
 const ConsoleProgressBarManager = require("./HUDComponents/ConsoleProgressBarManager");
+const ChunkCapacitor = require("./HUDComponents/ChunkCapacitor.js");
 const ConsoleTable = require("./HUDComponents/ConsoleTable.js");
 const FileMessagerClient = require("./FileMessagerClient");
 const FileMessager = require("./FileMessager");
@@ -75,20 +77,27 @@ class FileTide {
    * @param {Function} onTransferProgress - Callback for when an current transfers progress
    * @param {Boolean} [enableTransferBarrier=true] - Whether to enable the transfer barrier
    * @param {Object} [options = {}] - Additional options
+   * @param {Object} [headers = {}] - Additional connection headers
+   * @param {Function} onConnect - Callback for when the client connects to the desired server
+   * @param {Function} onDisconnect - Callback for when the client disconnects from the desired server
+   * @param {String} authURL - The destination of the connection authentication functionality
+   * @param {Object} [authHeaders = {}] - Additional connection authentication headers
+   * @param {Boolean} [useAuthentication=true] - Whether to enable connection authentication
+   * @param {Boolean} [queryAuthToken=false] - Whether to enable connection authentication tokens
    */
-  launchMessager(clientOptions = {}, connectionOptions = {}, roomName, userID, onLaunch, onIncomingFile, onIncomingTransfer, onTransferBarrier, onTransferProgress, enableTransferBarrier = true, options = {}) {
+  launchMessager(clientOptions = {}, connectionOptions = {}, roomName, userID, onLaunch, onIncomingFile, onIncomingTransfer, onTransferBarrier, onTransferProgress, enableTransferBarrier = true, options = {}, headers = {}, onConnect = null, onDisconnect = null, authURL = "", authHeaders = {}, useAuthentication = false, queryAuthToken = false) {
     if (this.clients.has(userID)) {
       this.stopMessager(userID);
     }
     const newClient = new FileMessagerClient(clientOptions);
-    newClient.joinRoom(userID, roomName, connectionOptions);
+    const enterRoom = newClient.joinRoom(userID, roomName, connectionOptions, headers, onConnect, onDisconnect, authURL, authHeaders, useAuthentication, queryAuthToken);
     this.transferBarrier = enableTransferBarrier;
     this.clientShorePolicies.set(userID, [FileUtilityManager.getTidePath(">CurrentUser"), FileUtilityManager.getTidePath(">Downloads"), FileUtilityManager.getTidePath(">Documents")]);
     this.clients.set(userID, newClient);
     FileTide.outputGradient(`[FileTide] ~ Messager launched successfully for client ~ ${userID}!`, significantMessageColors);
     _assertClassBrand(_FileTide_brand, this, _setupFileEventListeners).call(this, userID, newClient, onTransferProgress, onIncomingTransfer, onIncomingFile, onTransferBarrier, options);
     if (onLaunch) {
-      onLaunch(newClient);
+      onLaunch(newClient, enterRoom);
     }
     return;
   }
@@ -104,6 +113,9 @@ class FileTide {
   getTidePath(inputPath) {
     return FileUtilityManager.getTidePath(inputPath);
   }
+  saveTransferStates() {
+    FileTransferRecoveryManager.flushToDisk();
+  }
   filterFilesAndDirectories(dirPath, filterContent = [], callback) {
     FileUtilityManager.filterFilesAndDirectories(dirPath, filterContent, (files, error) => {
       if (callback) {
@@ -120,8 +132,8 @@ class FileTide {
     }
     clientMessager.listFiles(clientID, recipientID, depth);
   }
-  async listFiles(directories, depth = 1) {
-    return await FileUtilityManager.listFiles(directories, depth);
+  async listFiles(directories, depth = 1, onDirectory) {
+    return await FileUtilityManager.listFiles(directories, depth, onDirectory);
   }
   clearShorePolicies(clientID, shores = []) {
     let clientShorePolicies = this.clientShorePolicies.get(clientID);
@@ -153,8 +165,11 @@ class FileTide {
    * @param {Buffer} fileData - The path of the data to send
    * @param {String} destinationPath - The destination path on the device
    * @param {Array} filterDirectoryContent - List of paths to filter
+   * @param {Number} tideSize - The tide size in sending files (500)
+   * @param {Number} minTideSize - The minimum tide size in sending files (10)
+   * @param {Number} maxTideSize - The maximum tide size in sending files (2000)
    */
-  async sendToDevice(recipientID, filePath, destinationPath, filterDirectoryContent = []) {
+  async sendToDevice(recipientID, filePath, destinationPath, filterDirectoryContent = [], tideSize = 500, minTideSize = 10, maxTideSize = 2000) {
     const clientID = this.currentUserID;
     const clientMessager = this.clients.get(clientID);
     if (!clientMessager) {
@@ -167,13 +182,18 @@ class FileTide {
       return;
     }
     if (fileDetails.type === "file") {
+      if (fileDetails.largeFile) {
+        FileTide.outputGradient(`[${clientID}] Sending large file ~ ${fileDetails.fileName} to client ~ ${recipientID}...`, ["#00C897", "#00E0FF"]);
+        await clientMessager.sendLargeFile(clientID, recipientID, fileDetails.fileName, fileDetails.filePath, destinationPath, fileDetails.fileSize, tideSize, minTideSize, maxTideSize);
+        return;
+      }
       FileTide.outputGradient(`[${clientID}] Sending file ~ ${fileDetails.content.fileName} to client ~ ${recipientID}...`, ["#00C897", "#00E0FF"]);
       clientMessager.sendFile(clientID, recipientID, fileDetails.content.fileName, fileDetails.content.fileData, destinationPath, fileDetails.content.size);
       return;
     }
     if (fileDetails.type === "directory") {
       FileTide.outputGradient(`[${clientID}] Sending ${fileDetails.content.length} files in directory ~ ${path.basename(filePath)} to client ~ ${recipientID}...`, ["#00C897", "#00E0FF"]);
-      clientMessager.sendDirectoryFiles(clientID, recipientID, fileDetails.content, this.getTidePath(filePath), destinationPath);
+      clientMessager.sendDirectoryFiles(clientID, recipientID, fileDetails.content, this.getTidePath(filePath), destinationPath, tideSize, minTideSize, maxTideSize);
       return;
     }
     FileTide.outputGradient(`[FileTide] ~ No active client ~ ${recipientID} found.`, errorMessageColors);
@@ -215,6 +235,10 @@ class FileTide {
   stopMessager(userID) {
     if (this.clients.has(userID)) {
       FileTide.outputGradient(`Stopping messager for user ${userID}...`, significantMessageColors);
+      const connectionOrigin = this.clients.get(userID);
+      if (connectionOrigin) {
+        connectionOrigin.clientTide.closeSocket(userID);
+      }
       this.clients.delete(userID);
       FileTide.outputGradient(`Stopped messager for user ${userID}.`, significantMessageColors);
       return;
@@ -241,7 +265,9 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
     onTransferRequested,
     onTransferStatus,
     onListFiles,
-    onCurrentOnlineClients
+    onCurrentOnlineClients,
+    onClientTiding,
+    onCurrentClientIDAlreadyOnline
   } = options;
   const cliTable = new ConsoleTable({
     padding: 2,
@@ -287,6 +313,11 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
       onCurrentOnlineClients(currentClients, true);
     }
   });
+  client.clientTide.onEvent(userID, "current-client-tiding", data => {
+    if (onClientTiding) {
+      onClientTiding(data.message, significantMessageColors);
+    }
+  });
   client.clientTide.onEvent(userID, "current-clients", data => {
     const currentClients = {};
     Object.keys(data).forEach(key => {
@@ -302,6 +333,33 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
       onCurrentOnlineClients(currentClients, false);
     }
   });
+  client.clientTide.onEvent(userID, "current-client-id-already-online", clientID => {
+    if (userID === clientID) {
+      return;
+    }
+    _FileTide.outputGradient(`[FileTide ~ FileNet] ~ Client ~ ${userID} already online.`, significantMessageColors);
+    if (onCurrentClientIDAlreadyOnline) {
+      onCurrentClientIDAlreadyOnline(clientID);
+    }
+    return;
+  });
+  client.clientTide.onEvent(userID, "save-current-transfer-states", async data => {
+    this.saveTransferStates();
+    return;
+  });
+  client.clientTide.onEvent(userID, "current-transfer-state", async data => {
+    const {
+      senderID,
+      filePath
+    } = data;
+    const currentTransferState = FileTransferRecoveryManager.getTransferState(userID, senderID, filePath);
+    client.clientTide.emitEvent(userID, "send-current-transfer-state", {
+      recipientID: userID,
+      senderID,
+      transferState: currentTransferState
+    });
+    return;
+  });
   client.clientTide.onEvent(userID, "queue-incoming-transfer", async data => {
     if (this.transferBarrier && onIncomingTransfer) {
       onIncomingTransfer(data, status => {
@@ -320,6 +378,16 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
     return;
   });
   client.clientTide.onEvent(userID, "incoming-transfer", async data => {
+    const {
+      currentSender
+    } = data;
+    if (currentSender && currentSender === userID) {
+      _FileTide.outputGradient(`[${userID}] Transfer successfully sent to ${data.recipientID}`, significantMessageColors);
+      this.progressBarManager.completionMessage = `Successfully sent to ${data.recipientID}!`;
+      this.progressBarManager.displayPage("Page Number:", "Press 'n' for next page, 'p' for previous page.", chalk.blue, chalk.magenta);
+      this.progressBarManager.listenForInput("Page Number:", "Press 'n' for next page, 'p' for previous page.", chalk.blue, chalk.magenta, chalk.yellow);
+      return;
+    }
     _FileTide.outputGradient(`[${userID}] Preparing to receive transfer : ${FileUtilityManager.getTidePath(data.path)}`, significantMessageColors);
     if (onTransferStart) {
       onTransferStart(data);
@@ -371,11 +439,29 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
     }
     await fileTransferReceiver.handleTransferProgress(data);
     this.progressBarManager.updateTaskProgress(data.fileName, data.chunkSize || 512 * 1024);
+    const currentTransferState = FileTransferRecoveryManager.getTransferState(userID, data.senderName, data.path) || {
+      transferredSize: 0
+    };
+    currentTransferState.transferredSize += data.chunkSize || 512 * 1024;
+    FileTransferRecoveryManager.saveTransferState(userID, data.senderName, data.path, data.chunkIndex, currentTransferState.transferredSize);
     if (onTransferProgress) {
       onTransferProgress(data);
     }
   });
   client.clientTide.onEvent(userID, "transfer-status", data => {
+    const {
+      chunkIndex,
+      chunkSize,
+      fileName,
+      fileSize
+    } = data;
+    if (chunkIndex === 0) {
+      this.progressBarManager.addTask({
+        name: fileName,
+        size: fileSize
+      });
+    }
+    this.progressBarManager.updateTaskProgress(fileName, chunkSize);
     if (onTransferStatus) {
       onTransferStatus(data);
     }
@@ -389,11 +475,12 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
       if (!transferState) {
         return;
       }
-      fileTransferReceiver.completeTransfer(data, (transferData, transfers, success) => {
+      fileTransferReceiver.completeTransfer(data, (transferData, transfers, success, error) => {
         if (success) {
+          FileTransferRecoveryManager.clearTransferState(userID, data.senderID, data.filePath);
           _FileTide.outputGradient(`[${userID}] File saved at : ${savePath}\n`, significantMessageColors);
         } else if (!success) {
-          _FileTide.outputGradient(`[${userID}] Did not save file at : ${savePath}\n`, errorMessageColors);
+          _FileTide.outputGradient(`[${userID}] Did not save file at : ${savePath}\n\t${error}\n`, errorMessageColors);
         }
         if (onTransferComplete) {
           onTransferComplete(data, fileTransferReceiver.activeTransfers, success);
@@ -416,17 +503,29 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
     return;
   });
   client.clientTide.onEvent(userID, "list-files", async data => {
-    _FileTide.outputGradient(`[${userID}] Sending file list!`, significantMessageColors);
+    _FileTide.outputGradient(`[${userID}] Sending file list to ${data.senderID}...!`, significantMessageColors);
     const currentClientShorePolicies = this.getShorePolicies(userID);
-    const listedFiles = await this.listFiles(currentClientShorePolicies || [">Downloads"], data.depth || 1);
-    client.clientTide.emitEvent(userID, "send-file-list-to-client", {
-      senderID: data.recipientID,
-      recipientID: data.senderID,
-      listedFiles
+    const listedFiles = await this.listFiles(currentClientShorePolicies || [">Downloads"], data.depth || 1, (totalItems, directoryContents) => {
+      const capacitor = new ChunkCapacitor(directoryContents, 100);
+      const contents = capacitor.getAllChunks();
+      for (let files of contents) {
+        client.clientTide.emitEvent(userID, "send-file-list-to-client", {
+          senderID: data.recipientID,
+          recipientID: data.senderID,
+          totalItems: files.length,
+          listedFiles: files
+        });
+      }
     });
+    setTimeout(() => {
+      _FileTide.outputGradient(`[${userID}] Sent file list to ${data.senderID}!`, significantMessageColors);
+    }, 1000);
+  });
+  client.clientTide.onEvent(userID, "error", async error => {
+    _FileTide.outputGradient(`[${userID} | FileTide Error] ${error}`, errorMessageColors);
   });
   client.clientTide.onEvent(userID, "client-file-list", async data => {
-    _FileTide.outputGradient(`[${userID}] Listed ${data.senderID}'s files!`, significantMessageColors);
+    _FileTide.outputGradient(`[${userID}] Received ${data.totalItems} directory contents from ${data.senderID}'s file list!`, significantMessageColors);
     if (onListFiles) {
       onListFiles(data);
     }

package/dist/cjs/HUDComponents/ChunkCapacitor.js

@@ -0,0 +1,35 @@
+"use strict";
+
+class ChunkCapacitor {
+  constructor(list, chunkSize = 100) {
+    this.list = list;
+    this.chunkSize = chunkSize;
+    this.chunks = this.createChunks();
+  }
+  createChunks() {
+    const chunks = [];
+    for (let i = 0; i < this.list.length; i += this.chunkSize) {
+      const chunk = this.list.slice(i, i + this.chunkSize);
+      chunks.push(chunk);
+    }
+    return chunks;
+  }
+  getChunk(index) {
+    if (index < 0 || index >= this.chunks.length) {
+      console.log("Chunk index out of bounds.");
+      return null;
+    }
+    return this.chunks[index];
+  }
+  getTotalChunks() {
+    return this.chunks.length;
+  }
+  getTotalItems() {
+    return this.list.length;
+  }
+  getAllChunks() {
+    return this.chunks;
+  }
+}
+;
+module.exports = ChunkCapacitor;

package/dist/cjs/HUDComponents/ConsoleProgressBarManager.js

@@ -123,7 +123,11 @@ class ConsoleProgressBarManager {
         newBar.speed = speed;
         const filledLength = Math.round(settings.barLength * (newBar.current / newBar.totalSize));
         const bar = settings.barColor(settings.filledChar.repeat(filledLength)) + settings.unfilledChar.repeat(settings.barLength - filledLength);
-        process.stdout.write(`${settings.taskNameColor(newBar.taskName)} > ${settings.totalSizeColor(newBar.getFormattedSize(newBar.totalSize))} | ${settings.sizeTransferredColor(newBar.getFormattedSize(newBar.current))} ${settings.speedColor(`${speedData.current} ${speedData.unit}/s`)} | ${settings.taskETAColor(this.convertSeconds(timeLeft.toFixed(2)))} [${bar}] ${settings.percentageColor(percentage.toFixed(2) + "%")}`);
+        try {
+          process.stdout.write(`${settings.taskNameColor(newBar.taskName)} > ${settings.totalSizeColor(newBar.getFormattedSize(newBar.totalSize))} | ${settings.sizeTransferredColor(newBar.getFormattedSize(newBar.current))} ${settings.speedColor(`${speedData.current} ${speedData.unit}/s`)} | ${settings.taskETAColor(this.convertSeconds(timeLeft.toFixed(2)))} [${bar}] ${settings.percentageColor(percentage.toFixed(2) + "%")}`);
+        } catch (error) {
+          console.log(error);
+        }
       },
       update: amount => {
         newBar.current += amount;