@floomhq/floom 1.0.31 → 1.0.33

package/dist/errors.js

@@ -28,6 +28,9 @@ export function friendlyHttp(status, action) {
     if (status === 413) {
         return new FloomError("That file is too large to publish.");
     }
+    if (status === 429) {
+        return new FloomError("Floom is rate limiting requests.", "The CLI retries rate-limited requests automatically. Try again in a moment if this persists.");
+    }
     if (status >= 500) {
         return new FloomError("Floom is having trouble right now.", "Try again in a moment.");
     }

package/dist/lib/api.js

@@ -4,37 +4,46 @@ import { friendlyHttp, friendlyNetwork, FloomError } from "../errors.js";
  * patterns but throws FloomError instances so the CLI's printError gives
  * users a clean message instead of a stack trace.
  */
-export const DEFAULT_TIMEOUT_MS = 15_000;
+export const DEFAULT_TIMEOUT_MS = 60_000;
 export async function floomFetch(url, action, opts = {}) {
     const headers = { ...(opts.headers ?? {}) };
     if (opts.token)
         headers.authorization = `Bearer ${opts.token}`;
     if (opts.body !== undefined)
         headers["content-type"] = "application/json";
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), requestTimeoutMs(opts.timeoutMs));
-    let res;
-    try {
-        res = await fetch(url, {
-            method: opts.method ?? "GET",
-            headers,
-            signal: controller.signal,
-            ...(opts.body !== undefined ? { body: JSON.stringify(opts.body) } : {}),
-        });
-    }
-    catch (err) {
-        if (err.name === "AbortError") {
-            throw new FloomError(`Request timed out while trying to ${action}.`, "Try again in a moment.");
+    const attempts = Math.max(1, 1 + rateLimitRetries(opts.rateLimitRetries));
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), requestTimeoutMs(opts.timeoutMs));
+        let res;
+        try {
+            res = await fetch(url, {
+                method: opts.method ?? "GET",
+                headers,
+                signal: controller.signal,
+                ...(opts.body !== undefined ? { body: JSON.stringify(opts.body) } : {}),
+            });
         }
-        throw friendlyNetwork(err);
-    }
-    finally {
-        clearTimeout(timer);
-    }
-    if (opts.checkOk !== false && !res.ok) {
-        throw friendlyHttp(res.status, action);
+        catch (err) {
+            if (err.name === "AbortError") {
+                throw new FloomError(`Request timed out while trying to ${action}.`, "Try again in a moment.");
+            }
+            throw friendlyNetwork(err);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        if (res.status === 429 && attempt < attempts - 1) {
+            await drainResponse(res);
+            await sleep(rateLimitDelayMs(res, attempt));
+            continue;
+        }
+        if (opts.checkOk !== false && !res.ok) {
+            throw friendlyHttp(res.status, action);
+        }
+        return res;
     }
-    return res;
+    throw new FloomError(`Request failed (HTTP 429) while trying to ${action}.`);
 }
 function requestTimeoutMs(override) {
     if (override !== undefined)
@@ -44,6 +53,50 @@ function requestTimeoutMs(override) {
         return fromEnv;
     return DEFAULT_TIMEOUT_MS;
 }
+function rateLimitRetries(override) {
+    if (override !== undefined)
+        return Math.max(0, Math.floor(override));
+    const fromEnv = Number(process.env.FLOOM_RATE_LIMIT_RETRIES);
+    if (Number.isFinite(fromEnv) && fromEnv >= 0)
+        return Math.floor(fromEnv);
+    return 8;
+}
+function rateLimitDelayMs(res, attempt) {
+    const retryAfter = res.headers.get("retry-after");
+    if (retryAfter) {
+        const seconds = Number(retryAfter);
+        if (Number.isFinite(seconds) && seconds >= 0) {
+            return capRateLimitDelay(seconds * 1000);
+        }
+        const dateMs = Date.parse(retryAfter);
+        if (Number.isFinite(dateMs)) {
+            return capRateLimitDelay(Math.max(0, dateMs - Date.now()));
+        }
+    }
+    const resetSeconds = Number(res.headers.get("x-ratelimit-reset"));
+    if (Number.isFinite(resetSeconds) && resetSeconds > 0) {
+        return capRateLimitDelay(Math.max(0, (resetSeconds * 1000) - Date.now()));
+    }
+    const base = Number(process.env.FLOOM_RATE_LIMIT_RETRY_MS);
+    const fallback = Number.isFinite(base) && base >= 0 ? base : 1_000;
+    return capRateLimitDelay(fallback * (attempt + 1));
+}
+function capRateLimitDelay(ms) {
+    const fromEnv = Number(process.env.FLOOM_RATE_LIMIT_MAX_WAIT_MS);
+    const max = Number.isFinite(fromEnv) && fromEnv > 0 ? fromEnv : 65_000;
+    return Math.min(Math.max(0, ms), max);
+}
+async function drainResponse(res) {
+    try {
+        await res.arrayBuffer();
+    }
+    catch {
+        // Ignore bodies from rate-limit responses; the retry decision is header-based.
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 export async function getJson(url, action, token) {
     const res = await floomFetch(url, action, token ? { token } : {});
     return (await res.json());

package/dist/sync-manifest.js

@@ -5,7 +5,7 @@ import { CONFIG_DIR } from "./config.js";
 const MANIFEST_VERSION = 1;
 const MANIFEST_PATH = join(CONFIG_DIR, "sync-manifest.json");
 const LOCK_PATH = join(CONFIG_DIR, "sync.lock");
-const LOCK_TIMEOUT_MS = 15_000;
+const LOCK_TIMEOUT_MS = 60_000;
 const LOCK_STALE_MS = 5 * 60_000;
 const SLUG_RE = /^[A-Za-z0-9_-]{1,128}$/;
 const FD_PATH_ROOT = "/proc/self/fd";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floomhq/floom",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "description": "Sync AI skills across agents and machines.",
   "license": "MIT",
   "type": "module",