@persistica/flux-agent 0.0.37 → 0.0.39

package/index.js

@@ -98,6 +98,14 @@ var isClientId = (id) => {
   return regex.test(id);
 };
 
+// libs/flux/shared/types/src/lib/channels/channel-capacity.utils.ts
+var MAX_CHANNEL_MEMBERS_BY_SUBSCRIPTION_TYPE = {
+  free: 25,
+  medium: 500,
+  high: 1e5
+};
+var MAX_CHANNEL_MEMBERS = MAX_CHANNEL_MEMBERS_BY_SUBSCRIPTION_TYPE.high;
+
 // libs/flux/shared/ws/src/lib/rpc/rpc-server.class.ts
 var RPCServer = class {
   methods = /* @__PURE__ */ new Map();
@@ -142,6 +150,7 @@ var WebSocketClient = class extends RPCServer {
     open: [],
     message: [],
     close: [],
+    "connect-failed": [],
     error: [],
     connecting: []
   };
@@ -158,6 +167,10 @@ var WebSocketClient = class extends RPCServer {
   // The server proved it answers pings on this connection
   closeHandled = false;
   // Guards against running the close path twice (heartbeat + late onclose)
+  // The current `connect()` promise's reject, held so the close path can settle a
+  // socket that dies before it opens — `onclose` cancels the connection timeout,
+  // so without this the promise has nothing left to settle it (see #508).
+  pendingConnectReject;
   constructor(options) {
     super();
     this.options = {
@@ -175,6 +188,7 @@ var WebSocketClient = class extends RPCServer {
   connect() {
     return new Promise((resolve, reject) => {
       this.closeHandled = false;
+      this.pendingConnectReject = reject;
       this.emit("connecting", this.reconnectAttempts);
       const socket = new WebSocket(
         this.options.url
@@ -183,6 +197,7 @@ var WebSocketClient = class extends RPCServer {
       const timeout = setTimeout(() => {
         if (socket.readyState !== WebSocket.OPEN) {
           socket.close();
+          this.pendingConnectReject = void 0;
           reject(new Error("Connection timeout"));
         }
       }, this.options.connectionTimeout);
@@ -193,6 +208,7 @@ var WebSocketClient = class extends RPCServer {
         }
         this.reconnectAttempts = 0;
         this.isOpen = true;
+        this.pendingConnectReject = void 0;
         this.startHeartbeat();
         this.emit("open");
         resolve();
@@ -234,6 +250,7 @@ var WebSocketClient = class extends RPCServer {
     }
     this.closeHandled = true;
     this.stopHeartbeat();
+    const neverOpened = !this.isOpen;
     if (this.isOpen) {
       this.emit(
         "close",
@@ -241,7 +258,16 @@ var WebSocketClient = class extends RPCServer {
       );
       this.isOpen = false;
     }
-    if (this.options.autoReconnect && (this.options.retries === void 0 || this.reconnectAttempts < this.options.retries)) {
+    const willRetry = this.options.autoReconnect === true && (this.options.retries === void 0 || this.reconnectAttempts < this.options.retries);
+    if (neverOpened) {
+      const rejectPendingConnect = this.pendingConnectReject;
+      this.pendingConnectReject = void 0;
+      rejectPendingConnect?.(new Error("WebSocket closed before the connection was established"));
+      if (!willRetry) {
+        this.emit("connect-failed");
+      }
+    }
+    if (willRetry) {
       const delay = wasKicked ? RECONNECTION_DELAY_ON_KICK_MS : Math.min(
         this.options.maxReconnectDelay ?? Number.POSITIVE_INFINITY,
         (this.options.reconnectDelay ?? 0) * 2 ** this.reconnectAttempts
@@ -323,6 +349,7 @@ var WebSocketClient = class extends RPCServer {
     this.eventListeners.open = [];
     this.eventListeners.message = [];
     this.eventListeners.close = [];
+    this.eventListeners["connect-failed"] = [];
     this.eventListeners.connecting = [];
     this.eventListeners.error = [];
   }
@@ -727,6 +754,7 @@ var ChannelStateManager = class {
 
 // libs/flux/shared/connection/src/lib/flux-ws-connection.ts
 var RECONNECT_DELAY_MS = 2e3;
+var MAX_SIGN_ON_RETRY_DELAY_MS = 3e4;
 var createWSConnection = (id, ticket, stateManager, onReconnectCallback, options) => {
   return new FluxWebSocketConnection(
     id,
@@ -793,6 +821,7 @@ var FluxWebSocketConnection = class {
   };
   socketMessageHandler = this.handleMessage.bind(this);
   socketCloseHandler = (reason) => this.handleSocketClose(reason);
+  socketConnectFailedHandler = () => this.handleSocketConnectFailed();
   socketConnectingHandler = (retryAttempt) => this.handleSocketConnecting(retryAttempt);
   socketErrorHandler = (error) => this.handleSocketError(error);
   /**
@@ -834,7 +863,7 @@ var FluxWebSocketConnection = class {
       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.socket.on("message", this.socketMessageHandler).on("close", this.socketCloseHandler).on("connect-failed", this.socketConnectFailedHandler).on("connecting", this.socketConnectingHandler).on("error", this.socketErrorHandler);
     this.socket.connect().catch(this.socketErrorHandler);
     return this.connectPromise;
   }
@@ -974,6 +1003,33 @@ var FluxWebSocketConnection = class {
       this.fluxInstanceId
     );
     this.stateManager.emitNetworkState(reason === "kicked" ? "kicked" : "disconnected");
+    this.scheduleSignOn(reason === "kicked" ? RECONNECTION_DELAY_ON_KICK_MS : RECONNECT_DELAY_MS);
+  }
+  /**
+   * A socket that died before it ever opened. It emits no 'close' — there was no
+   * open connection to lose — and the low-level client does not re-dial it, since
+   * the ticket in its URL is single-use and expiring. Signing on again is the only
+   * way back, and nothing else will start it: before this, a socket that failed
+   * this way left the Authority up, silent and unregistered, until a human
+   * restarted the process (#508).
+   */
+  handleSocketConnectFailed() {
+    this.webSocketClient = void 0;
+    this.connectPromiseResolver = void 0;
+    this.connectPromise = void 0;
+    PicoLogger.log("\u{1F50C}\u{1F534} The connection failed before it was established", this.fluxInstanceId);
+    this.stateManager.emitNetworkState("disconnected");
+    this.scheduleSignOn(RECONNECT_DELAY_MS);
+  }
+  /**
+   * Signs on again from scratch: new handshake, new ticket, new connection.
+   * Driven by the disconnect, not by a successful reconnect — with an expired
+   * ticket there is no successful reconnect to hang this off.
+   *
+   * `disconnect()` does not reach here: it clears the socket's event subscribers,
+   * so nothing is emitted and nothing signs on again.
+   */
+  scheduleSignOn(delayMs) {
     setTimeout(
       () => {
         Promise.resolve(this.onReconnectCallback()).catch((error) => {
@@ -981,9 +1037,10 @@ var FluxWebSocketConnection = class {
             `Failed to sign on again: ${error instanceof Error ? error.message : String(error)}`,
             this.fluxInstanceId
           );
+          this.scheduleSignOn(Math.min(delayMs * 2, MAX_SIGN_ON_RETRY_DELAY_MS));
         });
       },
-      reason === "kicked" ? RECONNECTION_DELAY_ON_KICK_MS : RECONNECT_DELAY_MS
+      delayMs
     );
   }
   handleSocketConnecting(retryAttempt) {

package/package.json

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