@trap_stevo/filetide 0.0.32 → 0.0.34

package/LICENSE.md

@@ -0,0 +1,35 @@
+# License Agreement for @trap_stevo/filetide
+
+**Effective Date**: September 10, 2024
+
+This License Agreement ("Agreement") is entered into by and between **Steven Compton**, the owner of the package ("Licensor"), and any individual or entity attempting to use the package ("Licensee"). By attempting to install, use, or modify the package, Licensee agrees to the following terms and conditions:
+
+## 1. **Ownership**
+**Steven Compton** is the sole owner of all rights, title, and interest in and to the @trap_stevo/filetide, including all related intellectual property rights.
+
+## 2. **Grant of License**
+Licensee is **NOT** granted any rights to use, modify, distribute, or create derivative works of @trap_stevo/filetide, either in part or in whole, without prior express written consent from the Licensor. Any use of the package without permission constitutes a violation of this Agreement and applicable intellectual property laws.
+
+## 3. **Prohibited Uses**
+Without the express written permission of the Licensor, Licensee shall not:
+- Use the package for any purpose, including but not limited to personal, commercial, or educational purposes.
+- Copy, modify, distribute, or sublicense the package.
+- Reverse-engineer, decompile, or disassemble the package.
+
+## 4. **Request for Permission**
+Licensee may request permission to use the package by contacting the Licensor at **h.steven.compton13@gmail.com**. The Licensor reserves the right to approve or deny any such request at its sole discretion.
+
+## 5. **Violation of Terms**
+Any unauthorized use of @trap_stevo/filetide will result in immediate termination of any rights granted and may lead to legal action. Licensor reserves the right to seek damages and remedies to the fullest extent permitted by law.
+
+## 6. **No Warranty**
+@trap_stevo/filetide is provided "as is," without any warranty of any kind, express or implied, including but not limited to warranties of merchantability, fitness for a particular purpose, or non-infringement. Licensee assumes all risks associated with the use of the package, including but not limited to potential damage to systems or data.
+
+## 7. **Indemnification**
+Licensee agrees to indemnify and hold harmless the Licensor from any and all claims, damages, liabilities, and expenses arising out of Licensee's use of the package in violation of this Agreement.
+
+## 8. **Governing Law**
+This Agreement shall be governed by and construed in accordance with the laws of **Georgia**, without regard to its conflict of law principles.
+
+## 9. **Amendments**
+Licensor reserves the right to modify or update this Agreement at any time. Any changes to the Agreement will be effective immediately upon being posted to **[Location of Agreement, e.g., repository or website]**.

package/dist/cjs/FileMessager.js

