@persistica/flux-agent 0.0.39 → 0.0.41

package/index.js

@@ -703,6 +703,18 @@ var ChannelStateManager = class {
     }
     return Promise.reject(new Error("Not connected"));
   }
+  /**
+   * Re-subscribes every joined channel on a fresh socket. The mesh ties
+   * channel membership to the socket, so after a re-sign-on nothing is joined
+   * even though the channels — and their use counts — live on here unchanged.
+   * The mesh answers each with a subscribe ack nobody awaits, which
+   * `FluxWebSocketConnection.handleMessage` swallows.
+   */
+  resubscribeJoinedChannels(webSocketClient) {
+    for (const channelName of this.joinedChannels.keys()) {
+      webSocketClient.send(`${SUBSCRIBE_NETWORK_CHANNEL_NAME}:${channelName}`);
+    }
+  }
   /**
    * Leave a channel.
    */
@@ -780,20 +792,7 @@ var FluxWebSocketConnection = class {
       secretKey: this.options.secretKey,
       retries: this.options.retries ?? 1e4
     };
-    const url = new URL(this.options.domain);
-    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-    url.searchParams.set("token", this.token);
-    this.socket = new FluxWebSocketClientConnection(
-      {
-        url: url.toString(),
-        // The URL carries a mesh-issued ticket that expires (15 minutes)
-        // long before this connection does. Re-dialling it is pointless —
-        // the mesh answers 'jwt expired' every time — so coming back is
-        // `onReconnectCallback`'s job: it signs on again from scratch.
-        autoReconnect: false,
-        retries: this.options.retries
-      }
-    );
+    this.socket = this.createSocket(this.token);
     this.interceptPackageTypeMessages("isReady", this.readyInterceptor);
   }
   fluxInstanceId;
