backeer-opencode 0.1.2 → 0.1.4

package/src/sse.js

@@ -0,0 +1,139 @@
+import { HttpError, isAbortError, sleep } from "./http.js"
+import { limit } from "./utilities.js"
+
+export function parseSseFrame(frame) {
+  const data = []
+  let event = "message"
+  let id
+
+  for (const line of frame.split(/\r?\n/)) {
+    if (!line || line.startsWith(":")) continue
+    const separator = line.indexOf(":")
+    const field = separator === -1 ? line : line.slice(0, separator)
+    let value = separator === -1 ? "" : line.slice(separator + 1)
+    if (value.startsWith(" ")) value = value.slice(1)
+
+    if (field === "event") event = value
+    if (field === "id") id = value
+    if (field === "data") data.push(value)
+  }
+
+  if (data.length === 0) return
+  return { event, id, data: data.join("\n") }
+}
+
+export function nextSseFrame(buffer) {
+  const lfIndex = buffer.indexOf("\n\n")
+  const crlfIndex = buffer.indexOf("\r\n\r\n")
+  if (lfIndex === -1 && crlfIndex === -1) return
+
+  if (crlfIndex !== -1 && (lfIndex === -1 || crlfIndex < lfIndex)) {
+    return {
+      frame: buffer.slice(0, crlfIndex),
+      rest: buffer.slice(crlfIndex + 4),
+    }
+  }
+  return { frame: buffer.slice(0, lfIndex), rest: buffer.slice(lfIndex + 2) }
+}
+
+export async function consumeSse(response, state, onCommand, signal, reporter) {
+  if (!response.body) throw new Error("Backeer command stream has no body")
+
+  const reader = response.body.getReader()
+  const decoder = new TextDecoder()
+  let buffer = ""
+
+  try {
+    while (!signal.aborted) {
+      const item = await reader.read()
+      if (item.done) break
+      buffer += decoder.decode(item.value, { stream: true })
+
+      for (;;) {
+        const next = nextSseFrame(buffer)
+        if (!next) break
+        buffer = next.rest
+        const message = parseSseFrame(next.frame)
+        if (!message) continue
+        if (message.id) state.lastEventID = message.id
+        if (message.event !== "message" && message.event !== "command") continue
+
+        try {
+          await onCommand(JSON.parse(message.data))
+        } catch (error) {
+          if (error instanceof SyntaxError) {
+            reporter.error("Invalid command received", "SSE data is not valid JSON")
+            continue
+          }
+          throw error
+        }
+      }
+    }
+  } finally {
+    await reader.cancel().catch(() => {})
+  }
+}
+
+export async function runCommandStream(
+  config,
+  reporter,
+  { signal, hasPending, onCommand },
+) {
+  const state = { lastEventID: "" }
+  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,
+        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")
+      }
+
+      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
+      }
+    }
+
+    if (!signal.aborted && hasPending()) {
+      await sleep(reconnectDelay, signal)
+      reconnectDelay = Math.min(reconnectDelay * 2, 60_000)
+    }
+  }
+}

package/src/utilities.js

@@ -0,0 +1,25 @@
+const MAX_TRACKED_ITEMS = 500
+
+export const limit = (value, length = 1000) =>
+  String(value ?? "").slice(0, length)
+
+export function enabled(value, fallback = true) {
+  if (typeof value === "boolean") return value
+  if (typeof value !== "string") return fallback
+  return !["0", "false", "no", "off"].includes(value.trim().toLowerCase())
+}
+
+export function stableHash(value) {
+  let hash = 2166136261
+  for (let index = 0; index < value.length; index++) {
+    hash ^= value.charCodeAt(index)
+    hash = Math.imul(hash, 16777619)
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0")
+}
+
+export function rememberBounded(map, key, value) {
+  map.delete(key)
+  map.set(key, value)
+  while (map.size > MAX_TRACKED_ITEMS) map.delete(map.keys().next().value)
+}