@@ -10,6 +10,7 @@ const {
 const {
   FileTransferManager
 } = require("./HUDManagers/FileTransferManager");
+const HUDTargetQueue = require("./HUDManagers/HUDTargetQueueManager");
 class FileMessager {
   constructor(options = {
     pingTimeout: 3600000,
@@ -20,6 +21,9 @@ class FileMessager {
   }) {
     const serverOptions = FileMessagerConfigManager.getServerOptions(options);
     this.transporter = new FileTransferManager(transportOptions);
+    this.transferQueue = new HUDTargetQueue();
+    this.currentTransferBarrierTransfers = new Map();
+    this.clientTransferBarriers = new Map();
     this.fileNet = new IoTide(serverOptions.port, serverOptions, true, this.onConnect.bind(this), this.onDisconnect.bind(this));
     this.onlineClients = new Map();
     return;
@@ -35,6 +39,10 @@ class FileMessager {
     return;
   }
   start() {
+    this.fileNet.on("get-client-transfer-barrier-response", this.handleClientTransferBarrierResponse.bind(this));
+    this.fileNet.on("notify-transfer-barrier", this.handleNotifyTransferBarrier.bind(this));
+    this.fileNet.on("send-file-list-to-client", this.handleSendFileListToClient.bind(this));
+    this.fileNet.on("list-client-files", this.handleListClientFiles.bind(this));
     this.fileNet.on("transfer-start", this.handleFileTransferStart.bind(this));
     this.fileNet.on("transfer-progress", this.handleFileTransferProgress.bind(this));
     this.fileNet.on("transfer-complete", this.handleFileTransferComplete.bind(this));
@@ -63,7 +71,8 @@ class FileMessager {
       senderID,
       requesterID,
       path: filePath,
-      destinationPath
+      destinationPath,
+      type: "requestedTransfer"
     });
   }
 
@@ -118,6 +127,41 @@ class FileMessager {
     } = transferData;
     this.requestFromClient(requesterID, senderID, filePath, destinationPath);
   }
+  handleSendFileListToClient(listData) {
+    const {
+      listedFiles,
+      recipientID,
+      senderID
+    } = listData;
+    const recipientConnectionID = FileNetClientManager.getOnlineClient(recipientID).id;
+    const senderConnectionID = FileNetClientManager.getOnlineClient(senderID).id;
+    const senderClient = this.getClientFromID(senderConnectionID);
+    const client = this.getClientFromID(recipientConnectionID);
+    if (!client || !senderClient) {
+      return;
+    }
+    this.fileNet.emitToTide(client.tideID, "client-file-list", {
+      senderID,
+      listedFiles
+    });
+  }
+  handleListClientFiles(clientData) {
+    const {
+      requesterID,
+      recipientID
+    } = clientData;
+    const recipientConnectionID = FileNetClientManager.getOnlineClient(recipientID).id;
+    const senderConnectionID = FileNetClientManager.getOnlineClient(requesterID).id;
+    const senderClient = this.getClientFromID(senderConnectionID);
+    const client = this.getClientFromID(recipientConnectionID);
+    if (!client || !senderClient) {
+      return;
+    }
+    this.fileNet.emitToTide(client.tideID, "list-files", {
+      senderID: requesterID,
+      recipientID
+    });
+  }
   handleClientToClientTransfer(transferData) {
     const {
       senderID,
@@ -147,9 +191,48 @@ class FileMessager {
       console.log(`[FileTide ~ File Messager] ~ File transfer completed: ${fileName} from ${senderID} to ${recipientId}`);
     }
   }
+  handleClientTransferBarrierResponse(data) {
+    console.log(`Checking ${data.recipientID}'s transfer barrier for transfer ~ ${data.transferID}...`);
+    const recipientConnectionID = FileNetClientManager.getOnlineClient(data.recipientID).id;
+    const senderConnectionID = FileNetClientManager.getOnlineClient(data.clientID).id;
+    const senderClient = this.getClientFromID(senderConnectionID);
+    const client = this.getClientFromID(recipientConnectionID);
+    if (!client || !senderClient) {
+      return;
+    }
+    this.fileNet.emitToTide(client.tideID, "queue-incoming-transfer", {
+      ...data,
+      transferType: "send"
+    });
+    this.transferQueue.waitForData(data.transferID, () => this.currentTransferBarrierTransfers.get(data.transferID), [true, false], 100, 50000).then(accepted => {
+      console.log(`Transfer ${accepted ? "accepted!" : "denied."}`);
+      this.fileNet.emitToTide(senderClient.tideID, "transfer-barrier-response", accepted);
+      this.currentTransferBarrierTransfers.delete(data.transferID);
+      if (accepted) {
+        this.fileNet.emitToTide(client.tideID, "accepted-transfer", {
+          accepted,
+          ...data
+        });
+        return;
+      }
+      this.fileNet.emitToTide(client.tideID, "denied-transfer", {
+        accepted,
+        ...data
+      });
+    }).catch(error => {
+      console.error(error.message);
+    });
+    return;
+  }
+  handleNotifyTransferBarrier(data, emitToChannel) {
+    const accepted = data.accepted;
+    const transferID = data.data.transferID;
+    this.currentTransferBarrierTransfers.set(transferID, accepted);
+  }
   handleFileTransferStart(data, emitToChannel) {
     console.log(`Alerting client of incoming transfer from ${data.senderID}...`);
-    const client = this.getClientFromID(data.recipientID);
+    const recipientConnectionID = FileNetClientManager.getOnlineClient(data.recipientID).id;
+    const client = this.getClientFromID(recipientConnectionID);
     if (!client) {
       return;
     }
@@ -175,11 +258,15 @@ class FileMessager {
     this.fileNet.emitToTide(connectionDetails.tideID, "current-online-clients", Object.fromEntries(FileNetClientManager.getOnlineClients()));
     return;
   }
-  handleClientOnline(clientID, tideID, pClientID, connectionID) {
+  handleClientOnline(clientID, tideID, pClientID, connectionID, activeTransferBarrier) {
     if (!this.onlineClients.has(connectionID)) {
       return;
     }
     FileNetClientManager.addOnlineClient(clientID, pClientID, tideID, connectionID);
+    this.clientTransferBarriers.set(tideID, {
+      clientID,
+      activeTransferBarrier
+    });
     this.fileNet.emitToTide(tideID, "current-online-clients", Object.fromEntries(FileNetClientManager.getOnlineClients()));
     return;
   }

package/dist/cjs/FileMessagerClient.js

@@ -30,6 +30,7 @@ class FileMessagerClient {
     this.progressBarManager = new ConsoleProgressBarManager([], {
       completionMessageColor: chalk.blue.bold
     });
+    this.activeTransferTypes = new Map();
     this.clientTide = new HUDIoTide();
     this.clients = new Map();
   }
@@ -52,15 +53,56 @@ class FileMessagerClient {
       });
     });
   }
-  requestTransfer(clientID, senderID, filePath, destinationPath) {
+  async requestTransfer(clientID, senderID, filePath, destinationPath, filterContent = []) {
+    const transferAllowed = await this.allowedTransfer(clientID, senderID, destinationPath, "N/A", "requestSend");
+    if (!transferAllowed) {
+      return;
+    }
     this.clientTide.emitEvent(clientID, "request-transfer-from-client", {
       requesterID: clientID,
       senderID,
       destinationPath,
+      filterContent,
       filePath
     });
     return;
   }
+  listFiles(clientID, recipientID, depth = 1) {
+    this.clientTide.emitEvent(clientID, "list-client-files", {
+      requesterID: clientID,
+      recipientID,
+      depth
+    });
+    return;
+  }
+  async allowedTransfer(clientID, recipientID, filePath, fileSize, transferType = "send") {
+    try {
+      const currentDate = Date.now();
+      const transferID = `${clientID}_${filePath}_${currentDate}`;
+      const transferAccepted = await this.clientTide.emitEventWithResponse(clientID, "get-client-transfer-barrier-response", "transfer-barrier-response", {
+        clientID,
+        recipientID,
+        transferID,
+        path: filePath,
+        date: currentDate,
+        transferType
+      }, 30000);
+      if (!transferAccepted) {
+        FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ${recipientID} denied your transfer.`, errorMessageColors);
+        return false;
+      } else if (transferAccepted) {
+        FileNetUtilityManager.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);
+        return false;
+      }
+      FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] Transfer approval refused.\n${error}`, errorMessageColors);
+      return false;
+    }
+  }
 
   /**
    * Sends all files in a directory in parallel using the sendFile method.
@@ -70,21 +112,33 @@ class FileMessagerClient {
    * @param {string} baseDirectory - The base directory path that contains the files.
    * @param {string} destinationPath - The path to which the files should be sent.
    */
-  sendDirectoryFiles(clientID, recipientId, filesData, baseDirectory, destinationPath) {
+  async sendDirectoryFiles(clientID, recipientId, filesData, baseDirectory, destinationPath) {
     try {
       const baseDirectoryName = path.basename(baseDirectory);
       const adjustedDestinationPath = FileUtilityManager.normalizePath(path.join(destinationPath, baseDirectoryName));
-      const sendFilePromises = filesData.map((fileInfo, index) => {
+      let totalSize = 0;
+      filesData.forEach(fileInfo => {
+        totalSize += fileInfo.size;
+      });
+      const incomingType = this.activeTransferTypes.get(destinationPath);
+      const transferAllowed = incomingType && incomingType === "requestedTransfer" ? true : await this.allowedTransfer(clientID, recipientId, adjustedDestinationPath, totalSize, "send");
+      if (incomingType) {
+        this.activeTransferTypes.delete(destinationPath);
+      }
+      if (!transferAllowed) {
+        return;
+      }
+      const sendFilePromises = filesData.map(async (fileInfo, index) => {
         const relativeFilePath = path.dirname(path.relative(baseDirectory, fileInfo.filePath));
         const fileDestinationPath = FileUtilityManager.normalizePath(path.join(adjustedDestinationPath, relativeFilePath));
-        return this.sendFile(clientID, recipientId, fileInfo.fileName, fileInfo.fileData, fileDestinationPath, fileInfo.size, adjustedDestinationPath, index);
+        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));
     } catch (error) {
       FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Refused directory transfer: ${error}`, errorMessageColors);
     }
   }
-  sendFile(clientID, recipientId, fileName, file, filePath = process.cwd(), fileSize, directoryPath = null, index = 0) {
+  sendDirectoryFile(clientID, recipientId, fileName, file, filePath = process.cwd(), fileSize, directoryPath = null, index = 0) {
     if (!file) {
       return;
     }
@@ -146,6 +200,76 @@ class FileMessagerClient {
       }
     }).then(() => FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ File ~ ${fileName} transfer complete!`, significantMessageColors)).catch(error => FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Refused file transfer: ${error}`, errorMessageColors));
   }
+  async sendFile(clientID, recipientId, fileName, file, filePath = process.cwd(), fileSize) {
+    if (!file) {
+      return;
+    }
+    const destinationPath = FileUtilityManager.normalizePath(path.join(filePath, fileName));
+    FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Requesting to transfer ~ ${destinationPath} to ${recipientId}!`, significantMessageColors);
+    const incomingType = this.activeTransferTypes.get(filePath);
+    const transferAllowed = incomingType && incomingType === "requestedTransfer" ? true : await this.allowedTransfer(clientID, recipientId, destinationPath, fileSize, "send");
+    if (incomingType) {
+      this.activeTransferTypes.delete(filePath);
+    }
+    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
+    });
+    this.transporter.sendFile(file, {
+      onSendChunk: (transferId, chunkIndex, 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,
+            recipientId,
+            fileName,
+            fileChunk: chunkData,
+            totalChunks,
+            chunkIndex,
+            filePath,
+            fileSize
+          });
+          resolve();
+        });
+      },
+      onComplete: () => {
+        return new Promise((resolve, reject) => {
+          this.clientTide.emitEvent(clientID, "transfer-complete", {
+            senderID: clientID,
+            recipientId,
+            fileName,
+            filePath
+          });
+          resolve();
+        });
+      },
+      onProgress: progress => {
+        this.progressBarManager.updateTaskProgress(fileName, 512 * 1024);
+      },
+      originDetails: {
+        recipientID: recipientId,
+        senderID: clientID
+      },
+      fileDetails: {
+        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));
+  }
 }
 ;
 module.exports = FileMessagerClient;

