backeer-opencode 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backeer-opencode",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Backeer notifications and remote permission decisions for OpenCode",
   "type": "module",
   "main": "./src/index.js",
@@ -12,16 +12,20 @@
   },
   "files": [
     "src",
+    "dist",
     "bin",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"
   ],
   "scripts": {
-    "check": "node --check src/index.js && node --check bin/backeer-opencode.js && node --test",
+    "build": "esbuild src/index.js --bundle --platform=node --format=esm --target=node18 --outfile=dist/backeer-permission.js --legal-comments=none",
+    "check": "node --check bin/backeer-opencode.js && npm test",
+    "pretest": "npm run build",
     "test": "node --test",
     "pack:check": "npm pack --dry-run",
     "publish:check": "npm publish --dry-run --access public",
+    "prepack": "npm run build",
     "prepublishOnly": "npm run check"
   },
   "keywords": [
@@ -45,5 +49,8 @@
   "publishConfig": {
     "access": "public"
   },
+  "devDependencies": {
+    "esbuild": "^0.28.2"
+  },
   "license": "SEE LICENSE IN LICENSE"
 }

package/src/config.js

@@ -0,0 +1,56 @@
+import { readFileSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+import { normalizeLogLevel } from "./reporter.js"
+import { enabled } from "./utilities.js"
+
+const DEFAULT_ORIGIN = "https://external-gateway.backeer.com"
+
+function defaultConfigDirectory() {
+  const base = process.env.XDG_CONFIG_HOME?.trim()
+  return base ? join(base, "opencode") : join(homedir(), ".config", "opencode")
+}
+
+function loadToken(tokenFile) {
+  const environmentToken = process.env.BACKEER_INGEST_TOKEN?.trim()
+  if (environmentToken) return environmentToken
+
+  try {
+    return readFileSync(tokenFile, "utf8").trim()
+  } catch {
+    return ""
+  }
+}
+
+export function loadConfig(options = {}) {
+  const origin = new URL(
+    options.origin ?? process.env.BACKEER_ORIGIN ?? DEFAULT_ORIGIN,
+  )
+  if (origin.protocol !== "https:") {
+    throw new Error("Backeer origin must use HTTPS")
+  }
+
+  const tokenFile =
+    options.tokenFile ??
+    process.env.BACKEER_TOKEN_FILE ??
+    join(defaultConfigDirectory(), "secrets", "backeer-ingest-token")
+
+  return {
+    origin,
+    eventsEndpoint: new URL("/v1/events", origin),
+    commandStreamEndpoint: new URL("/v1/commands/stream", origin),
+    token: loadToken(tokenFile),
+    tokenFile,
+    permissions: enabled(
+      options.permissions ?? process.env.BACKEER_NOTIFY_PERMISSIONS,
+    ),
+    questions: enabled(
+      options.questions ?? process.env.BACKEER_NOTIFY_QUESTIONS,
+    ),
+    todos: enabled(options.todos ?? process.env.BACKEER_NOTIFY_TODOS),
+    logLevel: normalizeLogLevel(
+      options.logLevel ?? process.env.BACKEER_LOG_LEVEL,
+    ),
+  }
+}

package/src/event-publishers.js

@@ -0,0 +1,214 @@
+import { postJsonWithRetry } from "./http.js"
+import { limit, stableHash } from "./utilities.js"
+
+const ACTION_PROTOCOL = "opencode-permission/v1"
+
+export function permissionIdentity(request) {
+  const requestID = request.id ?? request.requestID
+  const sessionID = request.sessionID
+  if (typeof requestID !== "string" || typeof sessionID !== "string") return
+
+  return {
+    requestID,
+    sessionID,
+    externalId: `opencode:${sessionID}:${requestID}`,
+  }
+}
+
+export async function publishPermission(
+  config,
+  reporter,
+  request,
+  directory,
+  identity,
+) {
+  const permissionType = request.permission ?? request.action ?? "unknown"
+  const resources = Array.isArray(request.patterns)
+    ? request.patterns.join(", ")
+    : Array.isArray(request.resources)
+      ? request.resources.join(", ")
+      : ""
+
+  const payload = [
+    { key: "Permission", value: limit(permissionType) },
+    { key: "Session", value: limit(identity.sessionID) },
+    { key: "Request ID", value: limit(identity.requestID) },
+    { key: "Patterns", value: limit(resources) },
+    { key: "Working directory", value: limit(directory) },
+    { key: "Action protocol", value: ACTION_PROTOCOL },
+    { key: "Available decisions", value: "once, always, reject" },
+  ].filter((item) => item.value.length > 0)
+
+  const result = await postJsonWithRetry(config, config.eventsEndpoint, {
+    type: "application",
+    severity: "warning",
+    title: `OpenCode permission required: ${limit(permissionType, 200)}`,
+    body: resources
+      ? `OpenCode is waiting for approval to access: ${limit(resources, 500)}`
+      : `OpenCode is waiting for approval for: ${limit(permissionType, 500)}`,
+    payload,
+    externalId: identity.externalId,
+    timestamp: new Date().toISOString(),
+    notify: true,
+    direction: "in",
+  })
+  reporter.success("Permission request sent", `HTTP ${result.status}`)
+}
+
+export function questionIdentity(request) {
+  const requestID = request.id ?? request.requestID
+  const sessionID = request.sessionID
+  if (typeof requestID !== "string" || typeof sessionID !== "string") return
+
+  return {
+    requestID,
+    sessionID,
+    externalId: `opencode-question:${sessionID}:${requestID}`,
+  }
+}
+
+function formatQuestionOptions(options) {
+  if (!Array.isArray(options)) return ""
+
+  return options
+    .map((option) => {
+      const label = limit(option?.label, 200)
+      const description = limit(option?.description, 500)
+      if (!label) return ""
+      return description ? `${label} — ${description}` : label
+    })
+    .filter(Boolean)
+    .join(" | ")
+}
+
+async function resolveSessionTitle(client, directory, sessionID, reporter) {
+  if (typeof client?.session?.get !== "function") return ""
+
+  try {
+    const result = await client.session.get({
+      path: { id: sessionID },
+      query: { directory },
+      throwOnError: true,
+    })
+    return limit((result?.data ?? result)?.title)
+  } catch (error) {
+    reporter.debug("Session title unavailable", error)
+    return ""
+  }
+}
+
+export async function publishQuestion(
+  config,
+  reporter,
+  request,
+  identity,
+  client,
+  directory,
+) {
+  const questions = Array.isArray(request.questions) ? request.questions : []
+  if (questions.length === 0) return
+
+  const sessionTitle = await resolveSessionTitle(
+    client,
+    directory,
+    identity.sessionID,
+    reporter,
+  )
+  const payload = [
+    { key: "OpenCode session", value: sessionTitle },
+    ...questions.flatMap((question, index) => {
+      const suffix = questions.length > 1 ? ` ${index + 1}` : ""
+      return [
+        { key: `Question title${suffix}`, value: limit(question?.header) },
+        { key: `Question${suffix}`, value: limit(question?.question) },
+        {
+          key: `Options${suffix}`,
+          value: limit(formatQuestionOptions(question?.options)),
+        },
+      ]
+    }),
+  ].filter((item) => item.value.length > 0)
+
+  const firstQuestion = questions[0]
+  const body = questions
+    .map((question) => {
+      const header = limit(question?.header, 200)
+      const text = limit(question?.question, 500)
+      const options = limit(formatQuestionOptions(question?.options), 500)
+      return [header, text, options ? `Options: ${options}` : ""]
+        .filter(Boolean)
+        .join("\n")
+    })
+    .join("\n\n")
+
+  const result = await postJsonWithRetry(config, config.eventsEndpoint, {
+    type: "application",
+    severity: "info",
+    title: `OpenCode question: ${limit(firstQuestion?.header, 200) || "Question"}`,
+    body: limit(body, 2000),
+    payload,
+    externalId: identity.externalId,
+    timestamp: new Date().toISOString(),
+    notify: true,
+    direction: "in",
+  })
+  reporter.success("Question sent", `HTTP ${result.status}`)
+}
+
+export async function publishTodoCompletion(
+  config,
+  reporter,
+  request,
+  eventID,
+  client,
+  directory,
+) {
+  const todos = request.todos
+  const sessionTitle = await resolveSessionTitle(
+    client,
+    directory,
+    request.sessionID,
+    reporter,
+  )
+  const correlation =
+    typeof eventID === "string" && eventID.length > 0
+      ? limit(eventID, 200)
+      : stableHash(JSON.stringify(todos))
+  const externalId = `opencode-todo:${request.sessionID}:${correlation}`
+  const visibleTodos = todos.slice(0, 20)
+  const payload = [
+    { key: "OpenCode session", value: sessionTitle },
+    { key: "Completed tasks", value: String(todos.length) },
+    ...visibleTodos.flatMap((todo, index) => [
+      { key: `Task ${index + 1}`, value: limit(todo?.content) },
+      { key: `Priority ${index + 1}`, value: limit(todo?.priority, 100) },
+    ]),
+    ...(todos.length > visibleTodos.length
+      ? [{ key: "Additional tasks", value: String(todos.length - visibleTodos.length) }]
+      : []),
+  ].filter((item) => item.value.length > 0)
+
+  const summary = todos
+    .slice(0, 5)
+    .map((todo) => limit(todo?.content, 200))
+    .filter(Boolean)
+    .join(" • ")
+  const location = sessionTitle ? ` in ${sessionTitle}` : ""
+  const body = [
+    `All ${todos.length} OpenCode tasks completed${location}.`,
+    summary,
+  ].filter(Boolean).join("\n")
+
+  const result = await postJsonWithRetry(config, config.eventsEndpoint, {
+    type: "application",
+    severity: "info",
+    title: "OpenCode todo list completed",
+    body: limit(body, 2000),
+    payload,
+    externalId,
+    timestamp: new Date().toISOString(),
+    notify: true,
+    direction: "in",
+  })
+  reporter.success("Todo completion sent", `HTTP ${result.status}`)
+}

package/src/http.js

@@ -0,0 +1,87 @@
+import { limit } from "./utilities.js"
+
+const RETRY_DELAYS_MS = [0, 500, 1500]
+
+export class HttpError extends Error {
+  constructor(message, status, responseBody = "") {
+    super(message)
+    this.name = "HttpError"
+    this.status = status
+    this.responseBody = responseBody
+  }
+}
+
+function isRetryable(status) {
+  return status === 429 || status >= 500
+}
+
+export function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError"
+}
+
+export function sleep(milliseconds, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) {
+      resolve()
+      return
+    }
+
+    const timeout = setTimeout(done, milliseconds)
+
+    function done() {
+      clearTimeout(timeout)
+      signal?.removeEventListener("abort", done)
+      resolve()
+    }
+
+    signal?.addEventListener("abort", done, { once: true })
+  })
+}
+
+export async function postJsonWithRetry(config, url, body, options = {}) {
+  const retryDelays = options.retryDelays ?? RETRY_DELAYS_MS
+
+  for (let attempt = 0; attempt < retryDelays.length; attempt++) {
+    if (retryDelays[attempt] > 0) {
+      await sleep(retryDelays[attempt], options.signal)
+    }
+    if (options.signal?.aborted) throw new DOMException("Aborted", "AbortError")
+
+    const controller = new AbortController()
+    const abort = () => controller.abort()
+    const timeout = setTimeout(abort, options.timeoutMs ?? 5000)
+    options.signal?.addEventListener("abort", abort, { once: true })
+
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${config.token}`,
+          "Content-Type": "application/json",
+          ...options.headers,
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal,
+      })
+      const responseBody = limit(await response.text(), 1000)
+
+      if (response.ok) return { status: response.status, responseBody }
+      if (!isRetryable(response.status) || attempt === retryDelays.length - 1) {
+        throw new HttpError(
+          `HTTP request failed with status ${response.status}`,
+          response.status,
+          responseBody,
+        )
+      }
+    } catch (error) {
+      if (options.signal?.aborted) throw new DOMException("Aborted", "AbortError")
+      if (error instanceof HttpError) throw error
+      if (attempt === retryDelays.length - 1) throw error
+    } finally {
+      clearTimeout(timeout)
+      options.signal?.removeEventListener("abort", abort)
+    }
+  }
+
+  throw new Error("HTTP retry loop ended unexpectedly")
+}