@trap_stevo/filetide 0.0.85 → 0.0.86

package/dist/cjs/FileTide.js

@@ -17,7 +17,8 @@ require("./HUDComponents/FileTidePathsConfigurations.js");
 const {
   FileTideDebugUtilityManager,
   significantMessageColors,
-  errorMessageColors
+  errorMessageColors,
+  debugMessageColors
 } = require("./HUDManagers/FileTideDebugUtilityManager.js");
 const {
   displayFileTideAuthor,
@@ -34,11 +35,13 @@ const TideTokenEnforcer = require("./HUDManagers/TideTokenEnforcementManager.js"
 const {
   FileUtilityManager
 } = require("./HUDManagers/FileUtilityManager.js");
-const ConsoleProgressBarManager = require("./HUDComponents/ConsoleProgressBarManager.js");
+const {
+  FileTransferStatsManager
+} = require("./HUDManagers/FileTransferStatsManager.js");
 const ChunkCapacitor = require("./HUDComponents/ChunkCapacitor.js");
 const ConsoleTable = require("./HUDComponents/ConsoleTable.js");
 const FileMessagerClient = require("./FileMessagerClient.js");
-const FileMessager = require("./FileMessager.js");
+const FileTideAnchor = require("./FileTideAnchor.js");
 var _FileTide_brand = /*#__PURE__*/new WeakSet();
 class FileTide {
   constructor(debugMode = true) {
@@ -48,9 +51,7 @@ class FileTide {
      * Automatically checks and creates directories as needed.
      */
     _classPrivateMethodInitSpec(this, _FileTide_brand);
-    this.progressBarManager = new ConsoleProgressBarManager([], {
-      completionMessageColor: chalk.blue.bold
-    });
+    this.transferStatsManager = new FileTransferStatsManager();
     this.clientShorePolicies = new Map();
     this.transferBarrier = false;
     this.clientDetails = new Map();
@@ -81,28 +82,28 @@ class FileTide {
     return TideTokenEnforcer.getKey(scope);
   }
 
-  // --- FileTide Gateway Management ---
+  // --- FileTide Anchor Management ---
 
   /**
-   * Initialize and start the server.
+   * Initialize and start the Anchor (coordination server).
    * @param {Object} serverOptions - Configuration for server (e.g., port, useCors, useHTTPS)
    * @param {Function} onLaunch - Callback for when a file tide instance launches
    * @param {...any} tideConfigurations - Additional configuration objects for customizing FileTide behavior
    */
   launchFileTide(serverOptions = {}, onLaunch, ...tideConfigurations) {
     TideTokenEnforcer.protect(() => {
-      this.fileNet = new FileMessager(serverOptions, ...tideConfigurations);
-      this.fileNet.start();
-      FileTide.outputGradient("[FileTide] ~ FileNet launched successfully!", significantMessageColors);
+      this.anchor = new FileTideAnchor(serverOptions, ...tideConfigurations);
+      this.anchor.start();
+      FileTide.outputGradient("[FileTide] ~ Anchor launched successfully!", significantMessageColors);
       if (onLaunch) {
-        onLaunch(this.fileNet);
+        onLaunch(this.anchor);
       }
     }, "default")();
     return;
   }
 
   /**
-   * Initialize and start a new client for each user.
+   * Initialize and start a new client for each Tider (user).
    * @param {Object} clientOptions - Configuration for client (e.g., serverUrl)
    * @param {Object} connectionOptions - Configuration for the client connection
    * @param {Object} transportOptions - Configuration for the file transporter
@@ -115,7 +116,7 @@ class FileTide {
    * @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
+   * @param {Object} [options = {}] - Additional options including transfer lifecycle callbacks such as onTransferStart, onTransferComplete, and onTransferFailure.
    * @param {Object} [headers = {}] - Additional connection headers
    * @param {Function} onConnect - Callback for when the client connects to the desired server
    * @param {Function} onDisconnect - Callback for when the client disconnects from the desired server
@@ -141,7 +142,7 @@ class FileTide {
         const {
           onCurrentClientUnauthorized
         } = options;
-        FileTide.outputGradient(`[FileTide ~ FileNet] ~ Unauthorized access detected.`, errorMessageColors);
+        FileTide.outputGradient(`[FileTide ~ Anchor] ~ Unauthorized access detected.`, errorMessageColors);
         if (onCurrentClientUnauthorized) {
           onCurrentClientUnauthorized({
             ...currentClientDetails,
@@ -195,6 +196,13 @@ class FileTide {
 
   // --- FileTide Transfer State Management ---
 
+  getTransferStats(transferID) {
+    return this.transferStatsManager.getTransferStats(transferID);
+  }
+  getTransferStatsOverview() {
+    return this.transferStatsManager.getTransfers();
+  }
+
   // --- FileTide Remote Files Management ---
 
   listFilesFromClient(recipientID, depth = 1) {
@@ -315,7 +323,7 @@ class FileTide {
    * @returns {Boolean} - True if server running
    */
   async fileTideOperational() {
-    return await TideTokenEnforcer.protect(() => this.fileNet !== null, "default")();
+    return await TideTokenEnforcer.protect(() => this.anchor !== null, "default")();
   }
 
   /**
@@ -333,10 +341,10 @@ class FileTide {
    */
   stopFileTide() {
     TideTokenEnforcer.protect(() => {
-      if (this.fileNet) {
+      if (this.anchor) {
         FileTide.outputGradient("Stopping FileTide...", significantMessageColors);
-        this.fileNet.close();
-        this.fileNet = null;
+        this.anchor.close();
+        this.anchor = null;
         FileTide.outputGradient("Stopped FileTide.", significantMessageColors);
       }
     }, "default")();
@@ -446,6 +454,7 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
   const {
     onTransferStart,
     onTransferComplete,
+    onTransferFailure,
     onTransferRequested,
     onTransferStatus,
     onListFiles,
@@ -518,6 +527,28 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
       onClientTiding(data.message, significantMessageColors);
     }
   });
+  client.clientTide.onEvent(userID, "tide-network-sample", data => {
+    const throughputBps = Number(data?.throughputBps);
+    if (!Number.isFinite(throughputBps) || throughputBps <= 0) {
+      return;
+    }
+    const networkStatus = client.recordNetworkThroughput(throughputBps);
+    if (this.inDebugMode) {
+      const sampleDetails = JSON.stringify({
+        state: networkStatus.state,
+        bandwidthBps: networkStatus.bandwidthBps,
+        deliveredThroughputBps: networkStatus.deliveredThroughputBps,
+        sendRateBps: networkStatus.sendRateBps,
+        throughputRatio: networkStatus.throughputRatio,
+        latencyMs: networkStatus.latencyMs,
+        failureRate: networkStatus.failureRate,
+        retryRate: networkStatus.retryRate,
+        recommendedChunkSize: networkStatus.recommendedChunkSize,
+        sampleCount: networkStatus.sampleCount
+      }, null, 5);
+      _FileTide.outputGradient(`[FileTide ~ Network Traffic] ${sampleDetails}`, debugMessageColors);
+    }
+  });
   client.clientTide.onEvent(userID, "current-clients", data => {
     const currentClients = {};
     Object.keys(data).forEach(key => {
@@ -538,7 +569,7 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
     if (userID === clientID) {
       return;
     }
-    _FileTide.outputGradient(`[FileTide ~ FileNet] ~ Client ~ ${userID} already online.`, significantMessageColors);
+    _FileTide.outputGradient(`[FileTide ~ Anchor] ~ Client ~ ${userID} already online.`, significantMessageColors);
     if (onCurrentClientIDAlreadyOnline) {
       onCurrentClientIDAlreadyOnline(clientID);
     }
@@ -552,7 +583,7 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
     if (!bannedDetails.banned) {
       return;
     }
-    _FileTide.outputGradient(`[FileTide ~ FileNet] ~ Unauthorized access detected.`, errorMessageColors);
+    _FileTide.outputGradient(`[FileTide ~ Anchor] ~ Unauthorized access detected.`, errorMessageColors);
     await this.stopAllMessagers(onBeforeCurrentClientUnauthorizedDisconnect, onCurrentClientUnauthorizedDisconnect, async () => {
       if (onCurrentClientUnauthorized) {
         onCurrentClientUnauthorized(bannedDetails);
@@ -583,18 +614,12 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
     } = data;
     if (currentSender && currentSender === userID) {
       _FileTide.outputGradient(`[${userID}] Transfer successfully sent to ${data.recipientID}`, significantMessageColors);
-      this.progressBarManager.completionMessage = `Successfully sent to ${data.recipientID}!`;
-      this.progressBarManager.displayPage("Page Number:", "Press 'n' for next page, 'p' for previous page.", chalk.blue, chalk.magenta);
-      this.progressBarManager.listenForInput("Page Number:", "Press 'n' for next page, 'p' for previous page.", chalk.blue, chalk.magenta, chalk.yellow);
       return;
     }
     _FileTide.outputGradient(`[${userID}] Preparing to receive transfer : ${FileUtilityManager.getTidePath(data.path)}`, significantMessageColors);
     if (onTransferStart) {
       onTransferStart(data);
     }
-    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);
   });
   client.clientTide.onEvent(userID, "incoming-file", async data => {
     try {
@@ -603,16 +628,13 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
       const saveDir = FileUtilityManager.getTidePath(data.path);
       const verifiedSender = data.senderID && data.senderID !== userID;
       if (verifiedSender) {
-        this.progressBarManager.addTask({
-          name: data.fileName,
-          size: data.fileSize
-        });
+        this.transferStatsManager.startTransfer(data, "receiving");
       }
       if (onIncomingFile) {
-        const taskBarStats = this.progressBarManager.getTaskBar(data.fileName);
+        const transferStats = this.transferStatsManager.getTransferStats(data.transferId || data.fileName);
         onIncomingFile(verifiedSender, {
           ...data,
-          stats: taskBarStats
+          stats: transferStats
         }, FileTransferTrackingManager.activeTransfers);
       }
       if (verifiedSender && !fs.existsSync(saveDir)) {
@@ -638,53 +660,91 @@ 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}`);
+    const tide = data?.tide;
+    if (!tide || !Array.isArray(tide.chunks) || tide.chunks.length <= 0) {
+      FileTideDebugUtilityManager.log("notice", true, `Received invalid Tide from ~ ${tide?.senderID || data?.senderName || "unknown"} in transfer progress ~ ${tide?.fileName || data?.fileName || "unknown"}`);
       FileTransferTrackingManager.outputCurrentTransfers();
       return;
     }
-    await fileTransferReceiver.handleTransferProgress(data);
-    this.progressBarManager.updateTaskProgress(data.fileName, data.chunkSize || 512 * 1024);
-    const taskBarStats = this.progressBarManager.getTaskBar(data.fileName);
-    client.clientTide.emitEvent(userID, "acknowledge-transfer-tide", {
-      fileName: data.fileName,
-      senderName: data.senderName,
-      recipientName: userID,
-      transferStateID: `${data.path}-${data.fileName}`,
-      path: data.path,
-      transferStats: taskBarStats,
-      metadata: data.metadata
-    });
-    if (onTransferProgress) {
-      onTransferProgress({
-        ...data,
-        stats: taskBarStats,
-        metadata: data.metadata
+    try {
+      const tideState = await fileTransferReceiver.handleTransferTide(tide);
+      let transferStats = this.transferStatsManager.getTransferStats(tide.transferId || tide.fileName);
+      if (!transferStats) {
+        this.transferStatsManager.startTransfer({
+          transferId: tide.transferId,
+          fileName: tide.fileName,
+          fileSize: tide.fileSize,
+          senderID: tide.senderID,
+          recipientId: tide.recipientId
+        }, "receiving");
+      }
+      transferStats = this.transferStatsManager.updateTransfer(tide.transferId || tide.fileName, tideState.tideBytes);
+      client.clientTide.emitEvent(userID, "acknowledge-transfer-tide", {
+        transferId: tide.transferId,
+        fileName: tide.fileName,
+        senderName: tide.senderID,
+        recipientName: userID,
+        transferStateID: `${tide.filePath}-${tide.fileName}`,
+        path: tide.filePath,
+        fileSize: tide.fileSize,
+        chunkSize: tide.chunks[0]?.chunkSize,
+        transferStats,
+        firstChunkIndex: tideState.firstChunkIndex,
+        lastChunkIndex: tideState.lastChunkIndex,
+        highestContiguousChunk: tideState.highestContiguousChunk,
+        tideChunkCount: tideState.tideChunkCount,
+        tideBytes: tideState.tideBytes,
+        completedChunks: tideState.completedChunks,
+        totalChunks: tideState.totalChunks,
+        missingChunks: tideState.missingChunks,
+        metadata: tide.metadata
       });
+      if (onTransferProgress) {
+        onTransferProgress({
+          ...tide,
+          ...tideState,
+          stats: transferStats,
+          metadata: tide.metadata
+        });
+      }
+    } catch (error) {
+      client.clientTide.emitEvent(userID, "transfer-failed", {
+        transferId: tide.transferId,
+        senderID: tide.senderID,
+        recipientId: tide.recipientId,
+        fileName: tide.fileName,
+        filePath: tide.filePath,
+        reason: error.message,
+        metadata: tide.metadata
+      });
+      FileTideDebugUtilityManager.log("error", true, `Failed to process Tide ~ ${tide.fileName} | ${error.message}`);
+      return;
     }
   });
   client.clientTide.onEvent(userID, "transfer-status", data => {
     const {
-      chunkIndex,
-      chunkSize,
+      firstChunkIndex,
+      lastChunkIndex,
+      tideBytes,
       fileName,
       fileSize
     } = data;
-    if (chunkIndex === 0) {
+    if (firstChunkIndex === 0) {
       FileTransferTrackingManager.trackTransfer(data);
-      this.progressBarManager.addTask({
-        name: fileName,
-        size: fileSize
-      });
-    } else if (chunkIndex > 0) {
-      FileTransferTrackingManager.updateTransfer(data);
-      this.progressBarManager.updateTaskProgress(fileName, chunkSize);
+      this.transferStatsManager.startTransfer(data, "sending");
+    }
+    FileTransferTrackingManager.updateTransferRange(data);
+    let transferStats = this.transferStatsManager.getTransferStats(data.transferId || fileName);
+    if (!transferStats) {
+      this.transferStatsManager.startTransfer(data, "sending");
     }
+    transferStats = this.transferStatsManager.updateTransfer(data.transferId || fileName, tideBytes || 0);
     if (onTransferStatus) {
-      const taskBarStats = this.progressBarManager.getTaskBar(fileName);
       onTransferStatus({
         ...data,
-        stats: taskBarStats
+        firstChunkIndex,
+        lastChunkIndex,
+        stats: transferStats
       });
     }
     return;
@@ -705,47 +765,68 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
           } else if (!success) {
             _FileTide.outputGradient(`[${userID}] Did not save file at ~ ${savePath}\n\t${error}\n`, errorMessageColors);
           }
+          const transferStats = success ? this.transferStatsManager.completeTransfer(data.transferId || data.fileName) : this.transferStatsManager.failTransfer(data.transferId || data.fileName);
           if (onTransferComplete) {
-            const taskBarStats = this.progressBarManager.getTaskBar(data.fileName);
             onTransferComplete({
               ...data,
-              stats: taskBarStats
+              stats: transferStats
             }, FileTransferTrackingManager.activeTransfers, success);
           }
-          setTimeout(() => {
-            FileTransferTrackingManager.outputCurrentTransfers();
-            this.progressBarManager.clearTaskBar(data.fileName);
-          }, this.progressBarManager.completionTimeout);
+          FileTransferTrackingManager.outputCurrentTransfers();
+          this.transferStatsManager.clearTransfer(data.transferId || data.fileName);
         });
         return;
       }
       FileTransferTrackingManager.untrackTransfer(data.fileName);
       _FileTide.outputGradient(`[${userID}] Transfer successfully sent to ~ ${data.recipientId} and saved at ~ ${path.join(data.filePath, data.fileName)}\n`, significantMessageColors);
+      const transferStats = this.transferStatsManager.completeTransfer(data.transferId || data.fileName);
       if (onTransferComplete) {
-        const taskBarStats = this.progressBarManager.getTaskBar(data.fileName);
         onTransferComplete({
           ...data,
-          stats: taskBarStats
+          stats: transferStats
         }, FileTransferTrackingManager.activeTransfers, true);
       }
-      setTimeout(() => {
-        FileTransferTrackingManager.outputCurrentTransfers();
-        this.progressBarManager.clearTaskBar(data.fileName);
-      }, this.progressBarManager.completionTimeout);
+      FileTransferTrackingManager.outputCurrentTransfers();
+      this.transferStatsManager.clearTransfer(data.transferId || data.fileName);
     } catch (error) {
       _FileTide.outputGradient(`[${userID}] Did not save file at ~ ${savePath}\n${error}`, errorMessageColors);
+      const transferStats = this.transferStatsManager.failTransfer(data.transferId || data.fileName);
       if (onTransferComplete) {
-        const taskBarStats = this.progressBarManager.getTaskBar(data.fileName);
         onTransferComplete({
           ...data,
-          stats: taskBarStats
+          stats: transferStats
         }, FileTransferTrackingManager.activeTransfers, false);
       }
-      setTimeout(() => {
-        FileTransferTrackingManager.outputCurrentTransfers();
-        this.progressBarManager.clearTaskBar(data.fileName);
-      }, this.progressBarManager.completionTimeout);
+      FileTransferTrackingManager.outputCurrentTransfers();
+      this.transferStatsManager.clearTransfer(data.transferId || data.fileName);
+    }
+  });
+  client.clientTide.onEvent(userID, "transfer-failed", async data => {
+    const transferState = FileTransferTrackingManager.getTransfer(data.fileName);
+    _FileTide.outputGradient(`[${userID}] File transfer failed ~ ${data.fileName}${data.reason ? `\n${data.reason}` : ""}`, errorMessageColors);
+    if (transferState?.fileStream) {
+      try {
+        await new Promise(resolve => {
+          transferState.fileStream.end(resolve);
+        });
+      } catch (error) {
+        FileTideDebugUtilityManager.log("notice", true, `Did not close failed transfer stream ~ ${data.fileName} ~ ${error.message}`);
+      }
+    }
+    FileTransferTrackingManager.untrackTransfer(data.fileName);
+    const transferStats = this.transferStatsManager.failTransfer(data.transferId || data.fileName);
+    const failureData = {
+      ...data,
+      stats: transferStats
+    };
+    if (onTransferFailure) {
+      onTransferFailure(failureData, FileTransferTrackingManager.activeTransfers);
+    }
+    if (onTransferComplete) {
+      onTransferComplete(failureData, FileTransferTrackingManager.activeTransfers, false);
     }
+    FileTransferTrackingManager.outputCurrentTransfers();
+    this.transferStatsManager.clearTransfer(data.transferId || data.fileName);
   });
   client.clientTide.onEvent(userID, "transfer-requested", async data => {
     _FileTide.outputGradient(`[${userID}] Transfer requested from: ${data.requesterID}`, significantMessageColors);