@trap_stevo/filetide 0.0.62 → 0.0.64

package/dist/cjs/FileMessager.js

@@ -19,7 +19,11 @@ const {
 const {
   FileTransferManager
 } = require("./HUDManagers/FileTransferManager");
+const TideSentinelManager = require("./HUDManagers/TideSentinelManager");
 const HUDTargetQueue = require("./HUDManagers/HUDTargetQueueManager");
+const {
+  tidalytics
+} = require("./HUDManagers/TidalyticsManager");
 var _FileMessager_brand = /*#__PURE__*/new WeakSet();
 class FileMessager {
   constructor(options = {
@@ -28,7 +32,7 @@ class FileMessager {
   }, transportOptions = {
     parallelChunks: 3,
     maxRetries: 3
-  }, debugMode = false) {
+  }, onTideAction = null, debugMode = false, tideSentinelOptions = {}) {
     _classPrivateMethodInitSpec(this, _FileMessager_brand);
     const serverOptions = FileMessagerConfigManager.getServerOptions(options);
     this.transporter = new FileTransferManager(transportOptions);
@@ -36,9 +40,15 @@ class FileMessager {
     this.currentTransferBarrierTransfers = new Map();
     this.clientTransferBarriers = new Map();
     this.currentTidingTransfers = new Map();
+    this.tideSentinel = new TideSentinelManager(tideSentinelOptions);
+    this.tideSentinel.registerEntryAddedHook((key, entryData) => {
+      console.log(key, entryData);
+    });
     this.fileNet = new IoTide(serverOptions.port, serverOptions, true, this.onConnect.bind(this), this.onDisconnect.bind(this));
     this.onlineClients = new OmniMap();
+    this.onTideAction = onTideAction ?? (() => {});
     this.debugMode = debugMode;
+    this.tideSentinelOptions = tideSentinelOptions;
     this.transporterOptions = transportOptions;
     this.options = serverOptions;
     return;
@@ -72,6 +82,7 @@ class FileMessager {
     this.fileNet.on("transfer-complete", this.handleFileTransferComplete.bind(this));
     this.fileNet.on("request-transfer-from-client", this.handleRequestTransferFromClient.bind(this));
     this.fileNet.on("client-to-client-transfer", this.handleClientToClientTransfer.bind(this));
+    this.fileNet.on("check-client-banned", this.handleCheckClientBanned.bind(this));
     this.fileNet.on("check-client-online", this.handleCheckClientOnline.bind(this));
     this.fileNet.on("client-offline", this.handleClientOffline.bind(this));
     this.fileNet.on("clients-online", this.handleClientsOnline.bind(this));
@@ -79,6 +90,140 @@ class FileMessager {
     this.fileNet.on("client-tiding", this.handleClientTiding.bind(this));
     return;
   }
+
+  // --- File Messager Tidalytics Management ---
+
+  async getTidalyticsSince(interval = "1d", source = "storage", filter = {}) {
+    return await tidalytics.getMetricsSince(interval, source, filter);
+  }
+  async getStoredTidalytics(filter = {}) {
+    return await tidalytics.getStoredMetrics(filter);
+  }
+  async getTidalyticsInDomain(domain, options = {}) {
+    return await tidalytics.getMetricsInDomain(domain, options);
+  }
+  getTidalytics(filter = {}) {
+    return tidalytics.getMetrics(filter);
+  }
+  getTidalyticByID(id) {
+    return tidalytics.getMetricByID(id);
+  }
+  searchTidalyticByTagValue(key, match) {
+    return tidalytics.searchByTagValue(key, match);
+  }
+  getTidalyticAggregate(name) {
+    return tidalytics.getAggregate(name);
+  }
+  getTidalyticAggregateByType(type) {
+    return tidalytics.getAggregateByType(type);
+  }
+  groupTidalyticByTag(tagKey) {
+    return tidalytics.groupByTag(tagKey);
+  }
+  getTidalyticTimeSeries(name, options = {}) {
+    return tidalytics.getTimeSeries(name, options);
+  }
+  predictTidalytic(name, config = {}) {
+    return tidalytics.predictMetric(name, config);
+  }
+  async clearTidalytics(domain, options = {}) {
+    return await tidalytics.clearMetricsInDomain(domain, options);
+  }
+  clearAllTidalytics() {
+    return tidalytics.clearAllMetrics();
+  }
+
+  // --- File Messager Tide Sentinel Management ---
+
+  banClient(clientID, options = {}) {
+    const result = this.tideSentinel.banClient(clientID, options);
+    tidalytics.track("tider:banned", {
+      value: 1,
+      tags: {
+        "tider:banned": "tider:banned",
+        "tider": "tider",
+        clientID
+      },
+      metadata: {
+        clientID,
+        options
+      }
+    });
+    this.onTideAction({
+      tideActionID: "ban-client-activated",
+      tideActionDate: Date.now(),
+      tideActionDetails: {
+        clientID,
+        options
+      }
+    });
+    return result;
+  }
+  unbanClient(clientID) {
+    const result = this.tideSentinel.unbanClient(clientID);
+    tidalytics.track("tider:unbanned", {
+      value: 1,
+      tags: {
+        "tider:unbanned": "tider:unbanned",
+        "tider": "tider",
+        clientID
+      },
+      metadata: {
+        clientID
+      }
+    });
+    this.onTideAction({
+      tideActionID: "unban-client-activated",
+      tideActionDate: Date.now(),
+      tideActionDetails: {
+        clientID
+      }
+    });
+    return result;
+  }
+  clientBanned(clientID) {
+    const result = this.tideSentinel.clientBanned(clientID);
+    return result;
+  }
+  getBanEntry(clientID) {
+    const result = this.tideSentinel.getBanEntry(clientID);
+    return result;
+  }
+  filterBannedClients(filter = {}) {
+    const result = this.tideSentinel.filterBannedClients(filter);
+    return result;
+  }
+  registerTideSentinelExpireHook(list, callback) {
+    const result = this.tideSentinel.registerExpireHook(list, callback);
+    return result;
+  }
+  addToTideList(list, key, data) {
+    const result = this.tideSentinel.addToList(list, key, data);
+    return result;
+  }
+  removeFromTideList(list, key) {
+    const result = this.tideSentinel.removeFromList(list, key);
+    return result;
+  }
+  inTideList(list, key) {
+    const result = this.tideSentinel.inList(list, key);
+    return result;
+  }
+  getEntry(list, key) {
+    const result = this.tideSentinel.getEntry(list, key);
+    return result;
+  }
+  filterTideList(list, filter = {}) {
+    const result = this.tideSentinel.filterList(list, filter);
+    return result;
+  }
+  findSimilarKeys(keyword, options = {}) {
+    const result = this.tideSentinel.findSimilarKeys(keyword, options);
+    return result;
+  }
+
+  // --- File Messager Client Management ---
+
   getClientFromID(clientID) {
     const client = this.onlineClients.get(clientID);
     if (!client) {
@@ -126,6 +271,40 @@ class FileMessager {
         path: filePath,
         fileSize
       });
+      tidalytics.track("tide:incoming-file", {
+        value: 1,
+        tags: {
+          "tide:incoming-file": "tide:incoming-file",
+          "tide": "tide",
+          recipientID: clientData.userID,
+          senderID: senderData.userID,
+          path: filePath,
+          fileSize,
+          fileName
+        },
+        metadata: {
+          recipientID: clientData.userID,
+          senderID: senderData.userID,
+          path: filePath,
+          fileSize,
+          fileName,
+          totalChunks,
+          chunkSize
+        }
+      });
+      this.onTideAction({
+        tideActionID: "tide-incoming-file",
+        tideActionDate: Date.now(),
+        tideActionDetails: {
+          recipientID: clientData.userID,
+          senderID: senderData.userID,
+          path: filePath,
+          fileSize,
+          fileName,
+          totalChunks,
+          chunkSize
+        }
+      });
     }
     this.fileNet.emitToTide(client.tideID, "transfer-progress", {
       senderName: senderData.userID,
@@ -154,6 +333,24 @@ class FileMessager {
       });
     }
   }
+  saveClientTransferStates(data) {
+    const tidingTransfers = this.currentTidingTransfers.get(data.clientID);
+    if (tidingTransfers && tidingTransfers.size > 0) {
+      for (let recipientID of tidingTransfers.keys()) {
+        const recipientConnectionID = FileNetClientManager.getOnlineClient(data.recipientID ?? recipientID).id;
+        const client = this.getClientFromID(recipientConnectionID);
+        if (client) {
+          this.fileNet.emitToTide(client.tideID, "save-current-transfer-states", {
+            clientID: recipientID
+          });
+        }
+      }
+      this.currentTidingTransfers.delete(data.clientID);
+    }
+  }
+
+  // --- File Messager Event Management ---
+
   handleRequestTransferFromClient(senderTide, transferData) {
     const {
       requesterID,
@@ -183,6 +380,33 @@ class FileMessager {
         totalItemsSent,
         runningOn
       });
+      tidalytics.track("file-list:received", {
+        value: 1,
+        tags: {
+          "file-list:received": "file-list:received",
+          "file-list": "file-list",
+          recipientID,
+          senderID,
+          totalItems: totalItemsSent,
+          runningOn
+        },
+        metadata: {
+          recipientID,
+          senderID,
+          totalItems: totalItemsSent,
+          runningOn
+        }
+      });
+      this.onTideAction({
+        tideActionID: "file-list-received",
+        tideActionDate: Date.now(),
+        tideActionDetails: {
+          recipientID,
+          senderID,
+          totalItems: totalItemsSent,
+          runningOn
+        }
+      });
     } catch (error) {
       console.error(`[FileTide ~ Net Scanner] ~ `, error);
       return;
@@ -234,6 +458,30 @@ class FileMessager {
         recipientID,
         depth
       });
+      tidalytics.track("file-list:request", {
+        value: 1,
+        tags: {
+          "file-list:request": "file-list:request",
+          "file-list": "file-list",
+          recipientID,
+          requesterID,
+          depth
+        },
+        metadata: {
+          recipientID,
+          requesterID,
+          depth
+        }
+      });
+      this.onTideAction({
+        tideActionID: "file-list-request",
+        tideActionDate: Date.now(),
+        tideActionDetails: {
+          recipientID,
+          requesterID,
+          depth
+        }
+      });
     } catch (error) {
       console.error(`[FileTide ~ Net Scanner] ~ `, error);
       return;
@@ -281,6 +529,42 @@ class FileMessager {
               fileName,
               filePath
             });
+            tidalytics.track("tide:completed-transfer", {
+              value: 1,
+              tags: {
+                "tide:completed-transfer": "tide:completed-transfer",
+                "tide": "tide",
+                recipientID: recipientId,
+                senderID,
+                path: filePath,
+                fileSize,
+                fileName
+              },
+              metadata: {
+                recipientID: recipientId,
+                senderID,
+                path: filePath,
+                fileSize,
+                fileName,
+                completedChunks,
+                totalChunks,
+                chunkSize
+              }
+            });
+            this.onTideAction({
+              tideActionID: "tide-completed-transfer",
+              tideActionDate: Date.now(),
+              tideActionDetails: {
+                recipientID: recipientId,
+                senderID,
+                path: filePath,
+                fileSize,
+                fileName,
+                completedChunks,
+                totalChunks,
+                chunkSize
+              }
+            });
             console.log(`[FileTide ~ File Messager] ~ File transfer completed: ${fileName} from ${senderID} to ${recipientId}`);
             const tidingTransfers = this.currentTidingTransfers.get(senderID);
             if (tidingTransfers) {
@@ -325,6 +609,42 @@ class FileMessager {
           fileName,
           filePath
         });
+        tidalytics.track("tide:completed-transfer", {
+          value: 1,
+          tags: {
+            "tide:completed-transfer": "tide:completed-transfer",
+            "tide": "tide",
+            recipientID: recipientId,
+            senderID,
+            path: filePath,
+            fileSize,
+            fileName
+          },
+          metadata: {
+            recipientID: recipientId,
+            senderID,
+            path: filePath,
+            fileSize,
+            fileName,
+            completedChunks,
+            totalChunks,
+            chunkSize
+          }
+        });
+        this.onTideAction({
+          tideActionID: "tide-completed-transfer",
+          tideActionDate: Date.now(),
+          tideActionDetails: {
+            recipientID: recipientId,
+            senderID,
+            path: filePath,
+            fileSize,
+            fileName,
+            completedChunks,
+            totalChunks,
+            chunkSize
+          }
+        });
         console.log(`[FileTide ~ File Messager] ~ File transfer completed: ${fileName} from ${senderID} to ${recipientId}`);
         const tidingTransfers = this.currentTidingTransfers.get(senderID);
         if (tidingTransfers) {
@@ -356,12 +676,92 @@ class FileMessager {
         this.fileNet.emitToTide(senderClient.tideID, "transfer-barrier-response", accepted);
         this.currentTransferBarrierTransfers.delete(data.transferID);
         if (accepted) {
+          tidalytics.track("tide-barrier:accepted", {
+            value: 1,
+            tags: {
+              "tide-barrier:accepted": "tide-barrier:accepted",
+              "tide-barrier": "tide-barrier",
+              recipientID: data.recipientID,
+              transferID: data.transferID,
+              senderID: data.clientID,
+              tideTransferType: data.transferType,
+              tideDestinationPath: data.path,
+              tideOriginPath: data.originPath,
+              tideItemSize: data.itemSize
+            },
+            metadata: {
+              recipientID: data.recipientID,
+              transferID: data.transferID,
+              senderID: data.clientID,
+              tideItemCount: data.itemCount,
+              tideItemSize: data.itemSize,
+              tideTransferContentType: data.transferContentType,
+              tideTransferType: data.transferType,
+              tideDestinationPath: data.path,
+              tideOriginPath: data.originPath
+            }
+          });
+          this.onTideAction({
+            tideActionID: "tide-barrier-accepted",
+            tideActionDate: Date.now(),
+            tideActionDetails: {
+              recipientID: data.recipientID,
+              transferID: data.transferID,
+              senderID: data.clientID,
+              tideItemCount: data.itemCount,
+              tideItemSize: data.itemSize,
+              tideTransferContentType: data.transferContentType,
+              tideTransferType: data.transferType,
+              tideDestinationPath: data.path,
+              tideOriginPath: data.originPath
+            }
+          });
           this.fileNet.emitToTide(client.tideID, "accepted-transfer", {
             accepted,
             ...data
           });
           return;
         }
+        tidalytics.track("tide-barrier:denied", {
+          value: 1,
+          tags: {
+            "tide-barrier:denied": "tide-barrier:denied",
+            "tide-barrier": "tide-barrier",
+            recipientID: data.recipientID,
+            transferID: data.transferID,
+            senderID: data.clientID,
+            tideTransferType: data.transferType,
+            tideDestinationPath: data.path,
+            tideOriginPath: data.originPath,
+            tideItemSize: data.itemSize
+          },
+          metadata: {
+            recipientID: data.recipientID,
+            transferID: data.transferID,
+            senderID: data.clientID,
+            tideItemCount: data.itemCount,
+            tideItemSize: data.itemSize,
+            tideTransferContentType: data.transferContentType,
+            tideTransferType: data.transferType,
+            tideDestinationPath: data.path,
+            tideOriginPath: data.originPath
+          }
+        });
+        this.onTideAction({
+          tideActionID: "tide-barrier-denied",
+          tideActionDate: Date.now(),
+          tideActionDetails: {
+            recipientID: data.recipientID,
+            transferID: data.transferID,
+            senderID: data.clientID,
+            tideItemCount: data.itemCount,
+            tideItemSize: data.itemSize,
+            tideTransferContentType: data.transferContentType,
+            tideTransferType: data.transferType,
+            tideDestinationPath: data.path,
+            tideOriginPath: data.originPath
+          }
+        });
         this.fileNet.emitToTide(client.tideID, "denied-transfer", {
           accepted,
           ...data
@@ -430,7 +830,58 @@ class FileMessager {
   }
   handleAcknowledgeTransferTide(senderTide, data) {
     try {
-      console.log(`[FileTide ~ Net Activity] ~ ${data.recipientName} acknowledged tide transfer from ${data.senderName}.\n\n\t~ [${data.fileName}-${data.transferStats.startTime}] ~\n\n\t\tFile Name ~ ${data.fileName}\n\t\tDestination ~ ${data.path}\n\n\t\t\tProgress ~ ${data.transferStats.progress !== null && data.transferStats.progress !== undefined ? data.transferStats.progress.toFixed(2) : "N/A"}%\n\t\t\tETA ~ ${data.transferStats.timeLeft <= 0 ? "Now" : FileNetUtilityManager.convertSeconds(data.transferStats.timeLeft !== null && data.transferStats.timeLeft !== undefined ? data.transferStats.timeLeft.toFixed(2) : Infinity)}\n\t\t\tSpeed ~ ${FileNetUtilityManager.getFormattedSize(data.transferStats.speed, true)}/s\n\t\t\tSize ~ ${FileNetUtilityManager.getFormattedSize(data.transferStats.totalSize, true)}\n\t\t\tTransferred ~ ${FileNetUtilityManager.getFormattedSize(data.transferStats.current, true)}\n`);
+      const transferETA = data.transferStats.timeLeft <= 0 ? "Now" : FileNetUtilityManager.convertSeconds(data.transferStats.timeLeft !== null && data.transferStats.timeLeft !== undefined ? data.transferStats.timeLeft.toFixed(2) : Infinity);
+      const transferProgress = data.transferStats.progress !== null && data.transferStats.progress !== undefined ? data.transferStats.progress.toFixed(2) : "N/A";
+      const currentTransferredSize = FileNetUtilityManager.getFormattedSize(data.transferStats.current, true);
+      const transferSize = FileNetUtilityManager.getFormattedSize(data.transferStats.totalSize, true);
+      const transferSpeed = FileNetUtilityManager.getFormattedSize(data.transferStats.speed, true);
+      const transferStartTime = data.transferStats.startTime;
+      const fileName = data.fileName;
+      console.log(`[FileTide ~ Net Activity] ~ ${data.recipientName} acknowledged tide transfer from ${data.senderName}.\n\n\t~ [${fileName}-${transferStartTime}] ~\n\n\t\tFile Name ~ ${fileName}\n\t\tDestination ~ ${data.path}\n\n\t\t\tProgress ~ ${transferProgress}%\n\t\t\tETA ~ ${transferETA}\n\t\t\tSpeed ~ ${transferSpeed}/s\n\t\t\tSize ~ ${transferSize}\n\t\t\tTransferred ~ ${currentTransferredSize}\n`);
+      tidalytics.track("tide:transfer-state", {
+        value: 1,
+        tags: {
+          "tide:transfer-state": "tide:transfer-state",
+          "tide": "tide",
+          transferStateID: data.transferStateID,
+          recipientID: data.recipientName,
+          senderID: data.senderName,
+          path: data.path,
+          startTime: transferStartTime,
+          transferSize,
+          fileName
+        },
+        metadata: {
+          transferStateID: data.transferStateID,
+          recipientID: data.recipientName,
+          senderID: data.senderName,
+          path: data.path,
+          startTime: transferStartTime,
+          currentTransferredSize,
+          speed: transferSpeed,
+          transferProgress,
+          transferSize,
+          transferETA,
+          fileName
+        }
+      });
+      this.onTideAction({
+        tideActionID: "tide-transfer-state",
+        tideActionDate: Date.now(),
+        tideActionDetails: {
+          transferStateID: data.transferStateID,
+          recipientID: data.recipientName,
+          senderID: data.senderName,
+          path: data.path,
+          startTime: transferStartTime,
+          currentTransferredSize,
+          speed: transferSpeed,
+          transferProgress,
+          transferSize,
+          transferETA,
+          fileName
+        }
+      });
     } catch (error) {
       console.error(`[FileTide ~ Net Activity] ~  ${data.recipientName} acknowledged tide transfer from ${data.senderName}.\n\n${error}`);
     }
@@ -455,11 +906,45 @@ class FileMessager {
         ...data,
         currentSender: data.senderID
       });
+      const now = new Date();
+      tidalytics.track("tide:incoming-transfer", {
+        value: 1,
+        tags: {
+          "tide:incoming-transfer": "tide:incoming-transfer",
+          "tide": "tide",
+          recipientID: data.recipientID,
+          senderID: data.senderID,
+          fileSize: data.fileSize,
+          fileName: data.fileName,
+          path: data.path,
+          startedOn: now
+        },
+        metadata: {
+          recipientID: data.recipientID,
+          senderID: data.senderID,
+          fileSize: data.fileSize,
+          fileName: data.fileName,
+          path: data.path,
+          startedOn: now
+        }
+      });
+      this.onTideAction({
+        tideActionID: "tide-incoming-transfer",
+        tideActionDate: Date.now(),
+        tideActionDetails: {
+          recipientID: data.recipientID,
+          senderID: data.senderID,
+          fileSize: data.fileSize,
+          fileName: data.fileName,
+          path: data.path,
+          startedOn: now
+        }
+      });
       if (!this.currentTidingTransfers.get(data.senderID) || this.currentTidingTransfers.get(data.senderID).length <= 0) {
         const tidingTransfers = new Map();
         tidingTransfers.set(data.recipientID, {
           recipientID: data.recipientID,
-          startedOn: new Date(),
+          startedOn: now,
           size: data.fileSize,
           path: data.path
         });
@@ -468,7 +953,7 @@ class FileMessager {
       }
       this.currentTidingTransfers.get(data.senderID).set(data.recipientID, {
         recipientID: data.recipientID,
-        startedOn: new Date(),
+        startedOn: now,
         size: data.fileSize,
         path: data.path
       });
@@ -483,6 +968,40 @@ class FileMessager {
   handleFileTransferComplete(senderTide, data) {
     console.log(`File transfer completed: ${data.fileName}`);
   }
+  async handleCheckClientBanned(senderTide, data) {
+    console.log(`[FileTide ~ Net Activity] ~ Checking if client ~ ${data.clientID} banned...`);
+    try {
+      const clientBanned = await this.clientBanned(data.tideID);
+      if (!clientBanned) {
+        console.log(`[FileTide ~ Net Activity] ~ Client ~ ${data.clientID} access authorized!`);
+        this.fileNet.emit("retrieved-client-banned", {
+          banned: false,
+          clientID: data.clientID,
+          tideID: data.tideID,
+          bannedDetails: null
+        });
+        return;
+      }
+      console.log(`[FileTide ~ Net Activity] ~ Client ~ ${data.clientID} banned.`);
+      const bannedClientDetails = await this.getBanEntry(data.tideID);
+      FileNetClientManager.clearOnlineClient(data.clientID);
+      this.saveClientTransferStates(data);
+      this.fileNet.emit("retrieved-client-banned", {
+        banned: true,
+        clientID: data.clientID,
+        tideID: data.tideID,
+        bannedDetails: bannedClientDetails
+      });
+    } catch (error) {
+      this.fileNet.emit("retrieved-client-banned", {
+        banned: false,
+        clientID: data.clientID,
+        tideID: data.tideID,
+        bannedDetails: null
+      });
+      return;
+    }
+  }
   handleCheckClientOnline(senderTide, data) {
     console.log(`[FileTide ~ Net Activity] ~ Checking if client ~ ${data.clientID} online...`);
     try {
@@ -530,6 +1049,40 @@ class FileMessager {
       const currentClientID = clientID;
       clientID = nClientID;
       this.fileNet.emitToTide(tideID, "current-client-id-already-online", clientID);
+      tidalytics.track("tider:already-online", {
+        value: 1,
+        tags: {
+          "tider:already-online": "tider:already-online",
+          "tider": "tider",
+          originUser: originClientID,
+          pUser: currentClientID,
+          user: nClientID,
+          tideID: senderTide.tideID,
+          connectedOn: Date.now()
+        },
+        metadata: {
+          currentTideChannel: currentTideChannel || "file-room",
+          originUser: originClientID,
+          user: nClientID,
+          connectionID,
+          pClientID: currentClientID,
+          tideID: senderTide.tideID,
+          connectedOn: Date.now()
+        }
+      });
+      this.onTideAction({
+        tideActionID: "tider-already-online",
+        tideActionDate: Date.now(),
+        tideActionDetails: {
+          currentTideChannel: currentTideChannel || "file-room",
+          originUser: originClientID,
+          user: nClientID,
+          connectionID,
+          pClientID: currentClientID,
+          tideID: senderTide.tideID,
+          connectedOn: Date.now()
+        }
+      });
       FileNetClientManager.updateOnlineClient(nClientID, {
         pClientID: currentClientID,
         clientID: nClientID,
@@ -541,6 +1094,38 @@ class FileMessager {
       });
       return;
     }
+    tidalytics.track("tider:online", {
+      value: 1,
+      tags: {
+        "tider:online": "tider:online",
+        "tider": "tider",
+        originUser: originClientID,
+        user: clientID,
+        tideID
+      },
+      metadata: {
+        currentTideChannel: currentTideChannel || "file-room",
+        connectedOn: Date.now(),
+        originUser: originClientID,
+        user: clientID,
+        connectionID,
+        pClientID,
+        tideID
+      }
+    });
+    this.onTideAction({
+      tideActionID: "tider-online",
+      tideActionDate: Date.now(),
+      tideActionDetails: {
+        currentTideChannel: currentTideChannel || "file-room",
+        connectedOn: Date.now(),
+        originUser: originClientID,
+        user: clientID,
+        connectionID,
+        pClientID,
+        tideID
+      }
+    });
     FileNetClientManager.addOnlineClient(clientID, pClientID, tideID, connectionID, {
       connectedOn: Date.now(),
       currentTideChannel: currentTideChannel || "file-room",
@@ -563,6 +1148,38 @@ class FileMessager {
         console.log(!clientDetails ? `[FileTide ~ Net Activity] ~ Client ~ ${clientData.clientID} already offline.` : `[FileTide ~ Net Activity] ~ Unauthorized offline signal from connection ID ~ ${clientData.connectionID}.`);
         return;
       }
+      tidalytics.track("tider:offline", {
+        value: 1,
+        tags: {
+          "tider:offline": "tider:offline",
+          "tider": "tider",
+          originUser: clientDetails.originClientID,
+          user: clientDetails.clientID,
+          tideID: clientDetails.tideID
+        },
+        metadata: {
+          currentTideChannel: clientDetails.currentTideChannel || "file-room",
+          originUser: clientDetails.originClientID,
+          user: clientDetails.clientID,
+          connectionID: clientDetails.connectionID,
+          pClientID: clientDetails.pClientID,
+          tideID: clientDetails.tideID,
+          connectedOn: clientDetails.connectedOn
+        }
+      });
+      this.onTideAction({
+        tideActionID: "tider-offline",
+        tideActionDate: Date.now(),
+        tideActionDetails: {
+          currentTideChannel: clientDetails.currentTideChannel || "file-room",
+          originUser: clientDetails.originClientID,
+          user: clientDetails.clientID,
+          connectionID: clientDetails.connectionID,
+          pClientID: clientDetails.pClientID,
+          tideID: clientDetails.tideID,
+          connectedOn: clientDetails.connectedOn
+        }
+      });
       FileNetClientManager.clearOnlineClient(clientData.clientID);
       const currentOnlineClients = Object.fromEntries(FileNetClientManager.getOnlineClients());
       this.fileNet.emit("current-online-clients", currentOnlineClients);
@@ -571,19 +1188,7 @@ class FileMessager {
       this.fileNet.emitToTide(senderClient.tideID, "save-current-transfer-states", {
         clientID: clientData.clientID
       });
-      const tidingTransfers = this.currentTidingTransfers.get(clientData.clientID);
-      if (tidingTransfers && tidingTransfers.size > 0) {
-        for (let recipientID of tidingTransfers.keys()) {
-          const recipientConnectionID = FileNetClientManager.getOnlineClient(clientData.recipientID).id;
-          const client = this.getClientFromID(recipientConnectionID);
-          if (client) {
-            this.fileNet.emitToTide(client.tideID, "save-current-transfer-states", {
-              clientID: recipientID
-            });
-          }
-        }
-        this.currentTidingTransfers.delete(clientData.clientID);
-      }
+      this.saveClientTransferStates(clientData);
     } catch (error) {
       console.log(`[FileTide ~ Net Activity] ~ Did not process client ~ ${clientData} offline signal ~ ${error}`);
     }

package/dist/cjs/FileMessagerClient.js

@@ -36,23 +36,28 @@ class FileMessagerClient {
     const {
       maxReconnectionAttempts = 15,
       reconnectionAttempts = 15,
-      maxReconnectionDelay = 10000
+      maxReconnectionDelay = 10000,
+      ...messagerConfigurations
     } = messagerSettings;
     this.clientOptions = FileMessagerConfigManager.getClientOptions(options);
     this.transporter = new FileTransferManager(transportOptions);
     this.activeTransferTypes = new Map();
-    this.clientTide = new HUDIoTide(maxReconnectionAttempts, reconnectionAttempts, maxReconnectionDelay);
+    this.clientTide = new HUDIoTide(maxReconnectionAttempts, reconnectionAttempts, maxReconnectionDelay, {
+      persistentTideIDs: true,
+      persistentTideID: true,
+      ...messagerConfigurations
+    });
     this.clients = new Map();
   }
   createClientInstance(clientID, clientOptions, options = {}, headers = {}, onConnect = null, onDisconnect = null, authURL = "", authHeaders = {}, useAuthentication = false, queryAuthToken = false) {
     this.clientTide.createIO(clientID, clientOptions.url, {
       transports: ["websocket"],
       ...options
-    }, headers, authURL, authHeaders, useAuthentication, queryAuthToken, onConnect, () => {
+    }, headers, authURL, authHeaders, useAuthentication, queryAuthToken, onConnect, async () => {
       FileTransferTrackingManager.outputCurrentTransfers();
       FileTransferRecoveryManager.flushToDisk();
       if (onDisconnect) {
-        onDisconnect();
+        await onDisconnect();
       }
     });
     FileTideDebugUtilityManager.outputGradient(`\n[FileTide ~ File Messager] ~ Created client with ID ${clientID} and socket ${clientID}!`, significantMessageColors);

package/dist/cjs/FileTide.js

@@ -47,6 +47,7 @@ class FileTide {
     });
     this.clientShorePolicies = new Map();
     this.transferBarrier = false;
+    this.clientDetails = new Map();
     this.clients = new Map();
     this.currentUserID = "";
     this.runningOn = os.platform();
@@ -109,11 +110,29 @@ class FileTide {
     if (this.clients.has(userID)) {
       this.stopMessager(userID);
     }
+    const currentClientDetails = this.clientDetails.get(userID);
+    if (currentClientDetails && currentClientDetails.unauthorized) {
+      const {
+        onCurrentClientUnauthorized
+      } = options;
+      FileTide.outputGradient(`[FileTide ~ FileNet] ~ Unauthorized access detected.`, errorMessageColors);
+      if (onCurrentClientUnauthorized) {
+        onCurrentClientUnauthorized({
+          ...currentClientDetails,
+          userID
+        });
+      }
+      return;
+    }
     const newClient = new FileMessagerClient(clientOptions, transportOptions, messagerSettings);
     const enterRoom = newClient.joinRoom(userID, roomName, connectionOptions, headers, onConnect, onDisconnect, authURL, authHeaders, useAuthentication, queryAuthToken);
     this.transferBarrier = enableTransferBarrier;
     this.clientShorePolicies.set(userID, [FileUtilityManager.getTidePath(">Downloads"), FileUtilityManager.getTidePath(">Documents"), FileUtilityManager.getTidePath(">Desktop"), FileUtilityManager.getTidePath(">Photos"), FileUtilityManager.getTidePath(">Videos"), FileUtilityManager.getTidePath(">Music")]);
     this.clients.set(userID, newClient);
+    this.clientDetails.set(userID, {
+      unauthorized: false,
+      userID
+    });
     FileTide.outputGradient(`[FileTide] ~ Messager launched successfully for client ~ ${userID}!`, significantMessageColors);
     _assertClassBrand(_FileTide_brand, this, _setupFileEventListeners).call(this, userID, newClient, onTransferProgress, onIncomingTransfer, onIncomingFile, onTransferBarrier, options);
     if (onLaunch) {
@@ -153,6 +172,10 @@ class FileTide {
       FileTide.outputGradient(`[FileTide] Client ~ ${clientID} not found.`, errorMessageColors);
       return;
     }
+    clientMessager.clientTide.emitEvent(clientID, "check-client-banned", {
+      clientID,
+      tideID: clientMessager.clientTide.sockets[clientID].tideID
+    });
     clientMessager.listFiles(clientID, recipientID, depth);
   }
   async listFiles(directories, depth = 1, onDirectory) {
@@ -201,6 +224,10 @@ class FileTide {
       FileTide.outputGradient(`[FileTide] Client ~ ${clientID} not found.`, errorMessageColors);
       return false;
     }
+    clientMessager.clientTide.emitEvent(clientID, "check-client-banned", {
+      clientID,
+      tideID: clientMessager.clientTide.sockets[clientID].tideID
+    });
     const recipientOnline = await clientMessager.clientTide.emitEventWithResponse(clientID, "check-client-online", "retrieved-client-online", {
       clientID: recipientID
     }, 5000);
@@ -350,7 +377,10 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
     onFileListReceived,
     onCurrentOnlineClients,
     onClientTiding,
-    onCurrentClientIDAlreadyOnline
+    onCurrentClientIDAlreadyOnline,
+    onCurrentClientUnauthorized,
+    onBeforeCurrentClientUnauthorizedDisconnect,
+    onCurrentClientUnauthorizedDisconnect
   } = options;
   const cliTable = new ConsoleTable({
     padding: 2,
@@ -380,6 +410,10 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
   });
   const fileTransferReceiver = new FileTransferReceiverManager();
   client.clientTide.onEvent(userID, "current-online-clients", data => {
+    client.clientTide.emitEvent(userID, "check-client-banned", {
+      clientID: userID,
+      tideID: client.clientTide.sockets[userID].tideID
+    });
     const currentClients = {};
     Object.keys(data).forEach(key => {
       if (key !== userID) {
@@ -430,6 +464,22 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
     }
     return;
   });
+  client.clientTide.onEvent(userID, "retrieved-client-banned", async bannedDetails => {
+    const clientID = bannedDetails.clientID;
+    if (userID !== clientID) {
+      return;
+    }
+    if (!bannedDetails.banned) {
+      return;
+    }
+    _FileTide.outputGradient(`[FileTide ~ FileNet] ~ Unauthorized access detected.`, errorMessageColors);
+    await this.stopAllMessagers(onBeforeCurrentClientUnauthorizedDisconnect, onCurrentClientUnauthorizedDisconnect, async () => {
+      if (onCurrentClientUnauthorized) {
+        onCurrentClientUnauthorized(bannedDetails);
+      }
+    });
+    return;
+  });
   client.clientTide.onEvent(userID, "save-current-transfer-states", async data => {
     this.saveTransferStates();
     return;
@@ -687,6 +737,10 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
     }
   });
   client.clientTide.onEvent(userID, "client-file-list", async data => {
+    client.clientTide.emitEvent(userID, "check-client-banned", {
+      clientID: userID,
+      tideID: client.clientTide.sockets[userID].tideID
+    });
     _FileTide.outputGradient(`[${userID}] Received ${HUDUtilityManager.convertNumberToMoneyFormat(data.totalItems, false)} directory contents from ${data.senderID}'s file list!`, significantMessageColors);
     if (onListFiles) {
       onListFiles(data);

package/dist/cjs/HUDManagers/TidalyticsInstanceManager.js

@@ -0,0 +1,69 @@
+"use strict";
+
+const MetricTide = require("@trap_stevo/metrictide");
+class TidalyticsInstanceManager {
+  constructor() {
+    this.instances = new Map();
+  }
+  createInstance(name = "default", config = {}) {
+    if (this.instances.has(name)) {
+      return this.instances.get(name);
+    }
+    const defaultConfig = {
+      dbPath: "./filetide_core/.tidalytics",
+      persistence: {
+        alwaysOn: true
+      },
+      loadMetricsOnLaunch: false,
+      onTrack: record => {
+        console.log("[Tidalytics] Tracked:", record.name, record.value);
+      }
+    };
+    const mergedConfig = {
+      ...defaultConfig,
+      ...config,
+      persistence: {
+        ...defaultConfig.persistence,
+        ...(config.persistence || {})
+      }
+    };
+    const instance = new MetricTide(mergedConfig);
+    this.instances.set(name, instance);
+    return instance;
+  }
+  getInstance(name = "default", configurations = {}) {
+    if (!this.instances.has(name)) {
+      if (configurations) {
+        return this.createInstance(name, configurations);
+      }
+      return null;
+    }
+    return this.instances.get(name);
+  }
+  containsInstance(name = "default") {
+    return this.instances.has(name);
+  }
+  clearInstance(name = "default") {
+    this.instances.delete(name);
+  }
+  listInstances() {
+    return Array.from(this.instances.entries());
+  }
+  clearAll() {
+    this.instances.clear();
+  }
+}
+;
+let singleton = null;
+const Tidalytics = {
+  get() {
+    if (!singleton) {
+      singleton = new TidalyticsInstanceManager();
+    }
+    return singleton;
+  }
+};
+module.exports = {
+  TidalyticsInstanceManager,
+  Tidalytics
+};

package/dist/cjs/HUDManagers/TidalyticsManager.js

@@ -0,0 +1,9 @@
+"use strict";
+
+const {
+  Tidalytics
+} = require("./TidalyticsInstanceManager");
+const tidalytics = Tidalytics.get().getInstance("Tidalytics", {});
+module.exports = {
+  tidalytics
+};

package/dist/cjs/HUDManagers/TideSentinelManager.js

@@ -0,0 +1,143 @@
+"use strict";
+
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+const Timelyst = require("@trap_stevo/timelyst");
+var _config = /*#__PURE__*/new WeakMap();
+var _lists = /*#__PURE__*/new WeakMap();
+var _manager = /*#__PURE__*/new WeakMap();
+var _onEntryAddedHooks = /*#__PURE__*/new WeakMap();
+var _onExpireHooks = /*#__PURE__*/new WeakMap();
+var _TideSentinelManager_brand = /*#__PURE__*/new WeakSet();
+class TideSentinelManager {
+  constructor(config = {}) {
+    _classPrivateMethodInitSpec(this, _TideSentinelManager_brand);
+    _classPrivateFieldInitSpec(this, _config, void 0);
+    _classPrivateFieldInitSpec(this, _lists, void 0);
+    _classPrivateFieldInitSpec(this, _manager, void 0);
+    _classPrivateFieldInitSpec(this, _onEntryAddedHooks, {});
+    _classPrivateFieldInitSpec(this, _onExpireHooks, {});
+    const {
+      lists = {},
+      enableOfflineStorage = true,
+      autoCleanupInterval = "15s",
+      basePath = "./filetide_core/tide_sentinel",
+      ...rest
+    } = config;
+    _classPrivateFieldSet(_config, this, {
+      enableOfflineStorage,
+      autoCleanupInterval,
+      basePath,
+      ...rest
+    });
+    _classPrivateFieldSet(_lists, this, lists);
+    _classPrivateFieldSet(_manager, this, new Timelyst(_classPrivateFieldGet(_config, this)));
+    _classPrivateFieldGet(_manager, this).on("entry-expired", (list, key, entry) => {
+      const hook = _classPrivateFieldGet(_onExpireHooks, this)[list];
+      if (typeof hook === "function") {
+        hook(key, entry);
+      }
+    });
+    _classPrivateFieldGet(_manager, this).on("entry-added", (list, key, entry) => {
+      const hook = _classPrivateFieldGet(_onEntryAddedHooks, this)[list];
+      if (typeof hook === "function") {
+        hook(key, entry);
+      }
+    });
+  }
+  registerEntryAddedHook(list, callback) {
+    if (typeof callback === "function") {
+      _classPrivateFieldGet(_onEntryAddedHooks, this)[list] = callback;
+    }
+  }
+  registerExpireHook(list, callback) {
+    if (typeof callback === "function") {
+      _classPrivateFieldGet(_onExpireHooks, this)[list] = callback;
+    }
+  }
+  async createList(name, options = {}) {
+    _classPrivateFieldGet(_lists, this)[name] = options;
+    return _classPrivateFieldGet(_manager, this).createList(name, options);
+  }
+  async deleteList(name) {
+    delete _classPrivateFieldGet(_lists, this)[name];
+    return _classPrivateFieldGet(_manager, this).deleteList(name);
+  }
+  async reconfigureList(name, newOptions = {}) {
+    Object.assign(_classPrivateFieldGet(_lists, this)[name] = _classPrivateFieldGet(_lists, this)[name] || {}, newOptions);
+    await _classPrivateFieldGet(_manager, this).deleteList(name);
+    return _classPrivateFieldGet(_manager, this).createList(name, _classPrivateFieldGet(_lists, this)[name]);
+  }
+  async banClient(clientID, options = {}) {
+    const {
+      reason = "Unspecified.",
+      duration = null,
+      tags = [],
+      priority = 10,
+      category = "ban",
+      details = {}
+    } = options;
+    await _assertClassBrand(_TideSentinelManager_brand, this, _ensureList).call(this, "banned-tiders");
+    return _classPrivateFieldGet(_manager, this).addToList("banned-tiders", clientID, {
+      expiresIn: duration,
+      priority,
+      category,
+      tags,
+      details
+    });
+  }
+  async unbanClient(clientID) {
+    await _assertClassBrand(_TideSentinelManager_brand, this, _ensureList).call(this, "banned-tiders");
+    return _classPrivateFieldGet(_manager, this).removeFromList("banned-tiders", clientID);
+  }
+  async clientBanned(clientID) {
+    await _assertClassBrand(_TideSentinelManager_brand, this, _ensureList).call(this, "banned-tiders");
+    return _classPrivateFieldGet(_manager, this).inList("banned-tiders", clientID);
+  }
+  async getBanEntry(clientID) {
+    await _assertClassBrand(_TideSentinelManager_brand, this, _ensureList).call(this, "banned-tiders");
+    return _classPrivateFieldGet(_manager, this).getEntryByKey("banned-tiders", clientID);
+  }
+  async filterBannedClients(filter = {}) {
+    await _assertClassBrand(_TideSentinelManager_brand, this, _ensureList).call(this, "banned-tiders");
+    return _classPrivateFieldGet(_manager, this).filterList("banned-tiders", filter);
+  }
+  async addToList(list, key, data) {
+    await _assertClassBrand(_TideSentinelManager_brand, this, _ensureList).call(this, list);
+    return _classPrivateFieldGet(_manager, this).addToList(list, key, data);
+  }
+  async removeFromList(list, key) {
+    await _assertClassBrand(_TideSentinelManager_brand, this, _ensureList).call(this, list);
+    return _classPrivateFieldGet(_manager, this).removeFromList(list, key);
+  }
+  async inList(list, key) {
+    await _assertClassBrand(_TideSentinelManager_brand, this, _ensureList).call(this, list);
+    return _classPrivateFieldGet(_manager, this).inList(list, key);
+  }
+  async getEntry(list, key) {
+    await _assertClassBrand(_TideSentinelManager_brand, this, _ensureList).call(this, list);
+    return _classPrivateFieldGet(_manager, this).getEntryByKey(list, key);
+  }
+  async filterList(list, filter = {}) {
+    await _assertClassBrand(_TideSentinelManager_brand, this, _ensureList).call(this, list);
+    return _classPrivateFieldGet(_manager, this).filterList(list, filter);
+  }
+  async findSimilarKeys(key, options = {}) {
+    return _classPrivateFieldGet(_manager, this).findSimilarKeys(key, options);
+  }
+}
+async function _ensureList(name) {
+  if (!_classPrivateFieldGet(_lists, this)[name]) {
+    _classPrivateFieldGet(_lists, this)[name] = {};
+  }
+  const exists = await _classPrivateFieldGet(_manager, this).listOperational(name);
+  if (!exists) {
+    await _classPrivateFieldGet(_manager, this).createList(name, _classPrivateFieldGet(_lists, this)[name]);
+  }
+}
+;
+module.exports = TideSentinelManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trap_stevo/filetide",
-  "version": "0.0.62",
+  "version": "0.0.64",
   "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": {
@@ -34,9 +34,11 @@
   "author": "Steven Compton",
   "license": "See License in LICENSE.md",
   "dependencies": {
-    "@trap_stevo/iotide": "^0.0.41",
-    "@trap_stevo/iotide-client": "^0.0.23",
+    "@trap_stevo/iotide": "^0.0.43",
+    "@trap_stevo/iotide-client": "^0.0.25",
     "@trap_stevo/legendarybuilderpronodejs-utilities": "^1.0.43",
+    "@trap_stevo/metrictide": "^0.0.3",
+    "@trap_stevo/timelyst": "^0.0.5",
     "chalk": "^4.1.2",
     "readline": "^1.3.0"
   },

package/transfer_states/FileNetServer_FileNetClient_-Documents-TestFileTideDropZone-TidalCore.txt.json

@@ -0,0 +1,7 @@
+{
+  "transferredSize": 524288,
+  "senderName": "FileNetClient",
+  "clientName": "FileNetServer",
+  "filePath": ">Documents\\TestFileTideDropZone-TidalCore.txt",
+  "lastChunkSent": 147
+}