backeer-opencode 0.7.0 → 0.8.1

package/src/opencode-v2-client.js

@@ -1,6 +1,7 @@
 import { HttpError } from "./http.js"
 import { getFormApi } from "./opencode-v2-forms.js"
 import { createV2LiveClient } from "./live-bridge-client.js"
+import { createHash } from "node:crypto"
 
 async function nativeReply(operation) {
   try {
@@ -28,25 +29,28 @@ function questionForm(form) {
     )
 }
 
+function questionProperties(form) {
+  return { id: form.id, sessionID: form.sessionID,
+    nativeRevision: createHash("sha256").update(JSON.stringify({ id: form.id,
+      sessionID: form.sessionID, title: form.title, fields: form.fields })).digest("hex"),
+    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,
+    })) }
+}
+
 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,
-      })),
-    } }]
+    return [{ ...normalized, type: "question.v2.asked", properties: questionProperties(form) }]
   }
   if (event.type === "form.replied" || event.type === "form.cancelled") {
     return [{ ...normalized, type: event.type === "form.replied"
@@ -78,9 +82,11 @@ export function normalizeV2Event(event) {
   return [normalized]
 }
 
-export function createV2Client(ctx, resolveFormApi = (sessionID) => getFormApi(ctx, sessionID)) {
-  return {
-    liveBridge: createV2LiveClient(ctx),
+export function createV2Client(ctx, resolveFormApi) {
+  const liveBridge = createV2LiveClient(ctx)
+  resolveFormApi ??= (sessionID) => getFormApi(ctx, sessionID, { ownsSession: liveBridge.ownsSession })
+  const client = {
+    liveBridge,
     app: {
       async log({ body }) {
         // Server stderr is captured by OpenCode's log, never the TUI input.
@@ -101,10 +107,13 @@ export function createV2Client(ctx, resolveFormApi = (sessionID) => getFormApi(c
       decision: body.response,
     })),
     v2: { session: { question: {
-      async reply({ sessionID, requestID, questionV2Reply }) {
+      async reply({ sessionID, requestID, questionV2Reply, expectedNativeRevision }) {
         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)
+        if (expectedNativeRevision && questionProperties(form).nativeRevision !== expectedNativeRevision) {
+          throw Object.assign(new HttpError("The native question changed; read it again", 409), { code: "question_changed_read_again" })
+        }
         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)
@@ -132,16 +141,27 @@ export function createV2Client(ctx, resolveFormApi = (sessionID) => getFormApi(c
       },
     } } },
     async ownsEvent(event) {
-      if (event.location?.directory) return event.location.directory === ctx.location.directory
+      if (event.location?.directory === ctx.location.directory) return true
       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
+        const session = await liveBridge.get(sessionID)
+        return liveBridge.ownsSession(session)
       } catch {
         return false
       }
     },
   }
+  client.liveBridge.questions = async (sessionID) => {
+    const api = await resolveFormApi(sessionID)
+    const forms = await nativeReply(() => api.list({ sessionID }))
+    if (!Array.isArray(forms)) throw new HttpError("Invalid question list", 502)
+    return forms.filter(form => form.sessionID === sessionID && questionForm(form) &&
+      (!form.state || form.state.status === "pending")).map(questionProperties)
+  }
+  client.liveBridge.answerQuestion = (pending, answers) => client.v2.session.question.reply({
+    sessionID: pending.sessionID, requestID: pending.id, questionV2Reply: { answers }, expectedNativeRevision: pending.nativeRevision,
+  })
+  return client
 }

package/src/opencode-v2-endpoint.js

@@ -0,0 +1,54 @@
+import { readdir, readFile, readlink } from "node:fs/promises"
+import { Service } from "@opencode/client/service"
+
+import { HttpError } from "./http.js"
+
+// Inspect only sockets already owned by this server; never scan other ports.
+export async function ownLoopbackUrls({ platform = process.platform, fs = { readdir, readFile, readlink } } = {}) {
+  if (platform !== "linux") return []
+  const inodes = new Set((await Promise.all((await fs.readdir("/proc/self/fd")).map(async fd => {
+    try { return /^socket:\[(\d+)\]$/.exec(await fs.readlink(`/proc/self/fd/${fd}`))?.[1] }
+    catch { return undefined } // Descriptors can close while being inspected.
+  }))).filter(Boolean))
+  const tables = await Promise.all(["tcp", "tcp6"].map(async name => {
+    try { return await fs.readFile(`/proc/self/net/${name}`, "utf8") }
+    catch (error) { if (error.code === "ENOENT") return ""; throw error }
+  }))
+  const urls = new Set()
+  for (const table of tables) for (const row of table.trim().split("\n").slice(1)) {
+    const fields = row.trim().split(/\s+/)
+    if (fields[3] !== "0A" || !inodes.has(fields[9])) continue
+    const [address, portHex] = fields[1].split(":")
+    const host = address === "0100007F" ? "127.0.0.1"
+      : address === "00000000000000000000000001000000" ? "[::1]" : undefined
+    const port = Number.parseInt(portHex, 16)
+    if (host && port > 0 && port <= 65535) urls.add(`http://${host}:${port}`)
+  }
+  return [...urls]
+}
+
+export async function privateEndpoint({ argv = process.argv, env = process.env, pid = process.pid,
+  urls = ownLoopbackUrls, request = fetch } = {}) {
+  if (!argv.includes("--stdio")) return undefined
+  const flag = argv.indexOf("--port")
+  const rawPort = flag >= 0 ? argv[flag + 1] : argv.find(arg => arg.startsWith("--port="))?.slice(7)
+  const port = typeof rawPort === "string" && /^\d+$/.test(rawPort) ? Number(rawPort) : NaN
+  const password = env.OPENCODE_PASSWORD
+  try {
+    if (!Number.isInteger(port) || port < 0 || port > 65535 || !password) throw new Error()
+    const candidates = port === 0 ? await urls() : [`http://127.0.0.1:${port}`]
+    for (const url of candidates) {
+      const endpoint = { url, auth: { type: "basic", username: "opencode", password } }
+      let response
+      try {
+        response = await request(`${url}/api/info`, {
+          headers: Service.headers(endpoint), signal: AbortSignal.timeout(2000), redirect: "error",
+        })
+        if (response.ok && (await response.json()).pid === pid) return endpoint
+      } catch { /* Another listener owned by this process is not its native API. */ }
+      finally { await response?.body?.cancel().catch(() => {}) }
+    }
+  } catch { /* Report only a safe diagnostic, never upstream credentials or output. */ }
+  throw Object.assign(new HttpError("The existing private OpenCode server could not be verified; keep its session running", 501),
+    { code: "question_private_server_unavailable" })
+}

package/src/opencode-v2-forms.js

@@ -2,23 +2,34 @@ import { OpenCode } from "@opencode/client"
 import { Service } from "@opencode/client/service"
 
 import { HttpError } from "./http.js"
+import { privateEndpoint } from "./opencode-v2-endpoint.js"
 
-export async function getFormApi(ctx, sessionID, { makeClient = OpenCode.make } = {}) {
+function unavailable(code, message, status = 501) {
+  return Object.assign(new HttpError(message, status), { code })
+}
+
+export async function getFormApi(ctx, sessionID, { makeClient = OpenCode.make, ownsSession, resolvePrivate = privateEndpoint } = {}) {
   // 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 })
+  // Prefer the current private server; never start a second service or change it.
+  // discover() itself checks the registered service's protocol compatibility.
+  // An app patch-version difference must not hide a compatible owning service.
+  const endpoint = await resolvePrivate() ?? await Service.discover({ version: ctx.app.version }) ?? await Service.discover()
   if (!endpoint) {
-    throw new HttpError("Remote question replies require the OpenCode V2 shared service", 501)
+    throw unavailable("question_shared_service_unavailable", "Remote questions require a compatible running OpenCode V2 shared service")
   }
   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)
+    throw unavailable("question_session_not_in_shared_service", "The question session is not owned by the shared OpenCode service")
+  }
+  if (session.id !== undefined && session.id !== sessionID) {
+    throw unavailable("question_session_not_in_shared_service", "The shared service returned another question session")
   }
-  if (session.location.directory !== ctx.location.directory) {
-    throw new HttpError("The question session belongs to another OpenCode location", 403)
+  const owned = ownsSession ? await ownsSession(session) : session.location?.directory === ctx.location.directory
+  if (!owned) {
+    throw unavailable("question_session_location_mismatch", "The question session belongs to another OpenCode location", 403)
   }
   return client.session.form
 }

package/src/opencode-v2-tui.js

@@ -0,0 +1,49 @@
+import { loadConfig } from "./config.js"
+import { createLiveBridge } from "./live-bridge.js"
+import { createV2Client, normalizeV2Event } from "./opencode-v2-client.js"
+import { HttpError } from "./http.js"
+
+// The public TUI plugin context injects the client of the actual connected
+// OpenCode owner, including standalone processes. Never discover another server.
+export async function setup(ctx) {
+  if (ctx.options?.liveBridge?.owner !== "tui" || !ctx.location?.directory) return
+  const native = ctx.client
+  if (!native?.session?.form?.list || !native.session.form.get || !native.session.form.reply ||
+      !native.session.form.cancel || !native.session.get || !native.session.prompt) {
+    throw new HttpError("The injected OpenCode client does not expose native question forms", 501)
+  }
+  const config = loadConfig(ctx.options)
+  if (!config.liveBridge.enabled) return
+  const ownerContext = { app: ctx.app, options: ctx.options, location: ctx.location, session: native.session }
+  let client
+  client = createV2Client(ownerContext, async sessionID => {
+    const info = await native.session.get({ sessionID })
+    if (info.id !== sessionID || !await client.liveBridge.ownsSession(info)) {
+      throw Object.assign(new HttpError("The native question session is outside the verified project", 403),
+        { code: "question_session_location_mismatch" })
+    }
+    return native.session.form
+  })
+  client.liveBridge.questionTransport = "injected_native_client"
+  const bridge = await createLiveBridge({ config, client, directory: ctx.location.directory })
+  let disposed = false
+  // Public native data events, not terminal content or UI automation. New
+  // subscribers read authoritative pending forms directly from the same owner.
+  const unlisten = ctx.data.listen(({ details }) => {
+    void (async () => {
+      if (disposed || !await client.ownsEvent(details)) return
+      for (const event of normalizeV2Event(details)) {
+        if (disposed) return
+        await bridge.handle(event)
+      }
+    })().catch(() => { /* A failed event must not affect the native TUI or active work. */ })
+  })
+  let cleanup
+  return () => cleanup ??= (async () => {
+    disposed = true
+    unlisten()
+    await bridge.dispose()
+  })()
+}
+
+export default { id: "backeer-opencode", setup }

package/src/plugin.js

@@ -48,7 +48,9 @@ export default async function BackeerPlugin({ client, directory, feedback, v2 =
   const reporter = createOpenCodeReporter(client, config.logLevel)
   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) => {
+  const bridgeConfig = config.liveBridge.owner === "tui"
+    ? { ...config, liveBridge: { enabled: false } } : config
+  const liveBridge = await createLiveBridge({ config: bridgeConfig, client, directory, reporter }).catch((error) => {
     reporter.error("Live control unavailable", error)
     return { async handle() {}, async dispose() {} }
   })

package/src/question-command.js

@@ -14,22 +14,27 @@ export function validateQuestionCommand(command, pending, now = Date.now()) {
   }
   if (response.action === "reject") return
 
-  if (!Array.isArray(response.answers) || response.answers.length !== pending.questions.length) {
-    return { status: "rejected", action: response.action, errorCode: "invalid_answers" }
+  const errorCode = validateQuestionAnswers(response.answers, pending.questions)
+  if (errorCode) return { status: "rejected", action: response.action, errorCode }
+}
+
+export function validateQuestionAnswers(values, questions) {
+  if (!Array.isArray(values) || values.length !== questions.length) {
+    return "invalid_answers"
   }
-  for (let index = 0; index < pending.questions.length; index++) {
-    const question = pending.questions[index]
-    const answers = response.answers[index]
+  for (let index = 0; index < questions.length; index++) {
+    const question = questions[index]
+    const answers = values[index]
     if (!Array.isArray(answers) || (!question.multiple && answers.length > 1)) {
-      return { status: "rejected", action: response.action, errorCode: "invalid_answers" }
+      return "invalid_answers"
     }
     for (const answer of answers) {
       if (typeof answer !== "string" || answer.trim().length === 0) {
-        return { status: "rejected", action: response.action, errorCode: "invalid_answers" }
+        return "invalid_answers"
       }
       const known = question.options.some((option) => option.label === answer)
       if (!known && !question.custom) {
-        return { status: "rejected", action: response.action, errorCode: "custom_not_allowed" }
+        return "custom_not_allowed"
       }
     }
   }

package/src/updates.js

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