backeer-opencode 0.2.3 → 0.2.4

package/src/session-messages.js

@@ -1,4 +1,5 @@
-import { limit, rememberBounded } from "./utilities.js"
+import { FeedbackSessionStore } from "./feedback-session-store.js"
+import { limit } from "./utilities.js"
 
 const FEEDBACK_SYMBOLS = {
   info: "•",
@@ -16,6 +17,56 @@ const QUESTION_REPLIED_EVENTS = new Set([
   "question.v2.answered",
 ])
 
+function interactionKey(kind, event) {
+  const value = event.properties?.requestID ?? event.properties?.id
+  return `${kind}:${typeof value === "string" && value ? value : "pending"}`
+}
+
+const INTERACTION_EVENTS = new Map([
+  ["permission.asked", { kind: "permission", phase: "begin" }],
+  ["permission.replied", { kind: "permission", phase: "end" }],
+  ...[...QUESTION_ASKED_EVENTS]
+    .map((type) => [type, { kind: "question", phase: "begin" }]),
+  ...[...QUESTION_REPLIED_EVENTS]
+    .map((type) => [type, { kind: "question", phase: "end" }]),
+])
+
+const SESSION_EVENT_HANDLERS = {
+  "session.status": (sessions, event, sessionID) => {
+    const status = event.properties?.status?.type
+    if (status === "idle") sessions.setIdle(sessionID, true)
+    else if (status === "busy" || status === "retry") {
+      sessions.setIdle(sessionID, false)
+    }
+  },
+  "session.idle": (sessions, _event, sessionID) => {
+    sessions.setIdle(sessionID, true)
+  },
+  "todo.updated": (sessions, _event, sessionID) => {
+    sessions.setIdle(sessionID, false)
+  },
+  "session.error": (sessions, _event, sessionID) => {
+    sessions.failSession(sessionID)
+  },
+  "session.deleted": (sessions, _event, sessionID) => {
+    sessions.delete(sessionID)
+  },
+}
+
+function handleFeedbackEvent(sessions, event) {
+  const sessionID = event?.properties?.sessionID
+  if (typeof sessionID !== "string") return
+
+  const interaction = INTERACTION_EVENTS.get(event.type)
+  if (interaction) {
+    const key = interactionKey(interaction.kind, event)
+    if (interaction.phase === "begin") sessions.beginInteraction(sessionID, key)
+    else sessions.endInteraction(sessionID, key, interaction.kind)
+    return
+  }
+  SESSION_EVENT_HANDLERS[event.type]?.(sessions, event, sessionID)
+}
+
 export async function sendSessionMessage(client, sessionID, text) {
   if (typeof client?.session?.prompt !== "function") {
     throw new Error("OpenCode session messaging is unavailable")
@@ -35,139 +86,28 @@ export function formatBackeerFeedback(kind, message) {
 }
 
 export function createConversationFeedback({ client, reporter }) {
-  const sessions = new Map()
-  let disposed = false
-
-  function sessionState(sessionID) {
-    let state = sessions.get(sessionID)
-    if (!state) {
-      state = {
-        idle: false,
-        flushing: false,
-        blockers: new Set(),
-        queue: [],
-        queued: new Set(),
-      }
-      rememberBounded(sessions, sessionID, state)
-    }
-    return state
-  }
-
-  async function flush(sessionID, state) {
-    if (
-      disposed || state.flushing || !state.idle ||
-      state.blockers.size > 0 || state.queue.length === 0
-    ) return
-    state.flushing = true
-    try {
-      while (
-        !disposed && state.idle && state.blockers.size === 0 &&
-        state.queue.length > 0
-      ) {
-        const item = state.queue[0]
-        try {
-          await sendSessionMessage(
-            client,
-            sessionID,
-            formatBackeerFeedback(item.kind, item.message),
-          )
-          state.queue.shift()
-          state.queued.delete(item.key)
-        } catch (error) {
-          state.idle = false
-          reporter.debug("Conversation feedback could not be displayed", error)
-        }
-      }
-    } finally {
-      state.flushing = false
-    }
-  }
-
-  function enqueue(kind, sessionID, message) {
-    if (disposed || typeof sessionID !== "string" || !sessionID || !message) return
-    const state = sessionState(sessionID)
-    const key = `${sessionID}:${kind}:${message}`
-    if (state.queued.has(key)) return
-
-    state.queue.push({ kind, message: limit(message, 300), key })
-    state.queued.add(key)
-    while (state.queue.length > 20) {
-      const removed = state.queue.shift()
-      state.queued.delete(removed.key)
-    }
-    if (state.idle && state.blockers.size === 0) void flush(sessionID, state)
-  }
-
-  function setIdle(sessionID, idle) {
-    if (typeof sessionID !== "string" || !sessionID) return
-    const state = sessionState(sessionID)
-    state.idle = idle
-    if (idle) void flush(sessionID, state)
-  }
-
-  function interactionKey(kind, event) {
-    const value = event.properties?.requestID ?? event.properties?.id
-    return `${kind}:${typeof value === "string" && value ? value : "pending"}`
-  }
-
-  function beginInteraction(sessionID, kind, event) {
-    const state = sessionState(sessionID)
-    state.idle = false
-    state.blockers.add(interactionKey(kind, event))
-  }
-
-  function endInteraction(sessionID, kind, event) {
-    const state = sessionState(sessionID)
-    const key = interactionKey(kind, event)
-    if (!state.blockers.delete(key)) {
-      const fallback = [...state.blockers]
-        .find((blocker) => blocker.startsWith(`${kind}:`))
-      if (fallback) state.blockers.delete(fallback)
-    }
-    // The reply event can arrive before OpenCode has removed its permission UI
-    // or resumed the agent. Wait for the next idle event before injecting text.
-    state.idle = false
-  }
+  const sessions = new FeedbackSessionStore({
+    reporter,
+    send: (sessionID, kind, message) => sendSessionMessage(
+      client,
+      sessionID,
+      formatBackeerFeedback(kind, message),
+    ),
+  })
 
   return {
-    info: (sessionID, message) => enqueue("info", sessionID, message),
-    success: (sessionID, message) => enqueue("success", sessionID, message),
-    applied: (sessionID, message) => enqueue("applied", sessionID, message),
-    warning: (sessionID, message) => enqueue("warning", sessionID, message),
-    error: (sessionID, message) => enqueue("error", sessionID, message),
+    info: (sessionID, message) => sessions.enqueue("info", sessionID, message),
+    success: (sessionID, message) => sessions.enqueue("success", sessionID, message),
+    applied: (sessionID, message) => sessions.enqueue("applied", sessionID, message),
+    warning: (sessionID, message) => sessions.enqueue("warning", sessionID, message),
+    error: (sessionID, message) => sessions.enqueue("error", sessionID, message),
 
     handle(event) {
-      const sessionID = event?.properties?.sessionID
-      if (typeof sessionID !== "string") return
-
-      if (event.type === "session.status") {
-        const status = event.properties?.status?.type
-        if (status === "idle") setIdle(sessionID, true)
-        else if (status === "busy" || status === "retry") setIdle(sessionID, false)
-      } else if (event.type === "session.idle") {
-        setIdle(sessionID, true)
-      } else if (event.type === "permission.asked") {
-        beginInteraction(sessionID, "permission", event)
-      } else if (QUESTION_ASKED_EVENTS.has(event.type)) {
-        beginInteraction(sessionID, "question", event)
-      } else if (event.type === "permission.replied") {
-        endInteraction(sessionID, "permission", event)
-      } else if (QUESTION_REPLIED_EVENTS.has(event.type)) {
-        endInteraction(sessionID, "question", event)
-      } else if (event.type === "todo.updated") {
-        setIdle(sessionID, false)
-      } else if (event.type === "session.error") {
-        const state = sessionState(sessionID)
-        state.blockers.clear()
-        state.idle = false
-      } else if (event.type === "session.deleted") {
-        sessions.delete(sessionID)
-      }
+      handleFeedbackEvent(sessions, event)
     },
 
     dispose() {
-      disposed = true
-      sessions.clear()
+      sessions.dispose()
     },
   }
 }

package/src/sse.js

@@ -53,6 +53,7 @@ export async function consumeSse(response, state, onCommand, signal, reporter) {
         const next = nextSseFrame(buffer)
         if (!next) break
         buffer = next.rest
+        state.framesReceived = (state.framesReceived ?? 0) + 1
         const message = parseSseFrame(next.frame)
         if (!message) continue
         if (message.id) state.lastEventID = message.id
@@ -74,65 +75,120 @@ export async function consumeSse(response, state, onCommand, signal, reporter) {
   }
 }
 
+async function openCommandStream(config, state, signal, fetchImplementation) {
+  const headers = {
+    Accept: "text/event-stream",
+    Authorization: `Bearer ${config.token}`,
+  }
+  if (state.lastEventID) headers["Last-Event-ID"] = state.lastEventID
+
+  const response = await fetchImplementation(config.commandStreamEndpoint, {
+    headers,
+    signal,
+  })
+  if (!response.ok) {
+    const responseBody = limit(await response.text(), 500)
+    throw new HttpError(
+      `Backeer command stream failed with status ${response.status}`,
+      response.status,
+      responseBody,
+    )
+  }
+  if (!response.headers.get("content-type")?.includes("text/event-stream")) {
+    throw new Error("Backeer command stream returned an invalid content type")
+  }
+  return response
+}
+
+async function consumeConnection({
+  response,
+  state,
+  onCommand,
+  signal,
+  reporter,
+  now,
+  stableConnectionMs,
+  onStable,
+}) {
+  const connectedAt = now()
+  const framesBeforeConnection = state.framesReceived
+  try {
+    await consumeSse(response, state, onCommand, signal, reporter)
+  } finally {
+    const receivedFrame = state.framesReceived > framesBeforeConnection
+    if (receivedFrame || now() - connectedAt >= stableConnectionMs) onStable()
+  }
+}
+
+function streamErrorState(error, lastLoggedError, reconnectDelay, reporter) {
+  const message = error instanceof HttpError
+    ? `${error.message}: ${error.responseBody}`
+    : limit(error, 500)
+  if (message !== lastLoggedError) {
+    const authenticationFailure = error instanceof HttpError &&
+      [401, 403].includes(error.status)
+    reporter.error(
+      authenticationFailure
+        ? "Authentication failed — run: npx backeer-opencode@latest configure"
+        : "Connection interrupted — retrying",
+      message,
+    )
+  }
+  return {
+    lastLoggedError: message,
+    reconnectDelay: error instanceof HttpError && [401, 403, 404].includes(error.status)
+      ? 60_000
+      : reconnectDelay,
+  }
+}
+
 export async function runCommandStream(
   config,
   reporter,
-  { signal, hasPending, onCommand },
+  {
+    signal,
+    hasPending,
+    onCommand,
+    fetchImplementation = fetch,
+    sleepImplementation = sleep,
+    now = Date.now,
+    stableConnectionMs = 5_000,
+  },
 ) {
-  const state = { lastEventID: "" }
+  const state = { lastEventID: "", framesReceived: 0 }
   let reconnectDelay = 1000
   let lastLoggedError = ""
 
   while (!signal.aborted && hasPending()) {
     try {
-      const headers = {
-        Accept: "text/event-stream",
-        Authorization: `Bearer ${config.token}`,
-      }
-      if (state.lastEventID) headers["Last-Event-ID"] = state.lastEventID
-
-      const response = await fetch(config.commandStreamEndpoint, {
-        headers,
+      const response = await openCommandStream(
+        config,
+        state,
+        signal,
+        fetchImplementation,
+      )
+      await consumeConnection({
+        response,
+        state,
+        onCommand,
         signal,
+        reporter,
+        now,
+        stableConnectionMs,
+        onStable: () => {
+          reconnectDelay = 1000
+          lastLoggedError = ""
+        },
       })
-      if (!response.ok) {
-        const responseBody = limit(await response.text(), 500)
-        throw new HttpError(
-          `Backeer command stream failed with status ${response.status}`,
-          response.status,
-          responseBody,
-        )
-      }
-      if (!response.headers.get("content-type")?.includes("text/event-stream")) {
-        throw new Error("Backeer command stream returned an invalid content type")
-      }
-
-      reconnectDelay = 1000
-      lastLoggedError = ""
-      await consumeSse(response, state, onCommand, signal, reporter)
     } catch (error) {
       if (signal.aborted || isAbortError(error)) return
-      const message = error instanceof HttpError
-        ? `${error.message}: ${error.responseBody}`
-        : limit(error, 500)
-      if (message !== lastLoggedError) {
-        const authenticationFailure = error instanceof HttpError &&
-          [401, 403].includes(error.status)
-        reporter.error(
-          authenticationFailure
-            ? "Authentication failed — run: npx backeer-opencode@latest configure"
-            : "Connection interrupted — retrying",
-          message,
-        )
-        lastLoggedError = message
-      }
-      if (error instanceof HttpError && [401, 403, 404].includes(error.status)) {
-        reconnectDelay = 60_000
-      }
+      const next = streamErrorState(error, lastLoggedError, reconnectDelay, reporter)
+      reconnectDelay = next.reconnectDelay
+      lastLoggedError = next.lastLoggedError
     }
 
     if (!signal.aborted && hasPending()) {
-      await sleep(reconnectDelay, signal)
+      await sleepImplementation(reconnectDelay, signal)
       reconnectDelay = Math.min(reconnectDelay * 2, 60_000)
     }
   }

package/src/updates.js

@@ -1,4 +1,4 @@
-export const PLUGIN_VERSION = "0.2.3"
+export const PLUGIN_VERSION = "0.2.4"
 
 const PACKAGE_NAME = "backeer-opencode"
 const NPM_REGISTRY_URL = "https://registry.npmjs.org"