backeer-opencode 0.3.2 → 0.5.1

package/src/opencode-v2.js

@@ -0,0 +1,105 @@
+import server from "./plugin.js"
+import { createOpenCodeReporter } from "./reporter.js"
+import { createV2Client, normalizeV2Event } from "./opencode-v2-client.js"
+import { LIVE_RECONNECT_MS } from "./live-connection.js"
+
+function waitForReconnect(signal, delay) {
+  return new Promise((resolve) => {
+    const finish = () => {
+      clearTimeout(timer)
+      signal.removeEventListener("abort", finish)
+      resolve()
+    }
+    const timer = setTimeout(finish, delay)
+    signal.addEventListener("abort", finish, { once: true })
+    if (signal.aborted) finish()
+  })
+}
+
+export async function setup(ctx) {
+  const client = createV2Client(ctx)
+  const reporter = createOpenCodeReporter(client, ctx.options?.logLevel ?? process.env.BACKEER_LOG_LEVEL)
+  // V2 has no ignored/noReply conversation entry. Do not put delivery feedback
+  // into model context or start an agent turn just to display a notification.
+  const feedback = Object.fromEntries(
+    ["info", "success", "applied", "warning", "error"].map((kind) => [
+      kind, () => {},
+    ]),
+  )
+  feedback.handle = () => {}
+  feedback.dispose = () => {}
+  const hooks = await server({
+    client,
+    directory: ctx.location.directory,
+    feedback,
+    v2: true,
+  }, { ...ctx.options, todos: false })
+  if (!hooks.event) return
+
+  const controller = new AbortController()
+  let streamTask
+  let cleanupTask
+  const registrations = []
+  function cleanup() {
+    cleanupTask ??= (async () => {
+      controller.abort()
+      await streamTask?.catch(() => {})
+      await hooks.dispose()
+      await Promise.all(registrations.map((registration) => registration.dispose()))
+    })()
+    return cleanupTask
+  }
+
+  try {
+    await ctx.command.transform((editor) => {
+      editor.add({
+        name: "backeer",
+        description: "Check, test, update, or manage Backeer",
+        async execute({ sessionID, prompt, delivery }) {
+          const output = { parts: [] }
+          await hooks["command.execute.before"]({
+            command: "backeer", sessionID, arguments: prompt.text,
+          }, output)
+          if (output.parts.length) {
+            await ctx.session.prompt({
+              sessionID,
+              text: output.parts.map((part) => part.text).join("\n"),
+              delivery,
+            })
+          }
+        },
+      })
+    }).then((registration) => registrations.push(registration))
+
+    registrations.push(await ctx.session.hook("prompt", async (event) => {
+      const output = { message: { id: event.messageID }, parts: [] }
+      await hooks["chat.message"]({ sessionID: event.sessionID }, output)
+      if (output.parts.length) {
+        event.prompt.text += `\n\n${output.parts.map((part) => part.text).join("\n")}`
+      }
+    }))
+
+    streamTask = (async () => {
+      while (!controller.signal.aborted) {
+        try {
+          for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
+            if (controller.signal.aborted) break
+            if (!await client.ownsEvent(event)) continue
+            for (const normalized of normalizeV2Event(event)) {
+              await hooks.event({ event: normalized })
+            }
+          }
+        } catch (error) {
+          if (!controller.signal.aborted) reporter.error("OpenCode event stream disconnected", error)
+        }
+        if (!controller.signal.aborted) {
+          await waitForReconnect(controller.signal, LIVE_RECONNECT_MS)
+        }
+      }
+    })()
+    return cleanup
+  } catch (error) {
+    await cleanup()
+    throw error
+  }
+}

package/src/plugin.js

@@ -15,6 +15,7 @@ import {
   registerBackeerCommand,
 } from "./management.js"
 import { createLifecycleController } from "./lifecycle-controller.js"
+import { createLiveBridge } from "./live-bridge.js"
 import { createPermissionController } from "./permission-controller.js"
 import { createOpenCodeReporter } from "./reporter.js"
 import { createConversationFeedback } from "./session-messages.js"
