@trap_stevo/filetide 0.0.62 → 0.0.63

package/dist/cjs/FileMessagerClient.js

@@ -41,18 +41,21 @@ class FileMessagerClient {
     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
+    });
     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/filetide_core/.tidalytics/CURRENT

@@ -0,0 +1 @@
+MANIFEST-000088

package/filetide_core/.tidalytics/LOG.old

@@ -0,0 +1,6 @@
+2025/04/26-16:56:15.117 8174 Recovering log #84
+2025/04/26-16:56:15.117 8174 Level-0 table #86: started
+2025/04/26-16:56:15.122 8174 Level-0 table #86: 529 bytes OK
+2025/04/26-16:56:15.130 8174 Delete type=0 #84
+2025/04/26-16:56:15.130 8174 Delete type=3 #82
+2025/04/26-16:56:15.133 3da4 Moved #77 to level-1 1047 bytes OK: files[ 3 25 0 0 0 0 0 ]

package/filetide_core/tide_sentinel/banned-tiders/CURRENT

@@ -0,0 +1 @@
+MANIFEST-000091

package/filetide_core/tide_sentinel/banned-tiders/LOG

@@ -0,0 +1,3 @@
+2025/04/26-16:58:12.482 7d4c Recovering log #90
+2025/04/26-16:58:12.493 7d4c Delete type=0 #90
+2025/04/26-16:58:12.493 7d4c Delete type=3 #89

package/filetide_core/tide_sentinel/banned-tiders/LOG.old

@@ -0,0 +1,3 @@
+2025/04/26-16:56:15.155 8174 Recovering log #88
+2025/04/26-16:56:15.166 8174 Delete type=0 #88
+2025/04/26-16:56:15.166 8174 Delete type=3 #87

package/iotide_client/tide_session_id.json

@@ -0,0 +1 @@
+b27541b4-aa20-4f49-8e88-4854fd97faf6

package/iotide_client/tide_session_ids.json

@@ -0,0 +1,5 @@
+{
+     "FileNetClient": "7a236449-e992-425b-a565-83886f74d394",
+     "FileNetServer": "b1cf34c6-481e-4e4d-b0ea-dc55eb94fe24",
+     "FileNettClient": "d253ca4f-ea5f-4a4c-92e7-356d7442db46"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trap_stevo/filetide",
-  "version": "0.0.62",
+  "version": "0.0.63",
   "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
+}