@trap_stevo/filetide 0.0.32 → 0.0.33

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,8 @@ 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("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 +69,8 @@ class FileMessager {
       senderID,
       requesterID,
       path: filePath,
-      destinationPath
+      destinationPath,
+      type: "requestedTransfer"
     });
   }
 
@@ -147,9 +154,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 +221,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,7 +53,11 @@ class FileMessagerClient {
       });
     });
   }
-  requestTransfer(clientID, senderID, filePath, destinationPath) {
+  async requestTransfer(clientID, senderID, filePath, destinationPath) {
+    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,
@@ -61,6 +66,34 @@ class FileMessagerClient {
     });
     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 +103,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 +191,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,47 @@ 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} onIncomingTransfer - Callback for incoming transfers
+   * @param {Function} onTransferBarrier - Callback for when an incoming transfer status updates
    */
-  launchMessager(clientOptions = {}, connectionOptions = {}, roomName, userID, onLaunch, onIncomingFile) {
+  launchMessager(clientOptions = {}, connectionOptions = {}, roomName, userID, onLaunch, onIncomingFile, onIncomingTransfer, onTransferBarrier, enableTransferBarrier = true) {
     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, onIncomingFile, onIncomingTransfer, onTransferBarrier);
     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) {
+    return await FileUtilityManager.listFiles(directories);
+  }
   clearShorePolicies(clientID, shores = []) {
     let clientShorePolicies = this.clientShorePolicies.get(clientID);
     if (!shores || shores.length <= 0 || !clientShorePolicies || !clientID) {
@@ -122,15 +136,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 +218,7 @@ class FileTide {
   }
 }
 _FileTide = FileTide;
-function _setupFileEventListeners(userID, client, onIncomingFile) {
+function _setupFileEventListeners(userID, client, onIncomingFile, onIncomingTransfer, onTransferBarrier) {
   const cliTable = new ConsoleTable({
     padding: 2,
     headerAlign: "center",
@@ -245,9 +260,26 @@ function _setupFileEventListeners(userID, client, onIncomingFile) {
     cliTable.setData(currentClients);
     console.log(`\n[FileTide ~ FileNet]\n\n`, cliTable.render(), "\n");
   });
-  client.clientTide.onEvent(userID, "incoming-transfer", data => {
+  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", async data => {
     _FileTide.outputGradient(`[${userID}] Preparing to receive transfer : ${FileUtilityManager.getTidePath(data.path)}`, significantMessageColors);
-    this.progressBarManager.completionMessage = `Successfully received transfer from ${recipientId}!`;
+    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 +292,14 @@ 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 (verifiedSender && !fs.existsSync(saveDir)) {
         fs.mkdirSync(saveDir, {
           recursive: true
         });
@@ -274,6 +309,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;
@@ -306,9 +353,11 @@ function _setupFileEventListeners(userID, client, onIncomingFile) {
       activeTransfers.delete(data.fileName);
     }
   });
-  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);
+    await this.sendToDevice(data.requesterID, data.path, data.destinationPath);
+    return;
   });
   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,154 @@ 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 '*'.
+   * @returns {Promise<Array>} - A promise that resolves to an array of file and directory metadata across the system.
+   */
+  static async listAllPathsInOS() {
+    const rootPaths = ["/", "C:/"];
+    let allResults = [];
+    const rootPromises = rootPaths.map(async rootPath => {
+      if (await this.exists(rootPath)) {
+        const subResult = await this.listPaths(rootPath);
+        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.
+    * @returns {Promise<object>} - A promise that resolves to an object containing a list of files/directories with metadata.
+    */
+  static async listPaths(dir) {
+    let 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));
+      if (file.isDirectory()) {
+        const subDirResult = await this.listPaths(filePath);
+        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);
+      }
+    });
+    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.
+   * @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) {
+    let fileList = [];
+    if (directories.includes("*")) {
+      fileList = await this.listAllPathsInOS();
+    } else {
+      const dirPromises = directories.map(async dir => {
+        const currentDir = this.getTidePath(dir);
+        if (await this.exists(currentDir)) {
+          const subResult = await this.listPaths(currentDir);
+          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 +262,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 +316,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 +333,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.33",
   "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": {
@@ -30,7 +30,7 @@
   "license": "ISC",
   "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"