@@ -27,11 +28,11 @@ import {
  * OpenCode server plugin entrypoint.
  *
  * Supported options: origin, tokenFile, permissions, questions, todos,
- * lifecycle, logLevel.
+ * lifecycle, liveBridge, logLevel.
  * The ingest token is intentionally accepted only through the environment or a
  * protected file so it cannot accidentally be committed in opencode.json.
  */
-export default async function BackeerPlugin({ client, directory }, options = {}) {
+export default async function BackeerPlugin({ client, directory, feedback, v2 = false }, options = {}) {
   const bootstrapReporter = createOpenCodeReporter(
     client,
     options.logLevel ?? process.env.BACKEER_LOG_LEVEL,
@@ -45,7 +46,12 @@ export default async function BackeerPlugin({ client, directory }, options = {})
   }
 
   const reporter = createOpenCodeReporter(client, config.logLevel)
-  const conversation = createConversationFeedback({ client, reporter })
+  const conversation = feedback ?? createConversationFeedback({ client, reporter })
+  if (config.liveBridge.error) reporter.error("Live control disabled", config.liveBridge.error)
+  const liveBridge = await createLiveBridge({ config, client, directory, reporter }).catch((error) => {
+    reporter.error("Live control unavailable", error)
+    return { async handle() {}, async dispose() {} }
+  })
 
   const permissionController = createPermissionController({
     config,
@@ -64,7 +70,7 @@ export default async function BackeerPlugin({ client, directory }, options = {})
   const permissionPublications = createDeliveryTracker()
   const questionPublications = createDeliveryTracker()
   const todoCompletions = createCompletionTracker()
-  const updateChecker = createUpdateChecker()
+  const updateChecker = createUpdateChecker({ v2 })
   const handleBackeerCommand = createBackeerCommandHandler({
     client,
     config,
@@ -167,62 +173,64 @@ export default async function BackeerPlugin({ client, directory }, options = {})
       })
   }
 
-  return {
-    config: async (opencodeConfig) => {
-      registerBackeerCommand(opencodeConfig)
-    },
+  async function handleNotificationEvent(event) {
+    if (!config.token) return
 
-    "command.execute.before": handleBackeerCommand,
+    conversation.handle(event)
+    lifecycleController.handle(event)
 
-    "chat.message": handleUpdateNotice,
+    if (config.permissions && event.type === "permission.asked") {
+      await handlePermissionAsked(event)
+      return
+    }
 
-    event: async ({ event }) => {
-      if (!config.token) return
+    if (config.permissions && event.type === "permission.replied") {
+      permissionController.resolveLocally(
+        event.properties.requestID ?? event.properties.id,
+      )
+      return
+    }
 
-      conversation.handle(event)
-      lifecycleController.handle(event)
+    if (config.todos && event.type === "todo.updated") {
+      await handleTodoUpdated(event)
+      return
+    }
 
-      if (config.permissions && event.type === "permission.asked") {
-        await handlePermissionAsked(event)
-        return
-      }
+    if (
+      config.questions &&
+      (event.type === "question.asked" || event.type === "question.v2.asked")
+    ) {
+      await handleQuestionAsked(event)
+      return
+    }
 
-      if (config.permissions && event.type === "permission.replied") {
-        permissionController.resolveLocally(
-          event.properties.requestID ?? event.properties.id,
+    if (
+      config.questions &&
+      ["question.replied", "question.v2.replied", "question.rejected", "question.v2.rejected"]
+        .includes(event.type)
+    ) {
+      const requestID = event.properties.requestID ?? event.properties.id
+      if (typeof requestID === "string") {
+        permissionController.resolveQuestionLocally(
+          requestID,
+          event.type.endsWith("rejected") ? "rejected" : "answered",
         )
-        return
-      }
-
-      if (config.todos && event.type === "todo.updated") {
-        await handleTodoUpdated(event)
-        return
-      }
-
-      if (
-        config.questions &&
-        (event.type === "question.asked" || event.type === "question.v2.asked")
-      ) {
-        await handleQuestionAsked(event)
-        return
       }
+    }
+  }
 
-      if (
-        config.questions &&
-        ["question.replied", "question.v2.replied", "question.rejected", "question.v2.rejected"]
-          .includes(event.type)
-      ) {
-        const requestID = event.properties.requestID ?? event.properties.id
-        if (typeof requestID === "string") {
-          permissionController.resolveQuestionLocally(
-            requestID,
-            event.type.endsWith("rejected") ? "rejected" : "answered",
-          )
-        }
-      }
+  return {
+    config: async (opencodeConfig) => {
+      registerBackeerCommand(opencodeConfig)
+    },
+    "command.execute.before": handleBackeerCommand,
+    "chat.message": handleUpdateNotice,
+    event: async ({ event }) => {
+      // Start existing mobile handling first; live lookups must not gate approvals.
+      await Promise.all([handleNotificationEvent(event), liveBridge.handle(event)])
     },
-
     dispose: async () => {
+      await liveBridge.dispose()
       await permissionController.dispose()
       lifecycleController.dispose()
       permissionPublications.clear()

package/src/updates.js

@@ -1,4 +1,4 @@
-export const PLUGIN_VERSION = "0.3.2"
+export const PLUGIN_VERSION = "0.5.1"
 
 const PACKAGE_NAME = "backeer-opencode"
 const NPM_REGISTRY_URL = "https://registry.npmjs.org"
@@ -37,6 +37,7 @@ export function isVersionNewer(latestValue, currentValue) {
 export function createUpdateChecker({
   fetchImplementation = globalThis.fetch,
   now = () => Date.now(),
+  v2 = false,
 } = {}) {
   let checkedAt = 0
   let cachedResult
@@ -70,7 +71,8 @@ export function createUpdateChecker({
         currentVersion: PLUGIN_VERSION,
         latestVersion,
         updateCommand:
-          `opencode plugin ${PACKAGE_NAME}@${latestVersion} -g --force`,
+          v2 ? `opencode plugin add ${PACKAGE_NAME}@${latestVersion}`
+            : `opencode plugin ${PACKAGE_NAME}@${latestVersion} -g --force`,
       }
     } catch {
       return { state: "unavailable", currentVersion: PLUGIN_VERSION }