tandem-editor 0.11.2 → 0.13.0

package/dist/channel/index.js

@@ -17993,14 +17993,21 @@ var StdioServerTransport = class {
   }
 };
 
+// src/shared/api-paths.ts
+var API_EVENTS = "/api/events";
+var API_CHANNEL_AWARENESS = "/api/channel-awareness";
+var API_CHANNEL_ERROR = "/api/channel-error";
+var API_CHANNEL_REPLY = "/api/channel-reply";
+var API_CHANNEL_PERMISSION = "/api/channel-permission";
+var API_MODE = "/api/mode";
+
 // src/shared/constants.ts
 var DEFAULT_MCP_PORT = 3479;
 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 MAX_WS_PAYLOAD = 10 * 1024 * 1024;
-var IDLE_TIMEOUT = 30 * 60 * 1e3;
 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;
@@ -18030,7 +18037,7 @@ function resolveTandemUrlCandidate(override) {
   for (const url of candidates) {
     if (url !== void 0 && url.trim() !== "") return url.trim();
   }
-  return `http://localhost:${DEFAULT_MCP_PORT}`;
+  return `http://127.0.0.1:${DEFAULT_MCP_PORT}`;
 }
 function resolveAuthTokenCandidate(override) {
   const candidates = [
@@ -18186,52 +18193,109 @@ function formatEventMeta(event) {
   return meta;
 }
 
-// src/channel/event-bridge.ts
+// src/shared/types.ts
+var AnnotationTypeSchema = external_exports.enum(["highlight", "note", "comment"]);
+var AnnotationStatusSchema = external_exports.enum(["pending", "accepted", "dismissed"]);
+var HighlightColorSchema = external_exports.enum(["yellow", "green", "blue", "pink"]);
+var SeveritySchema = external_exports.enum(["info", "warning", "error", "success"]);
+var TandemModeSchema = external_exports.enum(["solo", "tandem"]);
+var AuthorSchema = external_exports.enum(["user", "claude", "import"]);
+var ReplyAuthorSchema = external_exports.enum(["user", "claude"]);
+var AnnotationActionSchema = external_exports.enum(["accept", "dismiss"]);
+var ExportFormatSchema = external_exports.enum(["markdown", "json"]);
+var DocumentFormatSchema = external_exports.enum(["md", "txt", "html", "docx"]);
+var ToolErrorCodeSchema = external_exports.enum([
+  "RANGE_GONE",
+  "RANGE_MOVED",
+  "FILE_LOCKED",
+  "FILE_NOT_FOUND",
+  "NO_DOCUMENT",
+  "INVALID_RANGE",
+  "INVALID_ARGUMENT",
+  "NOT_FOUND",
+  "ANNOTATION_RESOLVED",
+  "FORMAT_ERROR",
+  "PERMISSION_DENIED"
+]);
+var ChannelErrorCodeSchema = external_exports.enum(["CHANNEL_CONNECT_FAILED", "MONITOR_CONNECT_FAILED"]);
+var CHANNEL_CONNECT_FAILED = "CHANNEL_CONNECT_FAILED";
+
+// 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:",
-            describeFetchError(reportErr, "/api/channel-error", CHANNEL_ERROR_REPORT_TIMEOUT_MS)
+            `${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();
@@ -18241,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 = "";
@@ -18259,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" },
@@ -18278,17 +18343,23 @@ async function connectAndStream(mcp, tandemUrl, lastEventId, onEventId) {
       CHANNEL_AWARENESS_FETCH_TIMEOUT_MS
     ).catch((err) => {
       console.error(
-        "[Channel] clearAwareness failed (non-fatal):",
-        describeFetchError(err, "/api/channel-awareness clear", CHANNEL_AWARENESS_FETCH_TIMEOUT_MS)
+        `${opts.logPrefix} Awareness clear failed:`,
+        describeFetchError(
+          err,
+          `${API_CHANNEL_AWARENESS} clear`,
+          CHANNEL_AWARENESS_FETCH_TIMEOUT_MS
+        )
       );
     });
+    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" },
@@ -18301,21 +18372,25 @@ 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",
+          `${API_CHANNEL_AWARENESS} update`,
           CHANNEL_AWARENESS_FETCH_TIMEOUT_MS
         )
       );
     });
-    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) {
@@ -18343,80 +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;
+    const res = await fetchWithTimeout(
+      `${tandemUrl}${API_MODE}`,
+      {},
+      CHANNEL_MODE_FETCH_TIMEOUT_MS
+    );
+    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 = {}) {
@@ -18473,7 +18603,7 @@ async function runChannel(opts = {}) {
       const args = req.params.arguments;
       try {
         const res = await fetchWithTimeout(
-          `${tandemUrl}/api/channel-reply`,
+          `${tandemUrl}${API_CHANNEL_REPLY}`,
           {
             method: "POST",
             headers: { "Content-Type": "application/json" },
@@ -18507,7 +18637,7 @@ async function runChannel(opts = {}) {
               type: "text",
               text: `Failed to send reply: ${describeFetchError(
                 err,
-                "/api/channel-reply",
+                API_CHANNEL_REPLY,
                 CHANNEL_REPLY_FETCH_TIMEOUT_MS
               )}`
             }
@@ -18530,7 +18660,7 @@ async function runChannel(opts = {}) {
   mcp.setNotificationHandler(PermissionRequestSchema, async ({ params }) => {
     try {
       const res = await fetchWithTimeout(
-        `${tandemUrl}/api/channel-permission`,
+        `${tandemUrl}${API_CHANNEL_PERMISSION}`,
         {
           method: "POST",
           headers: { "Content-Type": "application/json" },
@@ -18551,7 +18681,7 @@ async function runChannel(opts = {}) {
     } catch (err) {
       console.error(
         "[Channel] Failed to forward permission request:",
-        describeFetchError(err, "/api/channel-permission", CHANNEL_PERMISSION_FETCH_TIMEOUT_MS)
+        describeFetchError(err, API_CHANNEL_PERMISSION, CHANNEL_PERMISSION_FETCH_TIMEOUT_MS)
       );
     }
   });
@@ -18577,7 +18707,7 @@ async function checkServerReachable(url, timeoutMs = 2e3) {
     parsed = new URL(url);
   } catch {
     console.error(
-      `[Channel] Invalid TANDEM_URL: "${url}" \u2014 expected format: http://localhost:3479`
+      `[Channel] Invalid TANDEM_URL: "${url}" \u2014 expected format: http://127.0.0.1:3479`
     );
     return false;
   }