@persistica/flux-agent 0.0.18 → 0.0.20

package/index.js

@@ -132,6 +132,7 @@ var RPCServer = class {
 };
 
 // libs/flux/shared/ws/src/lib/ws-client.ts
+var RECONNECTION_DELAY_ON_KICK_MS = 18e5;
 var WebSocketClient = class extends RPCServer {
   options;
   eventListeners = {
@@ -180,17 +181,25 @@ var WebSocketClient = class extends RPCServer {
       this.ws.onmessage = (event) => {
         this.emit("message", event.data);
       };
-      this.ws.onclose = () => {
+      this.ws.onclose = (closeEvent) => {
+        const wasKicked = closeEvent.reason === "Kicked by process";
         clearTimeout(timeout);
         if (this.isOpen) {
-          this.emit("close");
+          this.emit(
+            "close",
+            wasKicked ? "kicked" : void 0
+          );
           this.isOpen = false;
         }
         if (this.options.autoReconnect && (this.options.retries === void 0 || this.reconnectAttempts < this.options.retries)) {
+          const delay = wasKicked ? RECONNECTION_DELAY_ON_KICK_MS : Math.min(
+            this.options.reconnectDelay ?? Number.POSITIVE_INFINITY,
+            (this.options.reconnectDelay ?? 0) * (this.reconnectAttempts || 1)
+          );
           setTimeout(() => {
             this.reconnectAttempts++;
             this.connect();
-          }, Math.min(this.options.reconnectDelay ?? Number.POSITIVE_INFINITY, this.options.reconnectDelay * (this.reconnectAttempts || 1)));
+          }, delay);
         } else if (this.options.autoReconnect) {
           this.emit("error", new Error("Connection failed: retries exhausted"));
         }
@@ -444,33 +453,6 @@ var FluxAgentNetworkConnection = class {
   }
 };
 
-// libs/flux/shared/connection/src/lib/flux-network-channel.class.ts
-var FluxNetworkChannel = class {
-  constructor(channelName, _fluxWebSocketConnection) {
-    this.channelName = channelName;
-    this._fluxWebSocketConnection = _fluxWebSocketConnection;
-  }
-  /**
-   * Broadcasts a message to the channel.
-   */
-  publish(message) {
-    this._fluxWebSocketConnection.publish(
-      this.channelName,
-      message
-    );
-  }
-  /**
-   * Listen to messages on this channel.
-   */
-  onPublish(fn) {
-    this._fluxWebSocketConnection.onPublish(
-      this.channelName,
-      fn
-      // TODO
-    );
-  }
-};
-
 // libs/utils/logger/src/lib/utils-logger.ts
 var hasOverlap = (a, b) => a && b ? [...a].some((item) => (Array.isArray(b) ? b : [b]).includes(item)) : false;
 var PicoLogger = /* @__PURE__ */ (() => {
@@ -504,6 +486,91 @@ var PicoLogger = /* @__PURE__ */ (() => {
   };
 })();
 
+// libs/flux/shared/connection/src/lib/flux-network-channel.class.ts
+var FluxNetworkChannel = class {
+  constructor(channelName, _fluxWebSocketConnection) {
+    this.channelName = channelName;
+    this._fluxWebSocketConnection = _fluxWebSocketConnection;
+  }
+  /**
+   * Broadcasts a message to the channel.
+   */
+  publish(message) {
+    this._fluxWebSocketConnection.publish(
+      this.channelName,
+      message
+    );
+  }
+  /**
+   * Listen to messages on this channel.
+   */
+  onPublish(fn) {
+    this._fluxWebSocketConnection.onPublish(
+      this.channelName,
+      fn
+      // TODO
+    );
+  }
+};
+
+// libs/flux/shared/connection/src/lib/channel-state-manager.ts
+var CONNECTION_TIMEOUT_MS = 2e3;
+var ChannelStateManager = class {
+  connectionTimeouts = /* @__PURE__ */ new Map();
+  /**
+   * Join a channel.
+   */
+  async joinChannel(channelName, fluxWebSocketConnection, webSocketClient) {
+    if (webSocketClient) {
+      return new Promise((resolve, reject) => {
+        webSocketClient.send(`${SUBSCRIBE_NETWORK_CHANNEL_NAME}:${channelName}`);
+        const existingTimeout = this.connectionTimeouts.get(channelName);
+        if (existingTimeout) {
+          clearTimeout(existingTimeout);
+          this.connectionTimeouts.delete(channelName);
+        }
+        const cb = (message) => {
+          const timeout = this.connectionTimeouts.get(channelName);
+          if (timeout) {
+            clearTimeout(timeout);
+            this.connectionTimeouts.delete(channelName);
+          }
+          fluxWebSocketConnection.removePackageTypeInterceptor(SUBSCRIBED_NETWORK_CHANNEL_NAME, cb);
+          const receivedChannelName = message.substring(message.indexOf(":") + 1);
+          if (channelName !== receivedChannelName) {
+            reject(new Error(`Channel name mismatch: "${channelName}" !== "${receivedChannelName}"`));
+            return;
+          }
+          resolve(new FluxNetworkChannel(channelName, fluxWebSocketConnection));
+        };
+        this.connectionTimeouts.set(
+          channelName,
+          setTimeout(() => {
+            this.connectionTimeouts.delete(channelName);
+            fluxWebSocketConnection.removePackageTypeInterceptor(SUBSCRIBED_NETWORK_CHANNEL_NAME, cb);
+            reject(new Error(`Channel subscription timed out for channel "${channelName}"`));
+          }, CONNECTION_TIMEOUT_MS)
+        );
+        fluxWebSocketConnection.interceptPackageTypeMessages(
+          SUBSCRIBED_NETWORK_CHANNEL_NAME,
+          cb
+        );
+      });
+    }
+    return Promise.reject(new Error("Not connected"));
+  }
+  /**
+   * Leave a channel.
+   */
+  async leaveChannel(channelName, webSocketClient) {
+    if (webSocketClient) {
+      webSocketClient.send(`${UNSUBSCRIBE_NETWORK_CHANNEL_NAME}:${channelName}`);
+      return Promise.resolve(void 0);
+    }
+    return Promise.reject(new Error("Not connected"));
+  }
+};
+
 // libs/flux/shared/connection/src/lib/flux-ws-connection.ts
 var createWSConnection = (id, ticket, stateManager, onReconnectCallback, options) => {
   return new FluxWebSocketConnection(
@@ -530,7 +597,7 @@ var FluxWebSocketConnection = class {
       secretKey: this.options?.secretKey,
       retries: this.options?.retries ?? 1e4
     };
-    const url = new URL(this.options?.domain ?? "http://localhost:5100");
+    const url = new URL(this.options.domain);
     url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
     url.searchParams.set("token", this.token);
     this.socket = new FluxWebSocketClientConnection(
@@ -541,14 +608,36 @@ var FluxWebSocketConnection = class {
         retries: this.options.retries
       }
     );
+    this.interceptPackageTypeMessages("isReady", this.readyInterceptor);
   }
+  // ****************************************************************************
+  // *** State
+  // ****************************************************************************
   socket;
   callbacks = /* @__PURE__ */ new Set();
   channelCallbacks = /* @__PURE__ */ new Map();
-  // Handles messages before the rest of the logic. Will not continue if there are interceptors
+  // Handles messages before the rest of the logic. Will not continue if there are interceptors.
   packageTypeInterceptorCallbacks = /* @__PURE__ */ new Map();
   webSocketClient;
+  connectPromise;
+  connectPromiseResolver;
   first = true;
+  channelStateManager = new ChannelStateManager();
+  // ****************************************************************************
+  // *** Reused socket callbacks
+  // ****************************************************************************
+  readyInterceptor = () => {
+    this.resolveConnectedSocket();
+    if (this.first) {
+      this.first = false;
+      return;
+    }
+    this.onReconnectCallback();
+  };
+  socketMessageHandler = this.handleMessage.bind(this);
+  socketCloseHandler = (reason) => this.handleSocketClose(reason);
+  socketConnectingHandler = (retryAttempt) => this.handleSocketConnecting(retryAttempt);
+  socketErrorHandler = (error) => this.handleSocketError(error);
   /**
    * Intercepts messages of a given package type.
    */
@@ -581,43 +670,24 @@ var FluxWebSocketConnection = class {
     if (this.webSocketClient) {
       return Promise.resolve(this.webSocketClient);
     }
-    return new Promise((resolve) => {
-      this.interceptPackageTypeMessages(
-        "isReady",
-        () => {
-          this.stateManager.emitNetworkState("connected");
-          this.webSocketClient = this.socket;
-          resolve(this.socket);
-          if (this.first) {
-            this.first = false;
-            return;
-          }
-          this.onReconnectCallback();
-        }
-      );
-      this.socket.clearEventSubscribers();
-      this.socket.on("message", this.handleMessage.bind(this)).on("close", () => {
-        this.webSocketClient = void 0;
-        this.stateManager.emitNetworkState("disconnected");
-        PicoLogger.log("\u{1F50C}\u{1F534} Disconnected", this.fluxInstanceId);
-      }).on("connecting", (retryAttempt) => {
-        this.stateManager.emitNetworkState("disconnected");
-        if (retryAttempt > 0) {
-          PicoLogger.log(`\u{1F504} Connecting attempt: #${retryAttempt} of ${this.options?.retries ?? "none"}`, this.fluxInstanceId);
-        } else {
-          PicoLogger.log(`\u{1F504} Connecting: ${this.fluxInstanceId}`);
-        }
-      }).on("error", (error) => {
-        PicoLogger.log(`\u274C Error: "${error.message}".`, this.fluxInstanceId);
-      });
-      this.stateManager.emitNetworkState("connecting");
-      this.socket.connect();
+    if (this.connectPromise) {
+      return this.connectPromise;
+    }
+    this.connectPromise = new Promise((resolve) => {
+      this.connectPromiseResolver = resolve;
     });
+    this.socket.clearEventSubscribers();
+    this.socket.on("message", this.socketMessageHandler).on("close", this.socketCloseHandler).on("connecting", this.socketConnectingHandler).on("error", this.socketErrorHandler);
+    this.stateManager.emitNetworkState("connecting");
+    void this.socket.connect();
+    return this.connectPromise;
   }
   /**
    * Disconnects from the Flux platform.
    */
   disconnect() {
+    this.connectPromiseResolver = void 0;
+    this.connectPromise = void 0;
     this.socket.close();
     this.webSocketClient = void 0;
     this.stateManager.emitNetworkState("disconnected");
@@ -650,35 +720,20 @@ var FluxWebSocketConnection = class {
    * Join a channel.
    */
   async joinChannel(channelName) {
-    if (this.webSocketClient) {
-      this.webSocketClient.send(`${SUBSCRIBE_NETWORK_CHANNEL_NAME}:${channelName}`);
-      return new Promise((resolve, reject) => {
-        const cb = (message) => {
-          this.removePackageTypeInterceptor(SUBSCRIBED_NETWORK_CHANNEL_NAME, cb);
-          const receivedChannelName = message.substring(message.indexOf(":") + 1);
-          if (channelName !== receivedChannelName) {
-            reject(new Error(`Channel name mismatch: "${channelName}" !== "${receivedChannelName}"`));
-            return;
-          }
-          resolve(new FluxNetworkChannel(channelName, this));
-        };
-        this.interceptPackageTypeMessages(
-          SUBSCRIBED_NETWORK_CHANNEL_NAME,
-          cb
-        );
-      });
-    }
-    return Promise.reject(new Error("Not connected"));
+    return this.channelStateManager.joinChannel(
+      channelName,
+      this,
+      this.webSocketClient
+    );
   }
   /**
-   * Leaves a channel.
+   * Leave a channel.
    */
   async leaveChannel(channelName) {
-    if (this.webSocketClient) {
-      this.webSocketClient.send(`${UNSUBSCRIBE_NETWORK_CHANNEL_NAME}:${channelName}`);
-      return Promise.resolve(void 0);
-    }
-    return Promise.reject(new Error("Not connected"));
+    return this.channelStateManager.leaveChannel(
+      channelName,
+      this.webSocketClient
+    );
   }
   /**
    * Publishes a message to a channel.
@@ -746,6 +801,33 @@ var FluxWebSocketConnection = class {
   // ****************************************************************************
   // *** Internal Helpers
   // ****************************************************************************
+  resolveConnectedSocket() {
+    this.stateManager.emitNetworkState("connected");
+    this.webSocketClient = this.socket;
+    const connectPromiseResolver = this.connectPromiseResolver;
+    this.connectPromiseResolver = void 0;
+    this.connectPromise = void 0;
+    connectPromiseResolver?.(this.socket);
+  }
+  handleSocketClose(reason) {
+    this.webSocketClient = void 0;
+    PicoLogger.log(
+      reason === "kicked" ? `\u{1F50C}\u{1F534} Kicked, delaying reconnect ${RECONNECTION_DELAY_ON_KICK_MS / 6e4} minutes` : "\u{1F50C}\u{1F534} Disconnected",
+      this.fluxInstanceId
+    );
+    this.stateManager.emitNetworkState(reason === "kicked" ? "kicked" : "disconnected");
+  }
+  handleSocketConnecting(retryAttempt) {
+    this.stateManager.emitNetworkState("disconnected");
+    if (retryAttempt > 0) {
+      PicoLogger.log(`\u{1F504} Connecting attempt: #${retryAttempt} of ${this.options?.retries ?? "none"}`, this.fluxInstanceId);
+    } else {
+      PicoLogger.log(`\u{1F504} Connecting: ${this.fluxInstanceId}`);
+    }
+  }
+  handleSocketError(error) {
+    PicoLogger.log(`\u274C Error: "${error.message}".`, this.fluxInstanceId);
+  }
   /**
    * Handles incoming WebSocket messages.
    */
@@ -1068,9 +1150,6 @@ var FluxClientData = class {
 };
 
 // packages/flux/agent/src/lib/flux-agent.class.ts
-globalThis.agentLoadCount ??= 0;
-globalThis.agentLoadCount++;
-console.log(`[flux-agent] Reloaded ${globalThis.agentLoadCount} time(s)`);
 var DEFAULT_FLUX_DOMAIN = "https://mesh.persistica.io";
 var FluxAgent = class {
   constructor(networkId, options) {
@@ -1093,10 +1172,10 @@ var FluxAgent = class {
   async connect(identification, clientUId) {
     const domain = this.options?.domain ?? DEFAULT_FLUX_DOMAIN;
     this.stateManager.emitNetworkState("authorizing");
-    if (clientUId && !validateAgentUIDOrThrow(clientUId)) {
-      throw new Error("Will never be thrown");
-    }
     try {
+      if (clientUId && !validateAgentUIDOrThrow(clientUId)) {
+        throw new Error("Will never be thrown");
+      }
       const ticket = await retryOrThrow(
         async () => {
           return authenticateAgentOrThrow(
@@ -1134,8 +1213,7 @@ var FluxAgent = class {
         }
       );
       this.fluxClientData.updateWsConnection(this.fluxWebSocketConnection);
-      const fluxNetworkConnection = await this.fluxWebSocketConnection.connectToNetwork();
-      return fluxNetworkConnection;
+      return await this.fluxWebSocketConnection.connectToNetwork();
     } catch (error) {
       this.stateManager.emitNetworkState("auth-error");
       return Promise.reject(error);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@persistica/flux-agent",
-    "version": "0.0.18",
+    "version": "0.0.20",
     "description": "Persistica Flux Agent",
     "type": "module",
     "keywords": [],

package/src/lib/flux-agent.class.d.ts

@@ -1,6 +1,3 @@
-declare global {
-    var agentLoadCount: number | null | undefined;
-}
 import type { TMessageCallback } from '@flux/shared/ws';
 import type { FluxAgentNetworkConnection } from '@flux/shared/connection';
 export declare class FluxAgent {