@trap_stevo/filetide 0.0.52 → 0.0.54

package/dist/cjs/FileMessager.js

@@ -136,6 +136,8 @@ class FileMessager {
       this.fileNet.emitToTide(senderClient.tideID, "transfer-status", {
         status: `Chunk ${chunkIndex} of ${fileName} sent to client ${clientData.userID}!`,
         recipientID: clientData.userID,
+        senderName: senderData.userID,
+        senderID: senderData.id,
         success: true,
         fileName,
         chunkIndex,
@@ -146,7 +148,7 @@ class FileMessager {
       });
     }
   }
-  handleRequestTransferFromClient(transferData) {
+  handleRequestTransferFromClient(senderTide, transferData) {
     const {
       requesterID,
       senderID,
@@ -155,7 +157,7 @@ class FileMessager {
     } = transferData;
     this.requestFromClient(requesterID, senderID, filePath, destinationPath);
   }
-  handleSentFileListToClient(listData) {
+  handleSentFileListToClient(senderTide, listData) {
     const {
       totalItemsSent,
       recipientID,
@@ -174,10 +176,11 @@ class FileMessager {
         totalItemsSent
       });
     } catch (error) {
+      console.error(`[FileTide ~ Net Scanner] ~ `, error);
       return;
     }
   }
-  handleSendFileListToClient(listData) {
+  handleSendFileListToClient(senderTide, listData) {
     const {
       listedFiles,
       totalItems,
@@ -198,10 +201,11 @@ class FileMessager {
         listedFiles
       });
     } catch (error) {
+      console.error(`[FileTide ~ Net Scanner] ~ `, error);
       return;
     }
   }
-  handleListClientFiles(clientData) {
+  handleListClientFiles(senderTide, clientData) {
     const {
       requesterID,
       recipientID,
@@ -221,10 +225,11 @@ class FileMessager {
         depth
       });
     } catch (error) {
+      console.error(`[FileTide ~ Net Scanner] ~ `, error);
       return;
     }
   }
-  handleClientToClientTransfer(transferData) {
+  handleClientToClientTransfer(senderTide, transferData) {
     try {
       const {
         chunkBatch
@@ -317,11 +322,11 @@ class FileMessager {
         }
       }
     } catch (error) {
-      console.log(error);
+      console.error(`[FileTide ~ Net Transporter] ~ `, error);
       return;
     }
   }
-  handleClientTransferBarrierResponse(data) {
+  handleClientTransferBarrierResponse(senderTide, data) {
     console.log(`[FileTide ~ Net] Checking ${data.recipientID}'s transfer barrier for transfer ~ ${data.transferID}...`);
     try {
       const recipientConnectionID = FileNetClientManager.getOnlineClient(data.recipientID).id;
@@ -329,6 +334,7 @@ class FileMessager {
       const senderClient = this.getClientFromID(senderConnectionID);
       const client = this.getClientFromID(recipientConnectionID);
       if (!client || !senderClient) {
+        console.log(`[FileTide ~ Net Barrier] ~ Both, recipient and sender connection authorization required.`);
         return;
       }
       this.fileNet.emitToTide(client.tideID, "queue-incoming-transfer", {
@@ -351,18 +357,20 @@ class FileMessager {
           ...data
         });
       }).catch(error => {
-        console.error(error.message);
+        console.error(`[FileTide ~ Net Barrier] ~ ${error.message}`);
       });
       return;
     } catch (error) {
+      console.error(`[FileTide ~ Net Barrier] ~ `, error);
       return;
     }
   }
-  handleSendCurrentTransferState(data) {
+  handleSendCurrentTransferState(senderTide, data) {
     try {
       const senderConnectionID = FileNetClientManager.getOnlineClient(data.senderID).id;
       const senderClient = this.getClientFromID(senderConnectionID);
       if (!senderClient) {
+        console.log(`[FileTide ~ Net Transfers] ~ Sender ~ ${senderConnectionID.truncate(0, senderConnectionID.length / 2)}... not found.`);
         return;
       }
       this.fileNet.emitToTide(senderClient.tideID, "sent-current-transfer-state", data.transferState || {
@@ -370,10 +378,11 @@ class FileMessager {
         lastChunkSent: 0
       });
     } catch (error) {
+      console.error(`[FileTide ~ Net Transfers] ~ `, error);
       return;
     }
   }
-  handleGetClientTransferState(data) {
+  handleGetClientTransferState(senderTide, data) {
     const filePath = data.filePath || data.path;
     console.log(`[FileTide ~ Net] ~ Getting ${data.recipientID}'s transfer state for ~ ${filePath}...`);
     try {
@@ -388,10 +397,11 @@ class FileMessager {
         filePath
       });
     } catch (error) {
+      console.error(`[FileTide ~ Net Transfers] ~ `, error);
       return;
     }
   }
-  handleGetClient(data) {
+  handleGetClient(senderTide, data) {
     console.log(`[FileTide ~ Net] ~ Getting client ~ ${data.clientID}...`);
     try {
       const senderConnectionID = FileNetClientManager.getOnlineClient(data.senderID).id;
@@ -404,22 +414,23 @@ class FileMessager {
       console.log(`[FileTide ~ Net] Got client ~ ${data.clientID}!`);
       this.fileNet.emitToTide(senderClient.tideID, "retrieved-current-client", client);
     } catch (error) {
+      console.error(`[FileTide ~ Net Activity] ~ `, error);
       return;
     }
   }
-  handleAcknowledgeTransferTide(data) {
+  handleAcknowledgeTransferTide(senderTide, data) {
     try {
       console.log(`[FileTide ~ Net Activity] ~ ${data.recipientName} acknowledged tide transfer from ${data.senderName}.\n\n\t~ [${data.fileName}-${data.transferStats.startTime}] ~\n\n\t\tFile Name ~ ${data.fileName}\n\t\tDestination ~ ${data.path}\n\n\t\t\tProgress ~ ${data.transferStats.progress.toFixed(2)}%\n\t\t\tETA ~ ${data.transferStats.timeLeft <= 0 ? "Now" : FileNetUtilityManager.convertSeconds(data.transferStats.timeLeft.toFixed(2))}\n\t\t\tSpeed ~ ${FileNetUtilityManager.getFormattedSize(data.transferStats.speed, true)}/s\n\t\t\tSize ~ ${FileNetUtilityManager.getFormattedSize(data.transferStats.totalSize, true)}\n\t\t\tTransferred ~ ${FileNetUtilityManager.getFormattedSize(data.transferStats.current, true)}\n`);
     } catch (error) {
-      console.log(`[FileTide ~ Net Activity] ~  ${data.recipientName} acknowledged tide transfer from ${data.senderName}.\n\n${error}`);
+      console.error(`[FileTide ~ Net Activity] ~  ${data.recipientName} acknowledged tide transfer from ${data.senderName}.\n\n${error}`);
     }
   }
-  handleNotifyTransferBarrier(data, emitToChannel) {
+  handleNotifyTransferBarrier(senderTide, data, emitToChannel) {
     const accepted = data.accepted;
     const transferID = data.data.transferID;
     this.currentTransferBarrierTransfers.set(transferID, accepted);
   }
-  handleFileTransferStart(data, emitToChannel) {
+  handleFileTransferStart(senderTide, data, emitToChannel) {
     console.log(`[FileTide ~ File Messager] ~ Alerting client of incoming transfer from ${data.senderID}...`);
     try {
       const recipientConnectionID = FileNetClientManager.getOnlineClient(data.recipientID).id;
@@ -434,7 +445,7 @@ class FileMessager {
         ...data,
         currentSender: data.senderID
       });
-      if (!this.currentTidingTransfers.get(senderID) || this.currentTidingTransfers.get(senderID).length <= 0) {
+      if (!this.currentTidingTransfers.get(data.senderID) || this.currentTidingTransfers.get(data.senderID).length <= 0) {
         const tidingTransfers = new Map();
         tidingTransfers.set(data.recipientID, {
           recipientID: data.recipientID,
@@ -445,23 +456,24 @@ class FileMessager {
         this.currentTidingTransfers.set(data.senderID, tidingTransfers);
         return;
       }
-      this.currentTidingTransfers.get(senderID).set(data.recipientID, {
+      this.currentTidingTransfers.get(data.senderID).set(data.recipientID, {
         recipientID: data.recipientID,
         startedOn: new Date(),
         size: data.fileSize,
         path: data.path
       });
     } catch (error) {
+      console.error(`[FileTide ~ Net Transfers] ~ `, error);
       return;
     }
   }
-  handleFileTransferProgress(data, emitToChannel) {
+  handleFileTransferProgress(senderTide, data, emitToChannel) {
     console.log(`Progress: ${data.progress}`);
   }
-  handleFileTransferComplete(data) {
+  handleFileTransferComplete(senderTide, data) {
     console.log(`File transfer completed: ${data.fileName}`);
   }
-  handleCheckClientOnline(data) {
+  handleCheckClientOnline(senderTide, data) {
     console.log(`[FileTide ~ Net Activity] ~ Checking if client ~ ${data.clientID} online...`);
     try {
       const client = FileNetClientManager.getOnlineClient(data.clientID);
@@ -485,7 +497,7 @@ class FileMessager {
       return;
     }
   }
-  handleClientsOnline(clientID) {
+  handleClientsOnline(senderTide, clientID) {
     const connectionDetails = FileNetClientManager.getOnlineClient(clientID);
     if (!connectionDetails) {
       console.log(`[FileTide ~ Net Activity] ~ Client ~ ${clientID} not authorized.`);
@@ -499,13 +511,21 @@ class FileMessager {
     this.fileNet.emitToTide(connectionDetails.tideID, "current-online-clients", Object.fromEntries(FileNetClientManager.getOnlineClients()));
     return;
   }
-  handleClientOnline(clientID, tideID, pClientID, connectionID, activeTransferBarrier) {
+  handleClientOnline(senderTide, clientID, tideID, pClientID, connectionID, activeTransferBarrier) {
     if (!this.onlineClients.contains(connectionID)) {
       return;
     }
     if (FileNetClientManager.getOnlineClient(clientID) && this.onlineClients.get(connectionID)) {
-      clientID = `${clientID}_${connectionID.slice(0, 4)}`;
+      const nClientID = `${clientID}_${connectionID.slice(0, 4)}`;
+      const currentClientID = clientID;
+      clientID = nClientID;
       this.fileNet.emitToTide(tideID, "current-client-id-already-online", clientID);
+      FileNetClientManager.updateOnlineClient(nClientID, {
+        pClientID: currentClientID,
+        clientID: nClientID,
+        tideID: senderTide.tideID,
+        id: senderTide.id
+      });
       return;
     }
     FileNetClientManager.addOnlineClient(clientID, pClientID, tideID, connectionID);
@@ -518,7 +538,7 @@ class FileMessager {
     this.fileNet.emit("current-clients", currentOnlineClients);
     return;
   }
-  handleClientOffline(clientData) {
+  handleClientOffline(senderTide, clientData) {
     console.log(`[FileTide ~ Net Activity] ~ Client ~ ${clientData.clientID} | connection origin ~ ${clientData.connectionID} going offline...`);
     try {
       const clientDetails = FileNetClientManager.getOnlineClient(clientData.clientID);
@@ -537,7 +557,7 @@ class FileMessager {
       const tidingTransfers = this.currentTidingTransfers.get(clientData.clientID);
       if (tidingTransfers && tidingTransfers.size > 0) {
         for (let recipientID of tidingTransfers.keys()) {
-          const recipientConnectionID = FileNetClientManager.getOnlineClient(data.recipientID).id;
+          const recipientConnectionID = FileNetClientManager.getOnlineClient(clientData.recipientID).id;
           const client = this.getClientFromID(recipientConnectionID);
           if (client) {
             this.fileNet.emitToTide(client.tideID, "save-current-transfer-states", {
@@ -552,7 +572,7 @@ class FileMessager {
     }
     return;
   }
-  handleClientTiding(data) {
+  handleClientTiding(senderTide, data) {
     try {
       const senderConnectionID = FileNetClientManager.getOnlineClient(data.senderID).id;
       const senderClient = this.getClientFromID(senderConnectionID);
@@ -565,6 +585,7 @@ class FileMessager {
       });
       return;
     } catch (error) {
+      console.error(`[FileTide ~ Net Activity] ~ `, error);
       return;
     }
   }

package/dist/cjs/FileMessagerClient.js

@@ -7,10 +7,13 @@ const chalk = require("chalk");
 const path = require("path");
 const fs = require("fs");
 const {
-  FileNetUtilityManager,
+  FileTideDebugUtilityManager,
   significantMessageColors,
   errorMessageColors
-} = require("./HUDManagers/FileNetUtilityManager");
+} = require("./HUDManagers/FileTideDebugUtilityManager");
+const {
+  FileTransferTrackingManager
+} = require("./HUDManagers/FileTransferTrackingManager.js");
 const FileTransferRecoveryManager = require("./HUDManagers/FileTransferRecoveryManager");
 const {
   FileMessagerConfigManager
@@ -46,12 +49,13 @@ class FileMessagerClient {
       transports: ["websocket"],
       ...options
     }, headers, authURL, authHeaders, useAuthentication, queryAuthToken, onConnect, () => {
+      FileTransferTrackingManager.outputCurrentTransfers();
       FileTransferRecoveryManager.flushToDisk();
       if (onDisconnect) {
         onDisconnect();
       }
     });
-    FileNetUtilityManager.outputGradient(`\n[FileTide ~ File Messager] ~ Created client with ID ${clientID} and socket ${clientID}!`, significantMessageColors);
+    FileTideDebugUtilityManager.outputGradient(`\n[FileTide ~ File Messager] ~ Created client with ID ${clientID} and socket ${clientID}!`, significantMessageColors);
     return clientID;
   }
   joinRoom(userID, roomName, options = {}, headers = {}, onConnect = null, onDisconnect = null, authURL = "", authHeaders = {}, useAuthentication = false, queryAuthToken = false) {
@@ -60,7 +64,7 @@ class FileMessagerClient {
     }, 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);
+        FileTideDebugUtilityManager.outputGradient(`\n[FileTide ~ File Messager] ~ Client ~ ${userID} joined room ${roomName} successfully!`, significantMessageColors);
         this.clients.set(userID, {
           roomName
         });
@@ -109,18 +113,18 @@ class FileMessagerClient {
         transferType
       }, transferExpirationTime);
       if (!transferAccepted) {
-        FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ${recipientID} denied your transfer.`, errorMessageColors);
+        FileTideDebugUtilityManager.outputGradient(`[FileTide ~ File Messager] ${recipientID} denied your transfer.`, errorMessageColors);
         return false;
       } else if (transferAccepted) {
-        FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ${recipientID} accepted your transfer!`, significantMessageColors);
+        FileTideDebugUtilityManager.outputGradient(`[FileTide ~ File Messager] ${recipientID} accepted your transfer!`, significantMessageColors);
         return true;
       }
     } catch (error) {
       if (error.message.startsWith("Timeout: No response")) {
-        FileNetUtilityManager.outputGradient("[FileTide ~ File Messager] Transfer approval timed out.", errorMessageColors);
+        FileTideDebugUtilityManager.outputGradient("[FileTide ~ File Messager] Transfer approval timed out.", errorMessageColors);
         return false;
       }
-      FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] Transfer approval refused.\n${error}`, errorMessageColors);
+      FileTideDebugUtilityManager.outputGradient(`[FileTide ~ File Messager] Transfer approval refused.\n${error}`, errorMessageColors);
       return false;
     }
   }
@@ -163,7 +167,7 @@ class FileMessagerClient {
       });
       Promise.all(sendFilePromises).then(() => console.log("\nAll files in directory transferred successfully!")).catch(error => console.error("Did not transfer directory: ", error));
     } catch (error) {
-      FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Refused directory transfer: ${error}`, errorMessageColors);
+      FileTideDebugUtilityManager.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, transferRequestExpirationTime = 30000) {
@@ -192,7 +196,7 @@ class FileMessagerClient {
   }
   async sendFile(clientID, recipientId, fileName, filePath = process.cwd(), destination = process.cwd(), fileSize, tideSize = 500, minTideSize = 10, maxTideSize = 2000, initiatingTransfer = true, inDirectory = false, largeFile = false, transferRequestExpirationTime = 30000) {
     const destinationPath = FileUtilityManager.normalizePath(path.join(destination, fileName));
-    FileNetUtilityManager.outputGradient(largeFile ? `[FileTide ~ File Messager] ~ Requesting to transfer large file ~ ${destinationPath} to ${recipientId}!` : `[FileTide ~ File Messager] ~ Requesting to transfer ~ ${destinationPath} to ${recipientId}!`, significantMessageColors);
+    FileTideDebugUtilityManager.outputGradient(largeFile ? `[FileTide ~ File Messager] ~ Requesting to transfer large file ~ ${destinationPath} to ${recipientId}!` : `[FileTide ~ File Messager] ~ Requesting to transfer ~ ${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, filePath, fileSize, 1, "file", "send", transferRequestExpirationTime);
@@ -298,9 +302,9 @@ class FileMessagerClient {
           });
         }
       }, this.clientTide);
-      FileNetUtilityManager.outputGradient(largeFile ? `[FileTide ~ File Messager] ~ Large file ~ ${fileName} transfer complete!` : `[FileTide ~ File Messager] ~ File ~ ${fileName} transfer complete!`, significantMessageColors);
+      FileTideDebugUtilityManager.outputGradient(largeFile ? `[FileTide ~ File Messager] ~ Large file ~ ${fileName} transfer complete!` : `[FileTide ~ File Messager] ~ File ~ ${fileName} transfer complete!`, significantMessageColors);
     } catch (error) {
-      FileNetUtilityManager.outputGradient(largeFile ? `[FileTide ~ File Messager] ~ Error transferring large file: ${error.message}` : `[FileTide ~ File Messager] ~ Error transferring file ~ ${error.message}`, errorMessageColors);
+      FileTideDebugUtilityManager.outputGradient(largeFile ? `[FileTide ~ File Messager] ~ Error transferring large file: ${error.message}` : `[FileTide ~ File Messager] ~ Error transferring file ~ ${error.message}`, errorMessageColors);
     } finally {
       await fileHandle.close();
     }

package/dist/cjs/FileTide.js

@@ -11,10 +11,13 @@ const chalk = require("chalk");
 const path = require("path");
 const fs = require("fs");
 const {
-  FileNetUtilityManager,
+  FileTideDebugUtilityManager,
   significantMessageColors,
   errorMessageColors
-} = require("./HUDManagers/FileNetUtilityManager.js");
+} = require("./HUDManagers/FileTideDebugUtilityManager.js");
+const {
+  FileTransferTrackingManager
+} = require("./HUDManagers/FileTransferTrackingManager.js");
 const {
   FileTransferReceiverManager
 } = require("./HUDManagers/FileTransferReceiverManager.js");
@@ -32,7 +35,7 @@ const FileMessagerClient = require("./FileMessagerClient");
 const FileMessager = require("./FileMessager");
 var _FileTide_brand = /*#__PURE__*/new WeakSet();
 class FileTide {
-  constructor() {
+  constructor(debugMode = true) {
     /**
      * Set up file transfer event listeners natively.
      * Automatically checks and creates directories as needed.
@@ -45,10 +48,12 @@ class FileTide {
     this.transferBarrier = false;
     this.clients = new Map();
     this.currentUserID = "";
+    this.inDebugMode = debugMode;
+    FileTideDebugUtilityManager.setDebugMode(debugMode);
     return;
   }
   static outputGradient(text, colors) {
-    FileNetUtilityManager.outputGradient(text, colors);
+    FileTideDebugUtilityManager.outputGradient(text, colors);
     return;
   }
 
@@ -104,7 +109,7 @@ class FileTide {
     const newClient = new FileMessagerClient(clientOptions, transportOptions, messagerSettings);
     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.clientShorePolicies.set(userID, [FileUtilityManager.getTidePath(">Downloads"), FileUtilityManager.getTidePath(">Documents"), FileUtilityManager.getTidePath(">Desktop"), FileUtilityManager.getTidePath(">Photos"), FileUtilityManager.getTidePath(">Videos"), FileUtilityManager.getTidePath(">Music")]);
     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);
@@ -142,7 +147,7 @@ class FileTide {
     const clientID = this.currentUserID;
     const clientMessager = this.clients.get(clientID);
     if (!clientMessager) {
-      FileTide.outputGradient(`[FileTide] Client ~ ${clientID} not found.`, ["#F94144", "#F3722C"]);
+      FileTide.outputGradient(`[FileTide] Client ~ ${clientID} not found.`, errorMessageColors);
       return;
     }
     clientMessager.listFiles(clientID, recipientID, depth);
@@ -153,7 +158,7 @@ class FileTide {
   clearShorePolicies(clientID, shores = []) {
     let clientShorePolicies = this.clientShorePolicies.get(clientID);
     if (!shores || shores.length <= 0 || !clientShorePolicies || !clientID) {
-      FileTide.outputGradient(`[FileTide] Did not clear from client ~ ${clientID} shore policies.`, ["#F94144", "#F3722C"]);
+      FileTide.outputGradient(`[FileTide] Did not clear from client ~ ${clientID} shore policies.`, errorMessageColors);
       return false;
     }
     const shorePolicies = Array.from(clientShorePolicies.values());
@@ -164,7 +169,7 @@ class FileTide {
   addShorePolicies(clientID, shores = []) {
     const clientShorePolicies = this.clientShorePolicies.get(clientID);
     if (!shores || shores.length <= 0 || !clientShorePolicies || !clientID) {
-      FileTide.outputGradient(`[FileTide] Did not add to client ~ ${clientID} shore policies.`, ["#F94144", "#F3722C"]);
+      FileTide.outputGradient(`[FileTide] Did not add to client ~ ${clientID} shore policies.`, errorMessageColors);
       return false;
     }
     this.clientShorePolicies.set(clientID, [...new Set([...clientShorePolicies, ...shores])]);
@@ -190,33 +195,33 @@ class FileTide {
     const clientID = this.currentUserID;
     const clientMessager = this.clients.get(clientID);
     if (!clientMessager) {
-      FileTide.outputGradient(`[FileTide] Client ~ ${clientID} not found.`, ["#F94144", "#F3722C"]);
+      FileTide.outputGradient(`[FileTide] Client ~ ${clientID} not found.`, errorMessageColors);
       return false;
     }
     const recipientOnline = await clientMessager.clientTide.emitEventWithResponse(clientID, "check-client-online", "retrieved-client-online", {
       clientID: recipientID
     }, 5000);
     if (!recipientOnline || !recipientOnline.online) {
-      FileTide.outputGradient(`[FileTide] ${recipientID} currently not tiding.`, ["#F94144", "#F3722C"]);
+      FileTide.outputGradient(`[FileTide] ${recipientID} currently not tiding.`, errorMessageColors);
       return false;
     }
     const fileDetails = await this.getPathData(filePath, filterDirectoryContent);
     if (!fileDetails) {
-      FileTide.outputGradient(`[${clientID}] File at path ${filePath} not found.`, ["#F94144", "#F3722C"]);
+      FileTide.outputGradient(`[${clientID}] File at path ${filePath} not found.`, errorMessageColors);
       return false;
     }
     if (fileDetails.type === "file") {
       if (fileDetails.largeFile) {
-        FileTide.outputGradient(`[${clientID}] Sending large file ~ ${fileDetails.fileName} to client ~ ${recipientID}...`, ["#00C897", "#00E0FF"]);
+        FileTide.outputGradient(`[${clientID}] Sending large file ~ ${fileDetails.fileName} to client ~ ${recipientID}...`, significantMessageColors);
         await clientMessager.sendFile(clientID, recipientID, fileDetails.fileName, fileDetails.filePath, destinationPath, fileDetails.fileSize, tidalSize, minTideSize, maxTideSize, true, false, true, transferRequestExpirationTime);
         return true;
       }
-      FileTide.outputGradient(`[${clientID}] Sending file ~ ${fileDetails.content.fileName} to client ~ ${recipientID}...`, ["#00C897", "#00E0FF"]);
+      FileTide.outputGradient(`[${clientID}] Sending file ~ ${fileDetails.content.fileName} to client ~ ${recipientID}...`, significantMessageColors);
       await clientMessager.sendFile(clientID, recipientID, fileDetails.content.fileName, fileDetails.content.filePath, destinationPath, fileDetails.content.size, tideSize, minTideSize, maxTideSize, transferRequestExpirationTime);
       return true;
     }
     if (fileDetails.type === "directory") {
-      FileTide.outputGradient(`[${clientID}] Sending ${fileDetails.content.length} files in directory ~ ${path.basename(filePath)} to client ~ ${recipientID}...`, ["#00C897", "#00E0FF"]);
+      FileTide.outputGradient(`[${clientID}] Sending ${fileDetails.content.length} files in directory ~ ${path.basename(filePath)} to client ~ ${recipientID}...`, significantMessageColors);
       await clientMessager.sendDirectoryFiles(clientID, recipientID, fileDetails.content, this.getTidePath(filePath), destinationPath, tideSize, minTideSize, maxTideSize, transferRequestExpirationTime);
       return true;
     }
@@ -439,7 +444,7 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
         onIncomingFile(verifiedSender, {
           ...data,
           stats: taskBarStats
-        }, fileTransferReceiver.activeTransfers);
+        }, FileTransferTrackingManager.activeTransfers);
       }
       if (verifiedSender && !fs.existsSync(saveDir)) {
         fs.mkdirSync(saveDir, {
@@ -465,6 +470,8 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
   });
   client.clientTide.onEvent(userID, "transfer-progress", async data => {
     if (!data || data.fileChunk === undefined || data.fileChunk === null) {
+      FileTideDebugUtilityManager.log("notice", true, `Received invalid data chunk from ~ ${data.senderName} in transfer progress ~ ${data.fileName}`);
+      FileTransferTrackingManager.outputCurrentTransfers();
       return;
     }
     await fileTransferReceiver.handleTransferProgress(data);
@@ -498,12 +505,15 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
       fileSize
     } = data;
     if (chunkIndex === 0) {
+      FileTransferTrackingManager.trackTransfer(data);
       this.progressBarManager.addTask({
         name: fileName,
         size: fileSize
       });
+    } else if (chunkIndex > 0) {
+      FileTransferTrackingManager.updateTransfer(data);
+      this.progressBarManager.updateTaskProgress(fileName, chunkSize);
     }
-    this.progressBarManager.updateTaskProgress(fileName, chunkSize);
     if (onTransferStatus) {
       const taskBarStats = this.progressBarManager.getTaskBar(fileName);
       onTransferStatus({
@@ -517,28 +527,47 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
     const savePath = FileUtilityManager.getTidePath(path.join(data.filePath, data.fileName));
     try {
       _FileTide.outputGradient(`[${userID}] File transfer complete ~ ${data.fileName}`, significantMessageColors);
-      const transferState = fileTransferReceiver.activeTransfers.get(data.fileName);
+      const transferState = FileTransferTrackingManager.getTransfer(data.fileName);
+      FileTideDebugUtilityManager.log("notice", true, `Transfer state ~ ${data.fileName} active | ${transferState !== null && transferState !== undefined ? true : false}`);
       if (!transferState) {
         return;
       }
-      fileTransferReceiver.completeTransfer(data, (transferData, transfers, success, error) => {
-        if (success) {
-          FileTransferRecoveryManager.clearTransferState(userID, data.senderID, `${data.filePath}-${data.fileName}`);
-          _FileTide.outputGradient(`[${userID}] File saved at ~ ${savePath}\n`, significantMessageColors);
-        } else if (!success) {
-          _FileTide.outputGradient(`[${userID}] Did not save file at ~ ${savePath}\n\t${error}\n`, errorMessageColors);
-        }
-        if (onTransferComplete) {
-          const taskBarStats = this.progressBarManager.getTaskBar(data.fileName);
-          onTransferComplete({
-            ...data,
-            stats: taskBarStats
-          }, fileTransferReceiver.activeTransfers, success);
-        }
-        setTimeout(() => {
-          this.progressBarManager.clearTaskBar(data.fileName);
-        }, this.progressBarManager.completionTimeout);
-      });
+      if (transferState.fileStream) {
+        fileTransferReceiver.completeTransfer(data, (transferData, transfers, success, error) => {
+          if (success) {
+            FileTransferRecoveryManager.clearTransferState(userID, data.senderID, `${data.filePath}-${data.fileName}`);
+            _FileTide.outputGradient(`[${userID}] File saved at ~ ${savePath}\n`, significantMessageColors);
+          } else if (!success) {
+            _FileTide.outputGradient(`[${userID}] Did not save file at ~ ${savePath}\n\t${error}\n`, errorMessageColors);
+          }
+          if (onTransferComplete) {
+            const taskBarStats = this.progressBarManager.getTaskBar(data.fileName);
+            onTransferComplete({
+              ...data,
+              stats: taskBarStats
+            }, FileTransferTrackingManager.activeTransfers, success);
+          }
+          setTimeout(() => {
+            FileTransferTrackingManager.outputCurrentTransfers();
+            this.progressBarManager.clearTaskBar(data.fileName);
+          }, this.progressBarManager.completionTimeout);
+        });
+        return;
+      }
+      FileTransferRecoveryManager.clearTransferState(userID, data.senderID, `${data.filePath}-${data.fileName}`);
+      FileTransferTrackingManager.untrackTransfer(data.fileName);
+      _FileTide.outputGradient(`[${userID}] Transfer successfully sent to ~ ${data.recipientId} and saved at ~ ${path.join(data.filePath, data.fileName)}\n`, significantMessageColors);
+      if (onTransferComplete) {
+        const taskBarStats = this.progressBarManager.getTaskBar(data.fileName);
+        onTransferComplete({
+          ...data,
+          stats: taskBarStats
+        }, FileTransferTrackingManager.activeTransfers, true);
+      }
+      setTimeout(() => {
+        FileTransferTrackingManager.outputCurrentTransfers();
+        this.progressBarManager.clearTaskBar(data.fileName);
+      }, this.progressBarManager.completionTimeout);
     } catch (error) {
       _FileTide.outputGradient(`[${userID}] Did not save file at ~ ${savePath}\n${error}`, errorMessageColors);
       if (onTransferComplete) {
@@ -546,9 +575,10 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
         onTransferComplete({
           ...data,
           stats: taskBarStats
-        }, fileTransferReceiver.activeTransfers, false);
+        }, FileTransferTrackingManager.activeTransfers, false);
       }
       setTimeout(() => {
+        FileTransferTrackingManager.outputCurrentTransfers();
         this.progressBarManager.clearTaskBar(data.fileName);
       }, this.progressBarManager.completionTimeout);
     }

package/dist/cjs/HUDComponents/ConsoleProgressBarManager.js

@@ -2,6 +2,9 @@
 
 const readline = require("readline");
 const chalk = require("chalk");
+const {
+  FileTideDebugUtilityManager
+} = require("../HUDManagers/FileTideDebugUtilityManager.js");
 const {
   FileNetUtilityManager
 } = require("../HUDManagers/FileNetUtilityManager");
@@ -107,7 +110,9 @@ class ConsoleProgressBarManager {
         setTimeout(() => {
           this.completionFeed = this.completionFeed.filter(task => task !== newBar.taskName);
         }, this.completionTimeout);
+        FileTideDebugUtilityManager.log("notice", true, `Tasks Completion Status ~\n\n\tTasks ~ (${this.completedTasksCount}/${this.totalTasks})`);
         if (this.completedTasksCount === this.totalTasks) {
+          FileTideDebugUtilityManager.log("notice", true, `All Tasks Complete!`);
           this.allTasksCompleted = true;
           this.exitInputListener();
           this.displayPage();
@@ -153,7 +158,7 @@ class ConsoleProgressBarManager {
   getCurrentStats() {
     const completedTasks = this.taskBars.filter(bar => bar.completed).length;
     const totalTasks = this.taskBars.length;
-    const overallProgress = this.taskBars.reduce((acc, bar) => acc + bar.current / bar.totalSize * 100, 0) / totalTasks;
+    const overallProgress = totalTasks === 0 ? 0 : this.taskBars.reduce((acc, bar) => acc + bar.current / bar.totalSize * 100, 0) / totalTasks;
     const stats = {
       completedTasks,
       totalTasks,
@@ -259,14 +264,20 @@ class ConsoleProgressBarManager {
   }
   exitInputListener() {
     process.stdin.removeListener("data", this.inputListener);
+    FileTideDebugUtilityManager.log("notice", true, `Exiting input listener...`);
+    FileTideDebugUtilityManager.log("notice", true, `Process TTY ~ ${process.stdout.isTTY}`);
     if (process.stdout.isTTY) {
       process.stdin.setRawMode(false);
       process.stdin.resume();
+      FileTideDebugUtilityManager.log("notice", true, `Resumed process.`);
     }
+    FileTideDebugUtilityManager.log("notice", true, `Exited input listener.`);
   }
   displayCompletionMessage() {
     const lastLine = Math.min(this.taskBars.length, this.barsPerPage);
     readline.cursorTo(process.stdout, 0, lastLine);
+    FileTideDebugUtilityManager.log("notice", true, `Displaying task completion message...`);
+    FileTideDebugUtilityManager.log("notice", true, `Process TTY ~ ${process.stdout.isTTY}`);
     if (process.stdout.isTTY) {
       process.stdout.clearLine();
     }

package/dist/cjs/HUDManagers/FileNetClientManager.js

@@ -14,6 +14,17 @@ class FileNetClientManager {
     });
     return currentOnlineClients;
   }
+  static updateOnlineClient(clientID, data) {
+    const onlineClient = currentOnlineClients.get(clientID);
+    if (!onlineClient) {
+      return false;
+    }
+    currentOnlineClients.set(clientID, {
+      ...onlineClient,
+      ...data
+    });
+    return true;
+  }
   static clearOnlineClient(clientID) {
     if (!currentOnlineClients.get(clientID)) {
       return currentOnlineClients;

package/dist/cjs/HUDManagers/FileNetUtilityManager.js

@@ -3,20 +3,7 @@
 const {
   HUDUtilityManager
 } = require("@trap_stevo/legendarybuilderpronodejs-utilities");
-const chalk = require("chalk");
-const significantMessageColors = ["#00C897", "#00E0FF"];
-const errorMessageColors = ["#F94144", "#F3722C"];
 class FileNetUtilityManager {
-  static outputGradient(text, colors) {
-    const gradient = HUDUtilityManager.generateGradientColors(colors, text.length);
-    let coloredText = "";
-    for (let i = 0; i < text.length; i++) {
-      const [r, g, b] = gradient[i];
-      coloredText += chalk.rgb(r, g, b)(text[i]);
-    }
-    console.log(coloredText);
-    return;
-  }
   static convertSeconds(seconds) {
     if (seconds === 0) return "0 s";
     const units = [{
@@ -80,7 +67,5 @@ class FileNetUtilityManager {
   }
 }
 module.exports = {
-  FileNetUtilityManager,
-  significantMessageColors,
-  errorMessageColors
+  FileNetUtilityManager
 };

package/dist/cjs/HUDManagers/FileTideDebugUtilityManager.js

@@ -0,0 +1,73 @@
+"use strict";
+
+const {
+  HUDUtilityManager
+} = require("@trap_stevo/legendarybuilderpronodejs-utilities");
+const chalk = require("chalk");
+const significantMessageColors = ["#00C897", "#00E0FF"];
+const noticeMessageColors = ["#4A90E2", "#A3D8F4"];
+const errorMessageColors = ["#F94144", "#F3722C"];
+const infoMessageColors = ["#028090", "#56cfe1"];
+const logHandler = {
+  "significant": function (includeDate = false, ...message) {
+    const log = includeDate ? `[${new Date().toLocaleString()}] ~ ` : "";
+    outputGradient(log + message.join(" "), significantMessageColors);
+  },
+  "notice": function (includeDate = false, ...message) {
+    const log = includeDate ? `[${new Date().toLocaleString()}] ~ ` : "";
+    outputGradient(log + message.join(" "), noticeMessageColors);
+  },
+  "error": function (includeDate = false, ...message) {
+    const log = includeDate ? `[${new Date().toLocaleString()}] ~ ` : "";
+    outputGradient(log + message.join(" "), errorMessageColors);
+  },
+  "info": function (includeDate = false, ...message) {
+    const log = includeDate ? `[${new Date().toLocaleString()}] ~ ` : "";
+    outputGradient(log + message.join(" "), infoMessageColors);
+  }
+};
+function outputGradient(text, colors) {
+  const gradient = HUDUtilityManager.generateGradientColors(colors, text.length);
+  let coloredText = "";
+  for (let i = 0; i < text.length; i++) {
+    const [r, g, b] = gradient[i];
+    coloredText += chalk.rgb(r, g, b)(text[i]);
+  }
+  console.log(coloredText);
+  return;
+}
+;
+class FileTideDebugUtilityManager {
+  constructor() {
+    if (FileTideDebugUtilityManager.instance) {
+      return FileTideDebugUtilityManager.instance;
+    }
+    this.debugMode = false;
+    FileTideDebugUtilityManager.instance = this;
+  }
+  outputGradient(text, colors) {
+    outputGradient(text, colors);
+    return;
+  }
+  setDebugMode(mode) {
+    this.debugMode = mode;
+  }
+  log(type = "info", includeDate = false, ...message) {
+    if (!this.debugMode && type !== "error") {
+      return;
+    }
+    if (logHandler[type]) {
+      logHandler[type](includeDate, ...message);
+      return;
+    }
+    console.log(new Date().toLocaleString(), chalk.gray("Unknown log type ~ "), type, ...message);
+  }
+}
+const instance = new FileTideDebugUtilityManager();
+module.exports = {
+  FileTideDebugUtilityManager: instance,
+  significantMessageColors,
+  noticeMessageColors,
+  errorMessageColors,
+  infoMessageColors
+};

package/dist/cjs/HUDManagers/FileTransferReceiverManager.js

@@ -1,21 +1,25 @@
 "use strict";
 
-const fs = require("fs");
 const path = require("path");
+const fs = require("fs");
+const {
+  FileTransferTrackingManager
+} = require("./FileTransferTrackingManager.js");
+const {
+  FileTideDebugUtilityManager
+} = require("./FileTideDebugUtilityManager.js");
 const {
   FileUtilityManager
 } = require("./FileUtilityManager.js");
 class FileTransferReceiverManager {
-  constructor() {
-    this.activeTransfers = new Map();
-  }
+  constructor() {}
   async initializeTransfer(data, onError) {
     const savePath = FileUtilityManager.getTidePath(path.join(data.path || data.filePath, data.fileName));
-    if (this.activeTransfers.has(data.fileName)) {
+    FileTideDebugUtilityManager.log("notice", true, `Initializing transfer ~ ${data.fileName} | ${savePath}...`);
+    if (FileTransferTrackingManager.containsTransfer(data.fileName)) {
+      FileTideDebugUtilityManager.log("notice", true, `Transfer ~ ${data.fileName} | ${savePath} already initialized.`);
       return;
     }
-    const totalChunks = data.totalChunks || Math.ceil(data.fileSize / (data.chunkSize || 512 * 1024));
-    const chunkSize = data.chunkSize || 512 * 1024;
     try {
       const dir = path.dirname(savePath);
       if (!fs.existsSync(dir)) {
@@ -26,53 +30,58 @@ class FileTransferReceiverManager {
       const fileStream = fs.createWriteStream(savePath, {
         flags: "w"
       });
-      this.activeTransfers.set(data.fileName, {
-        receivedChunks: new Set(),
-        fileInfo: data,
-        totalChunks,
-        fileStream,
-        chunkSize
-      });
+      FileTransferTrackingManager.trackTransfer(data, fileStream);
+      FileTideDebugUtilityManager.log("notice", true, `Initialized transfer ~ ${data.fileName} | ${savePath}!`);
     } catch (error) {
+      FileTideDebugUtilityManager.log("error", true, `Did not initialize transfer ~ ${data.fileName} | ${savePath}.\n\t\t${error}`);
       if (onError) {
         onError(`[${data.fileName}] Did not initialize transfer ~ ${error.message}`);
       }
     }
   }
   async handleTransferProgress(data, onError) {
-    let transferState = this.activeTransfers.get(data.fileName);
+    let transferState = FileTransferTrackingManager.getTransfer(data.fileName);
     if (!transferState) {
       await this.initializeTransfer(data);
-      transferState = this.activeTransfers.get(data.fileName);
+      transferState = tFileTransferTrackingManager.getTransfer(data.fileName);
     }
     const chunkBuffer = Buffer.from(data.fileChunk);
     try {
       transferState.fileStream.write(chunkBuffer);
       transferState.receivedChunks.add(data.chunkIndex);
     } catch (error) {
+      FileTideDebugUtilityManager.log("error", true, `Did not write chunk ${data.chunkIndex} ~ ${data.fileName}.\n\t\t${error}`);
       if (onError) {
         onError(`[${data.fileName}] Did not write chunk ${data.chunkIndex} ~ ${error.message}`);
       }
     }
   }
   async completeTransfer(data, onComplete) {
-    let transferState = this.activeTransfers.get(data.fileName);
+    let transferState = FileTransferTrackingManager.getTransfer(data.fileName);
+    FileTideDebugUtilityManager.log("notice", true, `Completing transfer ~ ${data.fileName}...`);
     if (!transferState) {
+      FileTideDebugUtilityManager.log("notice", true, `Did not get transfer state ~ ${data.fileName}...re-initializing....`);
       await this.initializeTransfer(data);
-      transferState = this.activeTransfers.get(data.fileName);
+      transferState = FileTransferTrackingManager.getTransfer(data.fileName);
     }
     try {
+      FileTideDebugUtilityManager.log("notice", true, `Verifying transfer state ~ ${data.fileName} completion (${transferState.receivedChunks.size}/${transferState.totalChunks})...`);
+      FileTideDebugUtilityManager.log("notice", true, `Transfer state ~ ${data.fileName} completed ~ (${transferState.receivedChunks.size === transferState.totalChunks}).`);
       if (transferState.receivedChunks.size === transferState.totalChunks) {
         transferState.fileStream.end();
         console.log(`[${data.fileName}] Transfer complete. All chunks received and file written.`);
-        this.activeTransfers.delete(data.fileName);
-        if (onComplete) onComplete(data, this.activeTransfers, true);
+        FileTransferTrackingManager.untrackTransfer(data.fileName);
+        FileTideDebugUtilityManager.log("notice", true, `Cleared transfer state ~ ${data.fileName}.`);
+        FileTransferTrackingManager.outputCurrentTransfers();
+        if (onComplete) onComplete(data, FileTransferTrackingManager.activeTransfers, true);
       } else {
+        FileTideDebugUtilityManager.log("error", true, `Transfer incomplete. Received ${transferState.receivedChunks.size}/${transferState.totalChunks} chunks.`);
         throw new Error(`[${data.fileName}] Transfer incomplete. Received ${transferState.receivedChunks.size}/${transferState.totalChunks} chunks.`);
       }
     } catch (error) {
+      FileTideDebugUtilityManager.log("error", true, `Transfer incomplete.\n\t\t${error}`);
       if (onComplete) {
-        onComplete(data, this.activeTransfers, false, error);
+        onComplete(data, FileTransferTrackingManager.activeTransfers, false, error);
       }
     }
   }

package/dist/cjs/HUDManagers/FileTransferTrackingManager.js

@@ -0,0 +1,84 @@
+"use strict";
+
+const {
+  FileTideDebugUtilityManager
+} = require("./FileTideDebugUtilityManager.js");
+class FileTransferTrackingManager {
+  constructor() {
+    if (FileTransferTrackingManager.instance) {
+      return FileTransferTrackingManager.instance;
+    }
+    this.activeTransfers = new Map();
+    FileTransferTrackingManager.instance = this;
+  }
+  trackTransfer(data, fileStream) {
+    FileTideDebugUtilityManager.log("notice", true, `Tracking transfer ~ ${data.fileName} | ${data.senderName}...`);
+    if (this.containsTransfer(data.fileName)) {
+      FileTideDebugUtilityManager.log("notice", true, `Transfer ~ ${data.fileName} | ${data.senderName} already tracked.`);
+      return;
+    }
+    const totalChunks = data.totalChunks || Math.ceil(data.fileSize / (data.chunkSize || 512 * 1024));
+    const chunkSize = data.chunkSize || 512 * 1024;
+    this.activeTransfers.set(data.fileName, {
+      receivedChunks: new Set(),
+      fileInfo: data,
+      totalChunks,
+      fileStream,
+      chunkSize
+    });
+    FileTideDebugUtilityManager.log("notice", true, `Tracked transfer ~ ${data.fileName} | ${data.senderName}!`);
+  }
+  updateTransfer(data) {
+    FileTideDebugUtilityManager.log("notice", true, `Updating tracked transfer ~ ${data.fileName} | ${data.senderName}...`);
+    if (!this.containsTransfer(data.fileName)) {
+      FileTideDebugUtilityManager.log("notice", true, `Transfer ~ ${data.fileName} | ${data.senderName} not tracked.`);
+      return;
+    }
+    const transferState = this.getTransfer(data.fileName);
+    transferState.receivedChunks.add(data.chunkIndex);
+    FileTideDebugUtilityManager.log("notice", true, `Updated tracked transfer ~ ${data.fileName} | ${data.senderName}!`);
+  }
+  containsTransfer(transferID) {
+    return this.activeTransfers.has(transferID);
+  }
+  getTransfer(transferID) {
+    return this.activeTransfers.get(transferID);
+  }
+  untrackTransfer(transferID) {
+    FileTideDebugUtilityManager.log("notice", true, `Untracking transfer ~ ${transferID}...`);
+    if (this.containsTransfer(transferID)) {
+      this.activeTransfers.delete(transferID);
+      FileTideDebugUtilityManager.log("notice", true, `Transfer ~ ${transferID} untracked!`);
+      return;
+    }
+    FileTideDebugUtilityManager.log("notice", true, `Transfer ~ ${transferID} already untracked.`);
+  }
+  outputCurrentTransfers() {
+    if (this.activeTransfers.size === 0) {
+      FileTideDebugUtilityManager.log("notice", true, "No active file transfers.");
+      return;
+    }
+    FileTideDebugUtilityManager.log("notice", true, "Ongoing Transfers ~\n");
+    this.activeTransfers.forEach((transfer, fileName) => {
+      const {
+        totalChunks,
+        receivedChunks,
+        fileInfo
+      } = transfer;
+      const percentage = (receivedChunks.size / totalChunks * 100).toFixed(2);
+      FileTideDebugUtilityManager.log("notice", false, `\nFile Name ~ ${fileName}`);
+      FileTideDebugUtilityManager.log("notice", false, `File Path ~ ${fileInfo.path || fileInfo.filePath}`);
+      FileTideDebugUtilityManager.log("notice", false, `File Size ~ ${fileInfo.fileSize} bytes`);
+      FileTideDebugUtilityManager.log("notice", false, `Chunk Size ~ ${transfer.chunkSize} bytes`);
+      FileTideDebugUtilityManager.log("notice", false, `Total Chunks ~ ${totalChunks}`);
+      FileTideDebugUtilityManager.log("notice", false, `Received Chunks ~ ${receivedChunks.size}`);
+      FileTideDebugUtilityManager.log("notice", false, `Progress ~ ${percentage}%`);
+    });
+    FileTideDebugUtilityManager.log("notice", false, "=================================\n");
+  }
+}
+;
+const instance = new FileTransferTrackingManager();
+module.exports = {
+  FileTransferTrackingManager: instance
+};

package/dist/cjs/HUDManagers/FileUtilityManager.js

@@ -271,7 +271,7 @@ class FileUtilityManager {
       ">AppData": platform === "win32" ? path.join(homeDir, "AppData", "Roaming") : path.join(homeDir, ".config"),
       ">LocalAppData": platform === "win32" ? path.join(homeDir, "AppData", "Local") : path.join(homeDir, ".local", "share"),
       ">Music": path.join(homeDir, "Music"),
-      ">Pictures": path.join(homeDir, "Pictures"),
+      ">Photos": platform === "win32" ? path.join(homeDir, "Pictures") : path.join(homeDir, "Photos"),
       ">Videos": path.join(homeDir, "Videos"),
       ">Public": platform === "win32" ? path.join("C:", "Users", "Public") : "/usr/share",
       ">Templates": path.join(homeDir, "Templates"),

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@trap_stevo/filetide",
-  "version": "0.0.52",
+  "version": "0.0.54",
   "description": "Revolutionizing real-time file transfer with seamless, instant communication across any device. Deliver files instantly, regardless of platform, and experience unparalleled speed and control in managing transfers. Elevate your file-sharing capabilities with a tool designed for precision, efficiency, and effortless connectivity.",
   "main": "dist/cjs/FileTide.js",
   "scripts": {
     "build": "babel src -d dist/cjs --env-name cjs",
+    "start-file-generation": "node demos/FileGenerator.js",
     "start-messager": "node demos/FileTideClientDemo.js",
     "start-net": "node demos/FileTideNetDemo.js",
     "start": "node dist/cjs/FileTide.js"
@@ -33,7 +34,7 @@
   "author": "Steven Compton",
   "license": "See License in LICENSE.md",
   "dependencies": {
-    "@trap_stevo/iotide": "^0.0.37",
+    "@trap_stevo/iotide": "^0.0.41",
     "@trap_stevo/iotide-client": "^0.0.23",
     "@trap_stevo/legendarybuilderpronodejs-utilities": "^1.0.43",
     "chalk": "^4.1.2",