@persistica/flux-agent 0.0.35 → 0.0.37

package/index.js

@@ -726,6 +726,7 @@ var ChannelStateManager = class {
 };
 
 // libs/flux/shared/connection/src/lib/flux-ws-connection.ts
+var RECONNECT_DELAY_MS = 2e3;
 var createWSConnection = (id, ticket, stateManager, onReconnectCallback, options) => {
   return new FluxWebSocketConnection(
     id,
@@ -757,8 +758,11 @@ var FluxWebSocketConnection = class {
     this.socket = new FluxWebSocketClientConnection(
       {
         url: url.toString(),
-        autoReconnect: true,
-        reconnectDelay: 2e3,
+        // 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
       }
     );
@@ -780,18 +784,12 @@ var FluxWebSocketConnection = class {
   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);
@@ -976,6 +974,17 @@ var FluxWebSocketConnection = class {
       this.fluxInstanceId
     );
     this.stateManager.emitNetworkState(reason === "kicked" ? "kicked" : "disconnected");
+    setTimeout(
+      () => {
+        Promise.resolve(this.onReconnectCallback()).catch((error) => {
+          PicoLogger.error(
+            `Failed to sign on again: ${error instanceof Error ? error.message : String(error)}`,
+            this.fluxInstanceId
+          );
+        });
+      },
+      reason === "kicked" ? RECONNECTION_DELAY_ON_KICK_MS : RECONNECT_DELAY_MS
+    );
   }
   handleSocketConnecting(retryAttempt) {
     this.stateManager.emitNetworkState("connecting");
@@ -1223,8 +1232,12 @@ var retryOrThrow = async (fn, shouldRetry, options) => {
       if (attempt >= options.retries || !shouldRetry(err)) {
         throw err;
       }
-      if (options.delayMs > 0 || overrideDelay && overrideDelay > 0) {
-        const delay = overrideDelay ?? options.delayMs;
+      const backedOff = Math.min(
+        options.maxDelayMs ?? Number.POSITIVE_INFINITY,
+        options.delayMs * (options.backoffFactor ?? 1) ** attempt
+      );
+      const delay = overrideDelay ?? backedOff;
+      if (delay > 0) {
         await new Promise((res) => setTimeout(
           res,
           delay
@@ -1235,6 +1248,35 @@ var retryOrThrow = async (fn, shouldRetry, options) => {
   throw new Error("Retry loop exited unexpectedly.");
 };
 
+// libs/flux/shared/utils/src/lib/connection-errors.ts
+var RetryableError = class extends Error {
+};
+var ConnectionError = class extends RetryableError {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "ConnectionError";
+  }
+  statusCode;
+};
+var AuthenticationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+var EndpointNotFoundError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EndpointNotFoundError";
+  }
+};
+var isRetryableConnectionError = (error) => error instanceof RetryableError;
+var isRetryableAuthStatus = (status) => status >= 500 || status === 429;
+var asConnectionError = (error, origin) => new ConnectionError(
+  `Failed to reach mesh server at ${origin}: ${error instanceof Error ? error.message : "Unknown connection error"}`
+);
+
 // libs/flux/shared/utils/src/lib/machine-id.util.ts
 var validateMachineUID = (machineUID) => {
   if (typeof machineUID !== "string") {
@@ -1293,32 +1335,47 @@ var authenticateAgentOrThrow = async (networkId, domain, unknownIdentificationPa
   if (clientInfo.machineUID && validateMachineUID(clientInfo.machineUID)) {
     url.searchParams.set("machineUID", clientInfo.machineUID);
   }
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "text/plain",
-      "x-flux-content-type": typeof unknownIdentificationPayload === "string" ? "text/plain" : "application/json",
-      "Accept": "text/plain"
-    },
-    body: customPayload
-  });
-  if (!response.ok) {
-    const textResponse = await response.text();
-    if (response.status === 401) {
-      if (textResponse.startsWith(NetworkAuthorityNotFoundError.message)) {
-        throw new NetworkAuthorityNotFoundError(networkId);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "text/plain",
+        "x-flux-content-type": typeof unknownIdentificationPayload === "string" ? "text/plain" : "application/json",
+        "Accept": "text/plain"
+      },
+      body: customPayload
+    });
+    if (!response.ok) {
+      const textResponse = await response.text();
+      if (response.status === 401) {
+        if (textResponse.startsWith(NetworkAuthorityNotFoundError.message)) {
+          throw new NetworkAuthorityNotFoundError(networkId);
+        }
+        throw new AuthenticationError(textResponse ? `Auth failed: 401 - ${textResponse}` : "Auth failed: 401");
+      }
+      if (response.status === 404) {
+        throw new EndpointNotFoundError(`Mesh server not found at ${url.origin}.`);
+      }
+      const message = textResponse ? `Auth failed: ${response.status} - ${textResponse}` : `Auth failed: ${response.status}`;
+      if (isRetryableAuthStatus(response.status)) {
+        throw new ConnectionError(message, response.status);
       }
+      throw new Error(message);
     }
-    if (response.status === 404) {
-      throw new Error(`Mesh server not found at ${url.origin}.`);
+    const result = await response.text();
+    if (!checkAuthTicketShape(result)) {
+      throw new Error("Auth failed: unexpected response");
     }
-    throw new Error(textResponse ? `Auth failed: ${response.status} - ${textResponse}` : `Auth failed: ${response.status}`);
-  }
-  const result = await response.text();
-  if (!checkAuthTicketShape(result)) {
-    throw new Error("Auth failed: unexpected response");
+    return result;
+  } catch (error) {
+    if (error instanceof NetworkAuthorityNotFoundError || error instanceof AuthenticationError || error instanceof EndpointNotFoundError || error instanceof RetryableError) {
+      throw error;
+    }
+    if (error instanceof Error && error.message.startsWith("Auth failed:")) {
+      throw error;
+    }
+    throw asConnectionError(error, url.origin);
   }
-  return result;
 };
 
 // packages/flux/agent/src/lib/connector/flux-client-data.class.ts
@@ -1369,6 +1426,8 @@ var FluxAgent = class {
         throw new Error("Will never be thrown");
       }
       let warnedWaitingForAuthority = false;
+      let warnedMeshUnreachable = false;
+      let lastError;
       const ticket = await retryOrThrow(
         async () => {
           return authenticateAgentOrThrow(
@@ -1381,8 +1440,15 @@ var FluxAgent = class {
             }
           );
         },
-        // Retry if no authority was found yet
-        (error) => error instanceof NetworkAuthorityNotFoundError,
+        // Retry while no Authority has appeared yet, and while the mesh
+        // itself is unreachable. The latter used to fall straight through
+        // to the caller, so a network blip during startup left the Agent
+        // permanently disconnected while an Authority in the same
+        // situation would have retried through it.
+        (error) => {
+          lastError = error;
+          return error instanceof NetworkAuthorityNotFoundError || isRetryableConnectionError(error);
+        },
         {
           // Fixed by the SDK, not the consuming app: Agents run on untrusted client
           // machines, so the mesh operator — not the app — controls how long an Agent
@@ -1390,6 +1456,16 @@ var FluxAgent = class {
           retries: MAX_CONNECT_ATTEMPTS,
           delayMs: 500,
           onRetry: (attempt, retries) => {
+            if (isRetryableConnectionError(lastError)) {
+              this.stateManager.emitNetworkState("authorizing");
+              if (!warnedMeshUnreachable) {
+                warnedMeshUnreachable = true;
+                console.warn(
+                  `[flux-agent] Cannot reach the mesh at '${domain}'. Retrying in the background up to ${retries} times; the Agent connects on its own once the mesh answers. If this never resolves, check the 'domain' option points at the Mesh (not the Portal).`
+                );
+              }
+              return Math.min(3e4, 500 * 2 ** attempt);
+            }
             this.stateManager.emitNetworkState("waiting-for-authority");
             if (!warnedWaitingForAuthority) {
               warnedWaitingForAuthority = true;

package/package.json

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