@flamingo-stack/openframe-frontend-core 0.0.503 → 0.0.504-snapshot.20260801181709

package/dist/utils/index.cjs

@@ -3112,6 +3112,176 @@ function assertSameOrigin(url) {
   }
 }
 
+// src/utils/sse-subscription.ts
+var DEFAULT_SILENCE_TIMEOUT_MS = 45e3;
+var DEFAULT_MAX_BACKOFF_MS = 3e4;
+var DEFAULT_INITIAL_BACKOFF_MS = 1e3;
+function createSseSubscription(options) {
+  const {
+    url,
+    fetchImpl = embedAuthedFetch,
+    onEvent,
+    onStatusChange,
+    silenceTimeoutMs = DEFAULT_SILENCE_TIMEOUT_MS,
+    maxBackoffMs = DEFAULT_MAX_BACKOFF_MS,
+    initialBackoffMs = DEFAULT_INITIAL_BACKOFF_MS
+  } = options;
+  let closed = false;
+  let attempt = 0;
+  let generation = 0;
+  let abortController = null;
+  let retryTimerId = null;
+  let silenceTimerId = null;
+  const setStatus = (status) => {
+    if (closed && status !== "closed") return;
+    onStatusChange?.(status);
+  };
+  const clearTimers = () => {
+    if (retryTimerId) {
+      clearTimeout(retryTimerId);
+      retryTimerId = null;
+    }
+    if (silenceTimerId) {
+      clearTimeout(silenceTimerId);
+      silenceTimerId = null;
+    }
+  };
+  const armSilenceTimer = () => {
+    if (silenceTimerId) clearTimeout(silenceTimerId);
+    silenceTimerId = setTimeout(() => {
+      abortController?.abort();
+    }, silenceTimeoutMs);
+  };
+  const scheduleReconnect = () => {
+    if (closed || retryTimerId) return;
+    setStatus("reconnecting");
+    const backoff = Math.min(maxBackoffMs, initialBackoffMs * 2 ** attempt);
+    const jitter = backoff * 0.25 * Math.random();
+    attempt += 1;
+    retryTimerId = setTimeout(() => {
+      retryTimerId = null;
+      void connect();
+    }, backoff + jitter);
+  };
+  const parseFrame = (rawFrame) => {
+    let eventName = "message";
+    const dataLines = [];
+    for (const line of rawFrame.split("\n")) {
+      if (line.startsWith(":")) continue;
+      if (line.startsWith("event:")) {
+        eventName = line.slice(6).trim() || "message";
+      } else if (line.startsWith("data:")) {
+        dataLines.push(line.slice(5).trimStart());
+      }
+    }
+    if (dataLines.length === 0) return;
+    const rawData = dataLines.join("\n");
+    let data = rawData;
+    try {
+      data = JSON.parse(rawData);
+    } catch {
+    }
+    try {
+      onEvent(eventName, data);
+    } catch (err) {
+      console.error("[sse-subscription] onEvent handler threw:", err);
+    }
+  };
+  const connect = async () => {
+    if (closed) return;
+    const gen = ++generation;
+    setStatus("connecting");
+    abortController = new AbortController();
+    let response;
+    try {
+      response = await fetchImpl(url, {
+        method: "GET",
+        // Explicit Accept — embedAuthedFetch otherwise injects
+        // `Content-Type: application/json` defaults meant for POSTs.
+        headers: { Accept: "text/event-stream" },
+        signal: abortController.signal
+      });
+    } catch {
+      if (!closed && gen === generation) scheduleReconnect();
+      return;
+    }
+    if (closed || gen !== generation) return;
+    if (response.status === 204) {
+      setStatus("no-stream");
+      return;
+    }
+    if (!response.ok) {
+      const retryable = response.status === 408 || response.status === 429 || response.status >= 500;
+      if (retryable) {
+        scheduleReconnect();
+        return;
+      }
+      const blockLayer = response.headers.get("x-block-layer");
+      console.warn(
+        `[sse-subscription] terminal ${response.status} for ${url}${blockLayer ? ` (x-block-layer: ${blockLayer})` : ""} \u2014 not retrying`
+      );
+      setStatus("terminal");
+      return;
+    }
+    if (!response.body) {
+      scheduleReconnect();
+      return;
+    }
+    attempt = 0;
+    setStatus("open");
+    armSilenceTimer();
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (closed || gen !== generation) return;
+        if (done) break;
+        armSilenceTimer();
+        buffer += decoder.decode(value, { stream: true });
+        for (; ; ) {
+          const boundary = buffer.indexOf("\n\n");
+          if (boundary === -1) break;
+          const rawFrame = buffer.slice(0, boundary);
+          buffer = buffer.slice(boundary + 2);
+          parseFrame(rawFrame);
+        }
+      }
+    } catch {
+    } finally {
+      if (silenceTimerId) {
+        clearTimeout(silenceTimerId);
+        silenceTimerId = null;
+      }
+      try {
+        reader.releaseLock();
+      } catch {
+      }
+    }
+    if (!closed && gen === generation) scheduleReconnect();
+  };
+  void connect();
+  return {
+    close: () => {
+      if (closed) return;
+      closed = true;
+      generation += 1;
+      clearTimers();
+      abortController?.abort();
+      onStatusChange?.("closed");
+    },
+    reconnectNow: () => {
+      if (closed) return;
+      generation += 1;
+      clearTimers();
+      attempt = 0;
+      abortController?.abort();
+      void connect();
+    }
+  };
+}
+
 // src/utils/sse-decision-frame.ts
 async function readLeadingDecisionFrame(response) {
   const reader = response.body?.getReader();
@@ -4277,6 +4447,7 @@ exports.clearWalkthroughDismissal = clearWalkthroughDismissal;
 exports.clickupTaskUrl = clickupTaskUrl;
 exports.cn = cn;
 exports.consumeAccessCode = consumeAccessCode;
+exports.createSseSubscription = createSseSubscription;
 exports.createUTCTimestamp = createUTCTimestamp;
 exports.deepClone = deepClone;
 exports.delay = delay;