package/dist/cjs/FileTide.js

@@ -34,6 +34,7 @@ class FileTide {
       completionMessageColor: chalk.blue.bold
     });
     this.clientShorePolicies = new Map();
+    this.transferBarrier = false;
     this.clients = new Map();
     this.currentUserID = "";
     return;
@@ -65,34 +66,51 @@ class FileTide {
    * @param {String} roomName - The name of the room to join
    * @param {String} userID - The ID of the client user
    * @param {Function} onLaunch - Callback for when a file messager launches
+   * @param {Function} onIncomingFile - Callback for incoming files in transit
+   * @param {Function} onIncomingTransfer - Callback for incoming transfers
+   * @param {Function} onTransferBarrier - Callback for when an incoming transfer status updates
+   * @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
    */
-  launchMessager(clientOptions = {}, connectionOptions = {}, roomName, userID, onLaunch, onIncomingFile) {
+  launchMessager(clientOptions = {}, connectionOptions = {}, roomName, userID, onLaunch, onIncomingFile, onIncomingTransfer, onTransferBarrier, onTransferProgress, enableTransferBarrier = true, options = {}) {
     if (this.clients.has(userID)) {
       this.stopMessager(userID);
     }
     const newClient = new FileMessagerClient(clientOptions);
     newClient.joinRoom(userID, roomName, connectionOptions);
+    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, onIncomingFile);
+    _assertClassBrand(_FileTide_brand, this, _setupFileEventListeners).call(this, userID, newClient, onTransferProgress, onIncomingTransfer, onIncomingFile, onTransferBarrier, options);
     if (onLaunch) {
       onLaunch(newClient);
     }
     return;
   }
-  getDirectoryData(directoryPath) {
-    return FileUtilityManager.getDirectoryData(directoryPath);
+  async getDirectoryData(directoryPath) {
+    return await FileUtilityManager.getDirectoryData(directoryPath);
   }
   getFileData(filePath) {
     return FileUtilityManager.getFileData(filePath);
   }
-  getPathData(inputPath) {
-    return FileUtilityManager.getPathData(inputPath);
+  async getPathData(inputPath, filterContent = []) {
+    return await FileUtilityManager.getPathData(inputPath, filterContent);
   }
   getTidePath(inputPath) {
     return FileUtilityManager.getTidePath(inputPath);
   }
+  filterFilesAndDirectories(dirPath, filterContent = [], callback) {
+    FileUtilityManager.filterFilesAndDirectories(dirPath, filterContent, (files, error) => {
+      if (callback) {
+        callback(files, error);
+      }
+    });
+  }
+  async listFiles(directories, depth = 1) {
+    return await FileUtilityManager.listFiles(directories, depth);
+  }
   clearShorePolicies(clientID, shores = []) {
     let clientShorePolicies = this.clientShorePolicies.get(clientID);
     if (!shores || shores.length <= 0 || !clientShorePolicies || !clientID) {
@@ -122,15 +140,16 @@ class FileTide {
    * @param {String} recipientID - The ID of the client device to send the data to
    * @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
    */
-  sendToDevice(recipientID, filePath, destinationPath) {
-    const fileDetails = this.getPathData(filePath);
+  async sendToDevice(recipientID, filePath, destinationPath, filterDirectoryContent = []) {
     const clientID = this.currentUserID;
     const clientMessager = this.clients.get(clientID);
     if (!clientMessager) {
       FileTide.outputGradient(`[FileTide] Client ~ ${clientID} not found.`, ["#F94144", "#F3722C"]);
       return;
     }
+    const fileDetails = await this.getPathData(filePath, filterDirectoryContent);
     if (!fileDetails) {
       FileTide.outputGradient(`[${clientID}] File at path ${filePath} not found.`, ["#F94144", "#F3722C"]);
       return;
@@ -203,7 +222,14 @@ class FileTide {
   }
 }
 _FileTide = FileTide;
-function _setupFileEventListeners(userID, client, onIncomingFile) {
+function _setupFileEventListeners(userID, client, onTransferProgress, onIncomingTransfer, onIncomingFile, onTransferBarrier, options = {}) {
+  const {
+    onTransferStart,
+    onTransferComplete,
+    onTransferRequested,
+    onListFiles,
+    onCurrentOnlineClients
+  } = options;
   const cliTable = new ConsoleTable({
     padding: 2,
     headerAlign: "center",
@@ -244,10 +270,33 @@ function _setupFileEventListeners(userID, client, onIncomingFile) {
     cliTable.setTitle(`✨ Online >${Object.keys(currentClients).length}< ✨`, 1);
     cliTable.setData(currentClients);
     console.log(`\n[FileTide ~ FileNet]\n\n`, cliTable.render(), "\n");
+    if (onCurrentOnlineClients) {
+      onCurrentOnlineClients(currentClients);
+    }
+  });
+  client.clientTide.onEvent(userID, "queue-incoming-transfer", async data => {
+    if (this.transferBarrier && onIncomingTransfer) {
+      onIncomingTransfer(data, status => {
+        client.clientTide.emitEvent(userID, "notify-transfer-barrier", {
+          accepted: status,
+          data
+        });
+      });
+      return;
+    } else if (!this.transferBarrier) {
+      client.clientTide.emitEvent(userID, "notify-transfer-barrier", {
+        accepted: true,
+        data
+      });
+    }
+    return;
   });
-  client.clientTide.onEvent(userID, "incoming-transfer", data => {
+  client.clientTide.onEvent(userID, "incoming-transfer", async data => {
     _FileTide.outputGradient(`[${userID}] Preparing to receive transfer : ${FileUtilityManager.getTidePath(data.path)}`, significantMessageColors);
-    this.progressBarManager.completionMessage = `Successfully received transfer from ${recipientId}!`;
+    if (onTransferStart) {
+      onTransferStart(data);
+    }
+    this.progressBarManager.completionMessage = `Successfully received transfer from ${data.senderID}!`;
     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);
   });
@@ -260,11 +309,17 @@ function _setupFileEventListeners(userID, client, onIncomingFile) {
         fileInfo: data
       });
       const saveDir = FileUtilityManager.getTidePath(data.path);
-      if (data.senderID && data.senderID !== userID && !fs.existsSync(saveDir)) {
+      const verifiedSender = data.senderID && data.senderID !== userID;
+      if (verifiedSender) {
         this.progressBarManager.addTask({
           name: data.fileName,
           size: data.fileSize
         });
+      }
+      if (onIncomingFile) {
+        onIncomingFile(verifiedSender, data, activeTransfers);
+      }
+      if (verifiedSender && !fs.existsSync(saveDir)) {
         fs.mkdirSync(saveDir, {
           recursive: true
         });
@@ -274,6 +329,18 @@ function _setupFileEventListeners(userID, client, onIncomingFile) {
       _FileTide.outputGradient(`[${userID}] Halted file recieval preparation : ${data.fileName}\n${error}`, errorMessageColors);
     }
   });
+  client.clientTide.onEvent(userID, "accepted-transfer", async data => {
+    _FileTide.outputGradient(`[${userID}] Accepted ${data.clientID}'s transfer!`, significantMessageColors);
+    if (onTransferBarrier) {
+      onTransferBarrier(data);
+    }
+  });
+  client.clientTide.onEvent(userID, "denied-transfer", async data => {
+    _FileTide.outputGradient(`[${userID}] Denied ${data.clientID}'s transfer.`, errorMessageColors);
+    if (onTransferBarrier) {
+      onTransferBarrier(data);
+    }
+  });
   client.clientTide.onEvent(userID, "transfer-progress", data => {
     if (!data || data.fileChunk === undefined || data.fileChunk === null) {
       return;
@@ -285,8 +352,8 @@ function _setupFileEventListeners(userID, client, onIncomingFile) {
     transferState.receivedChunks[data.chunkIndex] = Buffer.from(data.fileChunk);
     const progress = (data.chunkIndex + 1) / transferState.totalChunks * 100;
     this.progressBarManager.updateTaskProgress(data.fileName, 512 * 1024);
-    if (onIncomingFile) {
-      onIncomingFile(data);
+    if (onTransferProgress) {
+      onTransferProgress(data);
     }
   });
   client.clientTide.onEvent(userID, "transfer-complete", data => {
@@ -301,14 +368,41 @@ function _setupFileEventListeners(userID, client, onIncomingFile) {
       fs.writeFileSync(savePath, fullFile);
       _FileTide.outputGradient(`[${userID}] File saved at : ${savePath}`, significantMessageColors);
       activeTransfers.delete(data.fileName);
+      if (onTransferComplete) {
+        onTransferComplete(data, activeTransfers, true);
+      }
     } catch (error) {
       _FileTide.outputGradient(`[${userID}] Did not save file at : ${savePath}\n${error}`, errorMessageColors);
       activeTransfers.delete(data.fileName);
+      if (onTransferComplete) {
+        onTransferComplete(data, activeTransfers, false);
+      }
     }
   });
-  client.clientTide.onEvent(userID, "transfer-requested", data => {
+  client.clientTide.onEvent(userID, "transfer-requested", async data => {
     _FileTide.outputGradient(`[${userID}] Transfer requested from: ${data.requesterID}`, significantMessageColors);
-    this.sendToDevice(data.requesterID, data.path, data.destinationPath);
+    this.clients.get(userID).activeTransferTypes.set(data.destinationPath, data.type);
+    if (onTransferRequested) {
+      onTransferRequested(data);
+    }
+    await this.sendToDevice(data.requesterID, data.path, data.destinationPath, data.filterContent || []);
+    return;
+  });
+  client.clientTide.onEvent(userID, "list-files", async data => {
+    _FileTide.outputGradient(`[${userID}] Sending file list!`, 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
+    });
+  });
+  client.clientTide.onEvent(userID, "client-file-list", async data => {
+    _FileTide.outputGradient(`[${userID}] Listed ${data.senderID}'s files!`, significantMessageColors);
+    if (onListFiles) {
+      onListFiles(data);
+    }
   });
   this.currentUserID = userID;
   return;

package/dist/cjs/HUDManagers/FileUtilityManager.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const path = require("path");
+const fsAsync = require("fs").promises;
 const fs = require("fs");
 const os = require("os");
 const filesPath = path.join(__dirname, "../files");
@@ -27,46 +28,169 @@ class FileUtilityManager {
 
   /**
    * Function to filter files and directories.
-   * @param {string} dirPath - The directory path to scan
-   * @param {Array} filterContent - Array of paths (files, directories, extensions) to avoid (e.g., ['docs', 'example.txt', '.js'])
-   * @param {function} callback - A callback function to handle the results
+   * @param {string} dirPath - The directory path to scan.
+   * @param {Array} filterContent - Array of paths (files, directories, extensions) to avoid (e.g., ['docs', 'example.txt', '.js']).
+   * @returns {Promise<Array>} - A promise that resolves to an array of objects containing details about filtered files and directories.
    */
-  static filterFilesAndDirectories(dirPath, filterContent = [], callback) {
-    fs.readdir(dirPath, {
-      withFileTypes: true
-    }, (error, items) => {
-      if (error) {
-        return callback(error);
-      }
+  static async filterFilesAndDirectories(dirPath, filterContent = []) {
+    try {
+      const currentDirPath = this.getTidePath(dirPath);
+      const items = await fs.promises.readdir(currentDirPath, {
+        withFileTypes: true
+      });
       const results = [];
-      items.forEach(item => {
-        const itemPath = path.join(dirPath, item.name);
+      for (const item of items) {
+        const itemPath = path.join(currentDirPath, item.name);
         const filtered = filterContent.some(filterEntry => {
-          const resolvedFilterEntry = path.resolve(filterEntry);
+          const resolvedFilterEntry = path.resolve(currentDirPath, filterEntry);
           const fileExtension = filterEntry.startsWith(".");
           return itemPath === resolvedFilterEntry || item.name === filterEntry || fileExtension && path.extname(item.name) === filterEntry;
         });
         if (!filtered) {
-          fs.stat(itemPath, (error, stats) => {
-            if (error) {
-              return callback(error);
-            }
-            results.push({
-              dateCreated: stats.birthtime,
-              type: item.isDirectory() ? "directory" : "file",
-              size: stats.size,
-              name: item.name,
-              path: itemPath
-            });
-            if (results.length === items.length) {
-              callback(null, results);
-            }
+          const stats = await fs.promises.stat(itemPath);
+          results.push({
+            type: item.isDirectory() ? "directory" : "file",
+            dateCreated: stats.birthtime,
+            size: stats.size,
+            name: item.name,
+            path: itemPath
           });
-        } else if (results.length === items.length) {
-          callback(null, results);
         }
-      });
+      }
+      return results;
+    } catch (error) {
+      console.error("Did not read directory: ", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Function to list all paths across the system using wildcard '*'.
+   * @param {number} depth - The maximum depth limit (from the root). Defaults to 1.
+   * @returns {Promise<Array>} - A promise that resolves to an array of file and directory metadata across the system.
+   */
+  static async listAllPathsInOS(depth = 1) {
+    const rootPaths = ["/", "C:/"];
+    let allResults = [];
+    const rootPromises = rootPaths.map(async rootPath => {
+      if (await this.exists(rootPath)) {
+        const subResult = await this.listPaths(rootPath, depth);
+        allResults.push(...subResult.results);
+      }
+    });
+    await Promise.all(rootPromises);
+    return allResults;
+  }
+
+  /**
+    * Function to list all paths and their metadata recursively.
+    * @param {string} dir - The directory path to scan.
+    * @param {number} maxDepth - The maximum depth limit (from the root). Defaults to 1.
+    * @param {number} currentDepth - The current depth level. Starts at 0 (for the root).
+    * @returns {Promise<object>} - A promise that resolves to an object containing a list of files/directories with metadata.
+    */
+  static async listPaths(dir, maxDepth = 1, currentDepth = 0) {
+    let results = [];
+    if (!maxDepth || currentDepth === undefined || currentDepth === null || currentDepth > maxDepth) {
+      return {
+        totalItems: 0,
+        totalSize: 0,
+        results
+      };
+    }
+    const list = await fsAsync.readdir(dir, {
+      withFileTypes: true
+    });
+    const stats = await fsAsync.stat(dir);
+    const dirMetadata = {
+      totalItems: 0,
+      totalSize: 0,
+      createdTime: stats.birthtime,
+      lastModified: stats.mtime,
+      type: "directory",
+      path: dir
+    };
+    results.push(dirMetadata);
+    const promises = list.map(async file => {
+      const filePath = this.getTidePath(path.join(dir, file.name));
+      try {
+        if (file.isDirectory()) {
+          const subDirResult = await this.listPaths(filePath, maxDepth, currentDepth + 1);
+          dirMetadata.totalItems += subDirResult.totalItems;
+          dirMetadata.totalSize += subDirResult.totalSize;
+          results.push(...subDirResult.results);
+        } else {
+          const fileStats = await fsAsync.stat(filePath);
+          const fileMetadata = {
+            createdTime: fileStats.birthtime,
+            lastModified: fileStats.mtime,
+            size: fileStats.size,
+            path: filePath,
+            type: "file"
+          };
+          dirMetadata.totalSize += fileStats.size;
+          dirMetadata.totalItems += 1;
+          results.push(fileMetadata);
+        }
+      } catch (error) {
+        console.log(`[FileTide] Path not found: ${filePath}`);
+      }
     });
+    await Promise.all(promises);
+    return {
+      totalItems: dirMetadata.totalItems,
+      totalSize: dirMetadata.totalSize,
+      results
+    };
+  }
+
+  /**
+   * Allows for listing files in a specific directory or all files in the system '*'.
+   * @param {Array} directories - Array of directories to scan or '*' for entire system.
+   * @param {number} depth - The maximum depth limit (from the root). Defaults to 1.
+   * @returns {Promise<Array>} - A promise that resolves to an array of file and directory metadata from specified directories or the entire system.
+   */
+  static async listFiles(directories, depth = 1) {
+    let fileList = [];
+    if (directories.includes("*")) {
+      fileList = await this.listAllPathsInOS(depth);
+    } else {
+      const dirPromises = directories.map(async dir => {
+        const currentDir = this.getTidePath(dir);
+        if (await this.exists(currentDir)) {
+          const subResult = await this.listPaths(currentDir, depth);
+          fileList.push(...subResult.results);
+        } else {
+          console.warn(`Directory does not exist: ${currentDir}`);
+        }
+      });
+      await Promise.all(dirPromises);
+    }
+    return fileList;
+  }
+
+  /**
+   * Checks the path's type.
+   * @param {string} inputPath - The path to check.
+   * @returns {Promise<boolean>} - Returns a promise that resolves to true if a directory, false otherwise.
+   */
+  static async directoryPath(inputPath) {
+    const stats = await fsAsync.stat(inputPath);
+    return stats.isDirectory();
+  }
+
+  /**
+   * Helper function to check if a path exists.
+   * @param {string} inputPath - The path to check.
+   * @returns {Promise<boolean>} - Returns a promise that resolves to true if the path exists, false otherwise.
+   */
+  static async exists(inputPath) {
+    try {
+      await fsAsync.access(inputPath);
+      return true;
+    } catch (e) {
+      return false;
+    }
   }
 
   /**
@@ -153,31 +277,31 @@ class FileUtilityManager {
   /**
    * Gets all files' data from a given directory.
    * @param {string} dirPath - The path to the directory.
+   * @param {Array} filterContent - The paths to filter from the directory.
    * @returns {Array} - An array of objects containing file data, name, and path.
    */
-  static getDirectoryData(inputDirPath) {
+  static async getDirectoryData(inputDirPath, filterContent = []) {
     const dirPath = this.getTidePath(inputDirPath);
     if (!fs.existsSync(dirPath)) {
       console.log(`Directory at path ${dirPath} not found.`);
       return [];
     }
     const filesData = [];
-    function readDirectory(currentPath) {
-      const fileList = fs.readdirSync(currentPath);
-      fileList.forEach(file => {
-        const filePath = FileUtilityManager.normalizePath(path.join(currentPath, file));
-        const stats = fs.statSync(filePath);
+    async function readDirectory(currentPath) {
+      const files = await FileUtilityManager.filterFilesAndDirectories(currentPath, filterContent);
+      for (const file of files) {
+        const stats = await fs.promises.stat(file.path);
         if (stats.isFile()) {
-          const fileData = FileUtilityManager.getFileData(filePath);
+          const fileData = FileUtilityManager.getFileData(file.path);
           if (fileData) {
             filesData.push(fileData);
           }
         } else if (stats.isDirectory()) {
-          readDirectory(filePath);
+          await readDirectory(file.path);
         }
-      });
+      }
     }
-    readDirectory(dirPath);
+    await readDirectory(dirPath);
     return filesData;
   }
 
@@ -207,9 +331,10 @@ class FileUtilityManager {
   /**
    * Gets data from a file or directory based on the provided path.
    * @param {string} inputPath - The path to a file or directory.
+   * @param {Array} filterContent - The paths to filter from the directory if getting a directory.
    * @returns {Object|Array|null} - File data if it's a file, an array of file data if it's a directory, or null if the path doesn't exist.
    */
-  static getPathData(inputPath) {
+  static async getPathData(inputPath, filterContent = []) {
     const currentInputPath = this.getTidePath(inputPath);
     if (!fs.existsSync(currentInputPath)) {
       console.log(`Path at ${currentInputPath} not found.`);
@@ -223,7 +348,7 @@ class FileUtilityManager {
       };
     } else if (stats.isDirectory()) {
       return {
-        content: this.getDirectoryData(currentInputPath),
+        content: await this.getDirectoryData(currentInputPath, filterContent),
         type: "directory"
       };
     }

package/dist/cjs/HUDManagers/HUDTargetQueueManager.js

@@ -0,0 +1,72 @@
+"use strict";
+
+class HUDTargetQueue {
+  constructor() {
+    this.queues = new Map();
+  }
+
+  /**
+   * Adds a function to the queue for a specific ID and target value.
+   * @param {string} id - A unique identifier for the value being watched.
+   * @param {function} fn - The function to execute when the target value is reached.
+   */
+  enqueue(id, fn) {
+    if (!this.queues.has(id)) {
+      this.queues.set(id, []);
+    }
+    this.queues.get(id).push(fn);
+  }
+
+  /**
+   * Waits for a value to change to the target value and executes only the functions
+   * in the queue associated with the specific ID.
+   * @param {string} id - A unique identifier for the value being watched.
+   * @param {function} getValue - A function that returns the current value.
+   * @param {any|array} targetValues - The value(s) to wait for.
+   * @param {number} interval - The interval (in milliseconds) to check the value.
+   * @param {number} [timeout] - Optional. The maximum time (in milliseconds) to wait before rejecting.
+   * @returns {Promise} - Resolves when the value matches the target value, executes queued functions.
+   */
+  waitForData(id, getValue, targetValues, interval = 100, timeout) {
+    return new Promise((resolve, reject) => {
+      let elapsedTime = 0;
+      const targets = Array.isArray(targetValues) ? targetValues : [targetValues];
+      const checkData = async () => {
+        const currentValue = await getValue();
+        if (typeof currentValue === "object" && targets.some(target => typeof target === "object")) {
+          if (targets.some(target => JSON.stringify(currentValue) === JSON.stringify(target))) {
+            this.executeQueue(id);
+            resolve(currentValue);
+          }
+        } else if (targets.includes(currentValue)) {
+          this.executeQueue(id);
+          resolve(currentValue);
+        } else if (timeout && elapsedTime >= timeout) {
+          reject(new Error(`Timeout: Value did not reach target within ${timeout}ms`));
+        } else {
+          elapsedTime += interval;
+          setTimeout(checkData, interval);
+        }
+      };
+      checkData();
+    });
+  }
+
+  /**
+   * Executes all functions in the queue associated with the specific ID.
+   * @param {string} id - A unique identifier for the value being watched.
+   */
+  executeQueue(id) {
+    const queue = this.queues.get(id);
+    if (queue) {
+      while (queue.length > 0) {
+        const fn = queue.shift();
+        if (typeof fn === "function") {
+          fn();
+        }
+      }
+      this.queues.delete(id);
+    }
+  }
+}
+module.exports = HUDTargetQueue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trap_stevo/filetide",
-  "version": "0.0.32",
+  "version": "0.0.34",
   "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": {
@@ -27,10 +27,10 @@
     "seamless connectivity"
   ],
   "author": "Steven Compton",
-  "license": "ISC",
+  "license": "See License in LICENSE.md",
   "dependencies": {
     "@trap_stevo/iotide": "^0.0.37",
-    "@trap_stevo/iotide-client": "^0.0.15",
+    "@trap_stevo/iotide-client": "^0.0.20",
     "@trap_stevo/legendarybuilderpronodejs-utilities": "^1.0.40",
     "chalk": "^4.1.2",
     "readline": "^1.3.0"