tandem-editor 0.12.0 → 0.13.5

package/dist/channel/index.js

@@ -18007,6 +18007,7 @@ var TANDEM_REPO_URL = "https://github.com/bloknayrb/tandem";
 var TANDEM_ISSUES_NEW_URL = `${TANDEM_REPO_URL}/issues/new`;
 var MAX_FILE_SIZE = 50 * 1024 * 1024;
 var SESSION_MAX_AGE = 30 * 24 * 60 * 60 * 1e3;
+var TANDEM_MODE_DEFAULT = "tandem";
 var CHANNEL_MAX_RETRIES = 5;
 var CHANNEL_RETRY_DELAY_MS = 2e3;
 var CHANNEL_CONNECT_FETCH_TIMEOUT_MS = 1e4;
@@ -18219,52 +18220,82 @@ var ToolErrorCodeSchema = external_exports.enum([
 var ChannelErrorCodeSchema = external_exports.enum(["CHANNEL_CONNECT_FAILED", "MONITOR_CONNECT_FAILED"]);
 var CHANNEL_CONNECT_FAILED = "CHANNEL_CONNECT_FAILED";
 
-// src/channel/event-bridge.ts
+// src/shared/sse-consumer.ts
 var AWARENESS_DEBOUNCE_MS = 500;
+var AWARENESS_CLEAR_MS = 3e3;
 var MODE_CACHE_TTL_MS = 2e3;
-async function startEventBridge(mcp, tandemUrl) {
+var STABLE_CONNECTION_MS = 6e4;
+var RETRY_MAX_DELAY_MS = 3e4;
+var shutdownTimers = { awarenessTimer: null, clearAwarenessTimer: null, lastDocumentId: null };
+var outstandingAwareness = /* @__PURE__ */ new Set();
+function trackAwareness(p) {
+  outstandingAwareness.add(p);
+  p.finally(() => outstandingAwareness.delete(p));
+}
+var cachedMode = TANDEM_MODE_DEFAULT;
+var cachedModeAt = 0;
+var cachedModeFailedAt = 0;
+var _modeRefreshInFlight = null;
+async function runEventConsumer(opts) {
+  await getCachedMode(opts.tandemUrl, opts.logPrefix).catch(() => {
+  });
   let retries = 0;
   let lastEventId;
   while (retries < CHANNEL_MAX_RETRIES) {
     try {
-      await connectAndStream(mcp, tandemUrl, lastEventId, (id) => {
-        lastEventId = id;
-        retries = 0;
+      await connectAndStreamOnce(opts, lastEventId, {
+        onEventId: (id) => {
+          lastEventId = id;
+        },
+        onStable: () => {
+          retries = 0;
+        }
       });
     } catch (err) {
       retries++;
       console.error(
-        `[Channel] SSE connection failed (${retries}/${CHANNEL_MAX_RETRIES}):`,
+        `${opts.logPrefix} SSE connection failed (${retries}/${CHANNEL_MAX_RETRIES}):`,
         err instanceof Error ? err.message : err
       );
       if (retries >= CHANNEL_MAX_RETRIES) {
-        console.error("[Channel] SSE connection exhausted, reporting error and exiting");
+        console.error(`${opts.logPrefix} SSE connection exhausted, reporting error and exiting`);
         try {
           await fetchWithTimeout(
-            `${tandemUrl}${API_CHANNEL_ERROR}`,
+            `${opts.tandemUrl}${API_CHANNEL_ERROR}`,
             {
               method: "POST",
               headers: { "Content-Type": "application/json" },
               body: JSON.stringify({
-                error: CHANNEL_CONNECT_FAILED,
-                message: `Channel shim lost connection after ${CHANNEL_MAX_RETRIES} retries.`
+                error: opts.errorCode,
+                message: `${opts.logPrefix} lost connection after ${CHANNEL_MAX_RETRIES} retries.`
               })
             },
             CHANNEL_ERROR_REPORT_TIMEOUT_MS
           );
         } catch (reportErr) {
           console.error(
-            "[Channel] Could not report failure to server:",
+            `${opts.logPrefix} Could not report failure to server:`,
             describeFetchError(reportErr, API_CHANNEL_ERROR, CHANNEL_ERROR_REPORT_TIMEOUT_MS)
           );
         }
+        opts.onExhaustion?.();
         process.exit(1);
       }
-      await new Promise((r) => setTimeout(r, CHANNEL_RETRY_DELAY_MS));
+      const delay = Math.min(CHANNEL_RETRY_DELAY_MS * 2 ** (retries - 1), RETRY_MAX_DELAY_MS);
+      console.error(
+        `${opts.logPrefix} Retrying in ${delay}ms (attempt ${retries}/${CHANNEL_MAX_RETRIES})...`
+      );
+      await new Promise((r) => setTimeout(r, delay));
     }
   }
+  console.error(
+    `${opts.logPrefix} Retry loop exited unexpectedly (retries=${retries}/${CHANNEL_MAX_RETRIES})`
+  );
+  process.exit(1);
 }
-async function connectAndStream(mcp, tandemUrl, lastEventId, onEventId) {
+async function connectAndStreamOnce(opts, lastEventId, cb) {
+  const onStable = cb.onStable ?? (() => {
+  });
   const headers = { Accept: "text/event-stream" };
   if (lastEventId) headers["Last-Event-ID"] = lastEventId;
   const connectCtrl = new AbortController();
@@ -18274,12 +18305,16 @@ async function connectAndStream(mcp, tandemUrl, lastEventId, onEventId) {
   );
   let res;
   try {
-    res = await authFetch(`${tandemUrl}${API_EVENTS}`, { headers, signal: connectCtrl.signal });
+    res = await authFetch(`${opts.tandemUrl}${API_EVENTS}`, {
+      headers,
+      signal: connectCtrl.signal
+    });
   } finally {
     clearTimeout(connectTimer);
   }
   if (!res.ok) throw new Error(`SSE endpoint returned ${res.status}`);
   if (!res.body) throw new Error("SSE endpoint returned no body");
+  const stableTimer = setTimeout(onStable, STABLE_CONNECTION_MS);
   const reader = res.body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
@@ -18292,13 +18327,10 @@ async function connectAndStream(mcp, tandemUrl, lastEventId, onEventId) {
       });
     }
   }, CHANNEL_SSE_INACTIVITY_TIMEOUT_MS / 4);
-  let awarenessTimer = null;
-  let clearAwarenessTimer = null;
   let pendingAwareness = null;
-  const AWARENESS_CLEAR_MS = 3e3;
-  function clearAwareness(documentId) {
-    fetchWithTimeout(
-      `${tandemUrl}${API_CHANNEL_AWARENESS}`,
+  function clearAwarenessNow(documentId) {
+    const p = fetchWithTimeout(
+      `${opts.tandemUrl}${API_CHANNEL_AWARENESS}`,
       {
         method: "POST",
         headers: { "Content-Type": "application/json" },
@@ -18311,7 +18343,7 @@ async function connectAndStream(mcp, tandemUrl, lastEventId, onEventId) {
       CHANNEL_AWARENESS_FETCH_TIMEOUT_MS
     ).catch((err) => {
       console.error(
-        "[Channel] clearAwareness failed (non-fatal):",
+        `${opts.logPrefix} Awareness clear failed:`,
         describeFetchError(
           err,
           `${API_CHANNEL_AWARENESS} clear`,
@@ -18319,13 +18351,15 @@ async function connectAndStream(mcp, tandemUrl, lastEventId, onEventId) {
         )
       );
     });
+    trackAwareness(p);
   }
   function flushAwareness() {
     if (!pendingAwareness) return;
     const event = pendingAwareness;
     pendingAwareness = null;
-    fetchWithTimeout(
-      `${tandemUrl}${API_CHANNEL_AWARENESS}`,
+    if (event.documentId) shutdownTimers.lastDocumentId = event.documentId;
+    const p = fetchWithTimeout(
+      `${opts.tandemUrl}${API_CHANNEL_AWARENESS}`,
       {
         method: "POST",
         headers: { "Content-Type": "application/json" },
@@ -18338,7 +18372,7 @@ async function connectAndStream(mcp, tandemUrl, lastEventId, onEventId) {
       CHANNEL_AWARENESS_FETCH_TIMEOUT_MS
     ).catch((err) => {
       console.error(
-        "[Channel] Awareness update failed:",
+        `${opts.logPrefix} Awareness update failed:`,
         describeFetchError(
           err,
           `${API_CHANNEL_AWARENESS} update`,
@@ -18346,13 +18380,17 @@ async function connectAndStream(mcp, tandemUrl, lastEventId, onEventId) {
         )
       );
     });
-    if (clearAwarenessTimer) clearTimeout(clearAwarenessTimer);
-    clearAwarenessTimer = setTimeout(() => clearAwareness(event.documentId), AWARENESS_CLEAR_MS);
+    trackAwareness(p);
+    if (shutdownTimers.clearAwarenessTimer) clearTimeout(shutdownTimers.clearAwarenessTimer);
+    shutdownTimers.clearAwarenessTimer = setTimeout(
+      () => clearAwarenessNow(event.documentId),
+      AWARENESS_CLEAR_MS
+    );
   }
   function scheduleAwareness(event) {
     pendingAwareness = event;
-    if (awarenessTimer) clearTimeout(awarenessTimer);
-    awarenessTimer = setTimeout(flushAwareness, AWARENESS_DEBOUNCE_MS);
+    if (shutdownTimers.awarenessTimer) clearTimeout(shutdownTimers.awarenessTimer);
+    shutdownTimers.awarenessTimer = setTimeout(flushAwareness, AWARENESS_DEBOUNCE_MS);
   }
   try {
     while (true) {
@@ -18380,84 +18418,135 @@ async function connectAndStream(mcp, tandemUrl, lastEventId, onEventId) {
           else if (line.startsWith("data: ")) data = line.slice(6);
         }
         if (!data) continue;
-        let event;
+        let raw;
         try {
-          event = parseTandemEvent(JSON.parse(data));
-        } catch {
+          raw = JSON.parse(data);
+        } catch (err) {
           console.error(
-            "[Channel] Malformed SSE event data (skipping), eventId=%s:",
-            eventId,
-            data.slice(0, 200)
+            `${opts.logPrefix} SSE JSON parse failed (eventId=${eventId ?? "none"}, len=${data.length}): ${err instanceof Error ? err.message : err}. Tail:`,
+            data.slice(Math.max(0, data.length - 200))
           );
-          if (eventId) onEventId(eventId);
+          if (eventId) cb.onEventId(eventId);
           continue;
         }
+        const event = parseTandemEvent(raw);
         if (!event) {
           console.error(
-            "[Channel] Invalid SSE event structure (skipping), eventId=%s:",
-            eventId,
-            data.slice(0, 200)
+            `${opts.logPrefix} SSE event failed validation (eventId=${eventId ?? "none"}): shape mismatch`
           );
-          if (eventId) onEventId(eventId);
+          if (eventId) cb.onEventId(eventId);
           continue;
         }
         if (event.type !== "chat:message") {
-          const mode = await getCachedMode(tandemUrl);
-          if (mode === "solo") {
-            console.error(`[Channel] Solo mode: suppressed ${event.type} event`);
-            if (eventId) onEventId(eventId);
+          refreshMode(opts.tandemUrl, opts.logPrefix);
+          if (getModeSync() === "solo") {
+            console.error(`${opts.logPrefix} Solo mode: suppressed ${event.type} event`);
+            if (eventId) cb.onEventId(eventId);
             continue;
           }
         }
         try {
-          await mcp.notification({
-            method: "notifications/claude/channel",
-            params: {
-              content: formatEventContent(event),
-              meta: formatEventMeta(event)
-            }
-          });
+          await opts.onEvent(event, eventId);
         } catch (err) {
-          console.error("[Channel] MCP notification failed (transport broken?):", err);
+          console.error(`${opts.logPrefix} onEvent failed (transport broken?):`, err);
           throw err;
         }
-        if (eventId) onEventId(eventId);
+        if (eventId) cb.onEventId(eventId);
         scheduleAwareness(event);
       }
     }
   } finally {
+    clearTimeout(stableTimer);
     clearInterval(watchdog);
-    if (awarenessTimer) clearTimeout(awarenessTimer);
-    if (clearAwarenessTimer) clearTimeout(clearAwarenessTimer);
+    if (shutdownTimers.awarenessTimer) clearTimeout(shutdownTimers.awarenessTimer);
+    if (shutdownTimers.clearAwarenessTimer) clearTimeout(shutdownTimers.clearAwarenessTimer);
+    shutdownTimers.awarenessTimer = null;
+    shutdownTimers.clearAwarenessTimer = null;
+    pendingAwareness = null;
   }
 }
-var cachedMode = "tandem";
-var cachedModeAt = 0;
-async function getCachedMode(tandemUrl) {
-  const now = Date.now();
-  if (now - cachedModeAt < MODE_CACHE_TTL_MS) return cachedMode;
+async function fetchMode(tandemUrl) {
   try {
     const res = await fetchWithTimeout(
       `${tandemUrl}${API_MODE}`,
       {},
       CHANNEL_MODE_FETCH_TIMEOUT_MS
     );
-    if (res.ok) {
-      const { mode } = await res.json();
-      cachedMode = mode;
-    } else {
-      console.error(`[Channel] Mode check returned ${res.status}, using cached: "${cachedMode}"`);
-    }
-    cachedModeAt = now;
+    if (!res.ok) return { ok: false, reason: `status ${res.status}` };
+    const body = await res.json();
+    const parsed = TandemModeSchema.safeParse(body.mode);
+    if (!parsed.success) return { ok: false, reason: `invalid mode ${JSON.stringify(body.mode)}` };
+    return { ok: true, mode: parsed.data };
   } catch (err) {
+    return { ok: false, reason: describeFetchError(err, API_MODE, CHANNEL_MODE_FETCH_TIMEOUT_MS) };
+  }
+}
+async function getCachedMode(tandemUrl, logPrefix = "[Tandem]") {
+  const now = Date.now();
+  if (now - cachedModeAt < MODE_CACHE_TTL_MS && cachedModeAt !== 0) return cachedMode;
+  const result = await fetchMode(tandemUrl);
+  if (!result.ok) {
+    if (cachedModeAt !== 0) {
+      console.error(
+        `${logPrefix} Mode check failed (${result.reason}), preserving last known mode '${cachedMode}'`
+      );
+      return cachedMode;
+    }
     console.error(
-      "[Channel] Mode check failed, delivering event (fail-open):",
-      describeFetchError(err, API_MODE, CHANNEL_MODE_FETCH_TIMEOUT_MS)
+      `${logPrefix} Mode check failed (${result.reason}), no prior mode \u2014 using cold-start default '${TANDEM_MODE_DEFAULT}'`
     );
-    cachedModeAt = now;
+    cachedMode = TANDEM_MODE_DEFAULT;
+    return TANDEM_MODE_DEFAULT;
   }
+  cachedMode = result.mode;
+  cachedModeAt = now;
+  return cachedMode;
+}
+function getModeSync() {
   return cachedMode;
 }
+function refreshMode(tandemUrl, logPrefix) {
+  if (_modeRefreshInFlight) return;
+  const now = Date.now();
+  if (now - cachedModeAt < MODE_CACHE_TTL_MS) return;
+  if (now - cachedModeFailedAt < MODE_CACHE_TTL_MS) return;
+  _modeRefreshInFlight = (async () => {
+    try {
+      const result = await fetchMode(tandemUrl);
+      if (result.ok) {
+        cachedMode = result.mode;
+        cachedModeAt = Date.now();
+        cachedModeFailedAt = 0;
+      } else {
+        cachedModeFailedAt = Date.now();
+        console.error(
+          `${logPrefix} Background mode refresh failed (${result.reason}), keeping cached`
+        );
+      }
+    } finally {
+      _modeRefreshInFlight = null;
+    }
+  })().catch((err) => {
+    console.error(`${logPrefix} refreshMode unexpected error:`, err);
+    cachedModeFailedAt = Date.now();
+  });
+}
+
+// src/channel/event-bridge.ts
+async function startEventBridge(mcp, tandemUrl) {
+  return runEventConsumer({
+    tandemUrl,
+    logPrefix: "[Channel]",
+    errorCode: CHANNEL_CONNECT_FAILED,
+    onEvent: (event) => mcp.notification({
+      method: "notifications/claude/channel",
+      params: {
+        content: formatEventContent(event),
+        meta: formatEventMeta(event)
+      }
+    })
+  });
+}
 
 // src/channel/run.ts
 async function runChannel(opts = {}) {