@trap_stevo/filetide 0.0.62 → 0.0.63

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}`);
     }