backeer-opencode 0.3.1 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backeer-opencode",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Backeer lifecycle notifications and remote permission and question replies for OpenCode",
   "type": "module",
   "main": "./src/index.js",
@@ -50,6 +50,9 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@opencode/client": "2.0.26"
+  },
   "devDependencies": {
     "@eslint/js": "^9.39.5",
     "esbuild": "^0.28.2",

package/src/index.js

@@ -1 +1,6 @@
-export { default } from "./plugin.js"
+import server from "./plugin.js"
+import { setup } from "./opencode-v2.js"
+
+// A plain definition avoids an authoring-SDK dependency in the installer bundle.
+// OpenCode >=1.18.29 calls server(); OpenCode V2 calls setup().
+export default { id: "backeer-opencode", setup, server }

package/src/opencode-v2-client.js

@@ -0,0 +1,145 @@
+import { HttpError } from "./http.js"
+import { getFormApi } from "./opencode-v2-forms.js"
+
+async function nativeReply(operation) {
+  try {
+    return await operation()
+  } catch (error) {
+    const statuses = {
+      PermissionNotFoundError: 404,
+      SessionNotFoundError: 404,
+      FormNotFoundError: 404,
+      FormAlreadySettledError: 409,
+      FormInvalidAnswerError: 422,
+    }
+    const status = statuses[error?._tag]
+    if (status) throw new HttpError(error.message || error._tag, status)
+    throw error
+  }
+}
+
+function questionForm(form) {
+  return form?.metadata?.kind === "question" &&
+    typeof form.sessionID === "string" && form.sessionID !== "global" &&
+    Array.isArray(form.fields) && form.fields.length > 0 &&
+    form.fields.every((field) =>
+      ["string", "multiselect"].includes(field.type) && !field.hidden && !field.when?.length,
+    )
+}
+
+export function normalizeV2Event(event) {
+  const properties = event.data ?? {}
+  const normalized = { ...event, properties }
+  if (event.type === "form.created") {
+    const form = properties.form
+    if (!questionForm(form)) return []
+    return [{ ...normalized, type: "question.v2.asked", properties: {
+      id: form.id,
+      sessionID: form.sessionID,
+      questions: form.fields.map((field) => ({
+        header: field.title ?? form.title,
+        question: field.description ?? field.title ?? form.title,
+        options: (field.options ?? []).map((option) => ({
+          label: option.label, description: option.description ?? "",
+        })),
+        multiple: field.type === "multiselect",
+        custom: field.custom === true || !field.options?.length,
+      })),
+    } }]
+  }
+  if (event.type === "form.replied" || event.type === "form.cancelled") {
+    return [{ ...normalized, type: event.type === "form.replied"
+      ? "question.v2.replied" : "question.v2.rejected" }]
+  }
+  if (event.type === "session.execution.started") {
+    return [{ ...normalized, type: "session.status", properties: {
+      ...properties, status: { type: "busy" },
+    } }]
+  }
+  if (["session.execution.succeeded", "session.execution.interrupted"].includes(event.type)) {
+    return [
+      { ...normalized, type: "message.updated", properties: { info: {
+        role: "assistant", sessionID: properties.sessionID, id: event.id,
+        time: { completed: event.created },
+        error: event.type === "session.execution.interrupted",
+      } } },
+      { ...normalized, type: "session.idle" },
+    ]
+  }
+  if (event.type === "session.execution.failed") {
+    return [{ ...normalized, type: "session.error" }, { ...normalized, type: "session.idle" }]
+  }
+  // Intermediate UI-idle transitions are not execution completion boundaries.
+  if (event.type === "session.idle" ||
+      (event.type === "session.status" && properties.status?.type === "idle")) {
+    return []
+  }
+  return [normalized]
+}
+
+export function createV2Client(ctx, resolveFormApi = (sessionID) => getFormApi(ctx, sessionID)) {
+  return {
+    app: {
+      async log({ body }) {
+        // Server stderr is captured by OpenCode's log, never the TUI input.
+        console.error(JSON.stringify(body))
+      },
+    },
+    session: {
+      get: ({ path }) => ctx.session.get({ sessionID: path.id }),
+      prompt: ({ path, body }) => ctx.session.synthetic({
+        sessionID: path.id,
+        text: body.parts.map((part) => part.text).join("\n"),
+        resume: false,
+      }),
+    },
+    postSessionIdPermissionsPermissionId: ({ path, body }) => nativeReply(() => ctx.permission.reply({
+      sessionID: path.id,
+      requestID: path.permissionID,
+      decision: body.response,
+    })),
+    v2: { session: { question: {
+      async reply({ sessionID, requestID, questionV2Reply }) {
+        const api = await resolveFormApi(sessionID)
+        const form = await nativeReply(() => api.get({ sessionID, formID: requestID }))
+        if (!questionForm(form)) throw new HttpError("Unsupported OpenCode question form", 422)
+        const answers = questionV2Reply.answers
+        if (!Array.isArray(answers) || answers.length !== form.fields.length) {
+          throw new HttpError("Question answer count does not match the form", 422)
+        }
+        const answer = {}
+        form.fields.forEach((field, index) => {
+          const selections = answers[index]
+          if (!Array.isArray(selections) || selections.some((value) => typeof value !== "string")) {
+            throw new HttpError("Invalid question answer", 422)
+          }
+          const values = selections.map((label) =>
+            field.options?.find((option) => option.label === label)?.value ?? label,
+          )
+          if (field.type === "multiselect") answer[field.key] = values
+          else if (values.length === 1) answer[field.key] = values[0]
+          else if (values.length > 1) throw new HttpError("Single-choice question has multiple answers", 422)
+        })
+        return nativeReply(() => api.reply({ sessionID, formID: requestID, answer }))
+      },
+      async reject({ sessionID, requestID }) {
+        const api = await resolveFormApi(sessionID)
+        const form = await nativeReply(() => api.get({ sessionID, formID: requestID }))
+        if (!questionForm(form)) throw new HttpError("Unsupported OpenCode question form", 422)
+        return nativeReply(() => api.cancel({ sessionID, formID: requestID }))
+      },
+    } } },
+    async ownsEvent(event) {
+      if (event.location?.directory) return event.location.directory === ctx.location.directory
+      const sessionID = event.data?.sessionID ?? event.data?.form?.sessionID
+      if (!sessionID) return event.type === "installation.update-available"
+      if (sessionID === "global") return false
+      try {
+        const session = await ctx.session.get({ sessionID })
+        return session.location?.directory === ctx.location.directory
+      } catch {
+        return false
+      }
+    },
+  }
+}

package/src/opencode-v2-forms.js

@@ -0,0 +1,24 @@
+import { OpenCode } from "@opencode/client"
+import { Service } from "@opencode/client/service"
+
+import { HttpError } from "./http.js"
+
+export async function getFormApi(ctx, sessionID, { makeClient = OpenCode.make } = {}) {
+  // 2.0.26 exposes forms on the client API, but not on the plugin context.
+  // Discover only: never start a second service or change its configuration.
+  const endpoint = await Service.discover({ version: ctx.app.version })
+  if (!endpoint) {
+    throw new HttpError("Remote question replies require the OpenCode V2 shared service", 501)
+  }
+  const client = makeClient({ baseUrl: endpoint.url, headers: Service.headers(endpoint) })
+  let session
+  try {
+    session = await client.session.get({ sessionID })
+  } catch {
+    throw new HttpError("The question session is not owned by the shared OpenCode service", 501)
+  }
+  if (session.location.directory !== ctx.location.directory) {
+    throw new HttpError("The question session belongs to another OpenCode location", 403)
+  }
+  return client.session.form
+}

package/src/opencode-v2.js

@@ -0,0 +1,107 @@
+import server from "./plugin.js"
+import { createOpenCodeReporter } from "./reporter.js"
+import { createV2Client, normalizeV2Event } from "./opencode-v2-client.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 () => {
+      let delay = 1000
+      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
+            delay = 1000
+            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, delay)
+          delay = Math.min(delay * 2, 30_000)
+        }
+      }
+    })()
+    return cleanup
+  } catch (error) {
+    await cleanup()
+    throw error
+  }
+}

package/src/plugin.js

@@ -31,7 +31,7 @@ import {
  * 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 +45,7 @@ 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 })
 
   const permissionController = createPermissionController({
     config,
@@ -64,7 +64,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,

package/src/updates.js

@@ -1,4 +1,4 @@
-export const PLUGIN_VERSION = "0.2.5"
+export const PLUGIN_VERSION = "0.4.0"
 
 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 }