@@ -804,6 +803,9 @@ var FluxWebSocketConnection = class {
   // ****************************************************************************
   // *** State
   // ****************************************************************************
+  // Mutable: a re-sign-on builds a fresh socket — the ticket is baked into its
+  // URL — but keeps this connection object, so every handle and listener
+  // registered against it survives (#536).
   socket;
   callbacks = /* @__PURE__ */ new Set();
   channelCallbacks = /* @__PURE__ */ new Map();
@@ -813,6 +815,9 @@ var FluxWebSocketConnection = class {
   connectPromise;
   connectPromiseResolver;
   channelStateManager = new ChannelStateManager();
+  // Whether the authority-side channel-change subscription was requested. The
+  // mesh ties it to the socket, so a re-signed-on connection has to ask again.
+  subscribedToChannelChanges = false;
   // ****************************************************************************
   // *** Reused socket callbacks
   // ****************************************************************************
@@ -824,6 +829,27 @@ var FluxWebSocketConnection = class {
   socketConnectFailedHandler = () => this.handleSocketConnectFailed();
   socketConnectingHandler = (retryAttempt) => this.handleSocketConnecting(retryAttempt);
   socketErrorHandler = (error) => this.handleSocketError(error);
+  /**
+   * Builds the low-level socket. The URL embeds the single-use, expiring
+   * ticket, so every sign-on — the first one and every one after a drop —
+   * needs its own socket. `reconnect()` swaps the fresh one in.
+   */
+  createSocket(ticket) {
+    const url = new URL(this.options.domain);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    url.searchParams.set("token", ticket);
+    return new FluxWebSocketClientConnection(
+      {
+        url: url.toString(),
+        // The URL carries a mesh-issued ticket that expires (15 minutes)
+        // long before this connection does. Re-dialling it is pointless —
+        // the mesh answers 'jwt expired' every time — so coming back is
+        // `onReconnectCallback`'s job: it signs on again from scratch.
+        autoReconnect: false,
+        retries: this.options.retries
+      }
+    );
+  }
   /**
    * Intercepts messages of a given package type.
    */
@@ -867,6 +893,23 @@ var FluxWebSocketConnection = class {
     this.socket.connect().catch(this.socketErrorHandler);
     return this.connectPromise;
   }
+  /**
+   * Signs on again with a fresh ticket, keeping this connection object — and
+   * with it every channel handle and listener registered before the drop.
+   *
+   * A sign-on used to build a whole new connection, whose empty channel state
+   * left the old handles pointing at a dead socket: `publish()` was a silent
+   * no-op and `onPublish` listeners never fired again (#536).
+   *
+   * Only swaps the socket in; the caller's next `connect()` dials it.
+   */
+  reconnect(ticket) {
+    this.socket.close();
+    this.webSocketClient = void 0;
+    this.connectPromise = void 0;
+    this.connectPromiseResolver = void 0;
+    this.socket = this.createSocket(ticket);
+  }
   /**
    * Disconnects from the Flux platform.
    */
@@ -929,6 +972,8 @@ var FluxWebSocketConnection = class {
     if (this.webSocketClient) {
       const messageString = typeof message === "string" ? `s:${message}` : `o:${JSON.stringify(message)}`;
       this.webSocketClient.send(`${NETWORK_CHANNEL_PUBLISH}:${channelName}:${messageString}`);
+    } else {
+      console.warn(`Cannot publish to channel "${channelName}": the connection is down. Message dropped.`);
     }
   }
   /**
@@ -966,6 +1011,7 @@ var FluxWebSocketConnection = class {
    * Subscribes to the channel changes.
    */
   subscribeToChannelChanges() {
+    this.subscribedToChannelChanges = true;
     if (this.webSocketClient) {
       this.webSocketClient.send(AUTHORITY_CHANNEL_SUBSCRIBE);
     } else {
@@ -991,6 +1037,10 @@ var FluxWebSocketConnection = class {
   resolveConnectedSocket() {
     this.stateManager.emitNetworkState("connected");
     this.webSocketClient = this.socket;
+    this.channelStateManager.resubscribeJoinedChannels(this.socket);
+    if (this.subscribedToChannelChanges) {
+      this.socket.send(AUTHORITY_CHANNEL_SUBSCRIBE);
+    }
     const connectPromiseResolver = this.connectPromiseResolver;
     this.connectPromiseResolver = void 0;
     this.connectPromise = void 0;
@@ -1099,6 +1149,9 @@ var FluxWebSocketConnection = class {
         }
         return;
       }
+      case SUBSCRIBED_NETWORK_CHANNEL_NAME: {
+        return;
+      }
       case RPC_REQUEST: {
         const payload = JSON.parse(message_.substring(message_.indexOf(":") + 1));
         void this.socket.handleMessage(payload, (data) => {
@@ -1330,6 +1383,7 @@ var EndpointNotFoundError = class extends Error {
 };
 var isRetryableConnectionError = (error) => error instanceof RetryableError;
 var isRetryableAuthStatus = (status) => status >= 500 || status === 429;
+var AUTH_FETCH_TIMEOUT_MS = 6e4;
 var asConnectionError = (error, origin) => new ConnectionError(
   `Failed to reach mesh server at ${origin}: ${error instanceof Error ? error.message : "Unknown connection error"}`
 );
@@ -1400,7 +1454,9 @@ var authenticateAgentOrThrow = async (networkId, domain, unknownIdentificationPa
         "x-flux-content-type": typeof unknownIdentificationPayload === "string" ? "text/plain" : "application/json",
         "Accept": "text/plain"
       },
-      body: customPayload
+      body: customPayload,
+      // A timeout rejects like any transport failure, so the caller retries it (#541).
+      signal: AbortSignal.timeout(AUTH_FETCH_TIMEOUT_MS)
     });
     if (!response.ok) {
       const textResponse = await response.text();
@@ -1534,22 +1590,26 @@ var FluxAgent = class {
           }
         }
       );
-      this.fluxWebSocketConnection = createWSConnection(
-        this.id,
-        ticket,
-        this.stateManager,
-        async () => {
-          await this.connect(
-            identification,
-            clientUId
-          );
-        },
-        {
-          ...this.options,
-          domain
-        }
-      );
-      this.fluxClientData.updateWsConnection(this.fluxWebSocketConnection);
+      if (this.fluxWebSocketConnection) {
+        this.fluxWebSocketConnection.reconnect(ticket);
+      } else {
+        this.fluxWebSocketConnection = createWSConnection(
+          this.id,
+          ticket,
+          this.stateManager,
+          async () => {
+            await this.connect(
+              identification,
+              clientUId
+            );
+          },
+          {
+            ...this.options,
+            domain
+          }
+        );
+        this.fluxClientData.updateWsConnection(this.fluxWebSocketConnection);
+      }
       return await this.fluxWebSocketConnection.connectToNetwork();
     } catch (error) {
       this.stateManager.emitNetworkState("auth-error");

package/package.json

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