@persistica/flux-agent 0.0.35 → 0.0.36

package/index.js

@@ -1223,8 +1223,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 +1239,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 +1326,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 +1417,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 +1431,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 +1447,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.36",
     "description": "Persistica Flux Agent",
     "type": "module",
     "keywords": [],