backeer-opencode 0.6.0 → 0.8.0

package/src/live-session-manager.js

@@ -1,17 +1,23 @@
 import { randomUUID } from "node:crypto"
 import { LiveControlClient, readLiveControlToken } from "./live-control-client.js"
-import { ConnectionError, loadConnectionProfiles } from "./live-profiles.js"
+import { ConnectionError, loadConnectionProfiles, saveConnectionProfiles, connectionProfile } from "./live-profiles.js"
+import { discoverLiveConnections, discoveryDefaults } from "./live-discovery.js"
 
 // Bindings are immutable capabilities, kept in the calling chat, never a global "current session".
 // Each binding owns its SSE client/cursor, even when two chats target the same session.
 export class LiveSessionManager {
-  constructor({ profilesFile, clientFactory = options => new LiveControlClient(options), maxBindings = 16 }) {
+  constructor({ profilesFile, clientFactory = options => new LiveControlClient(options), maxBindings = 16,
+    discovery = discoveryDefaults() }) {
     this.profilesFile = profilesFile
     this.clientFactory = clientFactory
     this.maxBindings = maxBindings
     this.bindings = new Map()
     this.clients = new Set()
     this.closed = false
+    this.discovery = discovery
+    this.candidates = new Map()
+    this.saving = Promise.resolve()
+    this.shutdown = new AbortController()
   }
 
   async profiles() {
@@ -39,13 +45,14 @@ export class LiveSessionManager {
     finally { this.clients.delete(client) }
   }
 
-  async listSessions(connection) {
+  async listSessions(connection, { includeChildren = false } = {}) {
     const profile = await this.profile(connection)
     const client = await this.client(profile)
     try {
       const result = await client.listSessions()
       this.checkProject(profile, result)
-      return { connection, ...result }
+      return { connection, ...result, sessions: result.sessions.filter(item => includeChildren || !item.parentID),
+        subagentCount: result.sessions.filter(item => item.parentID).length }
     } finally { await this.release(client) }
   }
 
@@ -55,7 +62,17 @@ export class LiveSessionManager {
     }
   }
 
-  async connect(connection, sessionId) {
+  async connect(connection, sessionId, { sessionTitle } = {}) {
+    if ((sessionId === undefined) === (sessionTitle === undefined)) {
+      throw new ConnectionError("Choose exactly one session ID or exact session title from the current list.")
+    }
+    if (sessionTitle !== undefined) {
+      if (typeof sessionTitle !== "string" || !sessionTitle.trim() || sessionTitle.length > 240) throw new ConnectionError("Invalid session title.")
+      const result = await this.listSessions(connection)
+      const matches = result.sessions.filter(item => item.title === sessionTitle)
+      if (matches.length !== 1) throw new ConnectionError("Session title is missing or ambiguous. Refresh the session list and select an exact session ID.")
+      sessionId = matches[0].id
+    }
     if (typeof sessionId !== "string" || !/^[A-Za-z0-9_-]{1,160}$/.test(sessionId) || sessionId === "global") {
       throw new ConnectionError("Invalid OpenCode session ID.")
     }
@@ -104,6 +121,16 @@ export class LiveSessionManager {
     return value.client.sendInstruction({ sessionId: value.sessionId, requestId, prompt, signal })
   }
 
+  async questions(bindingId) {
+    const value = await this.verified(bindingId)
+    return value.client.listQuestions(value.sessionId)
+  }
+
+  async answer(bindingId, args, signal) {
+    const value = await this.verified(bindingId)
+    return value.client.answerQuestion({ ...args, sessionId: value.sessionId, signal })
+  }
+
   async read(bindingId, options, waitMs = 0, signal) {
     const value = await this.verified(bindingId)
     return value.client.readEvents({ ...options, sessionId: value.sessionId }, { waitMs, signal })
@@ -116,9 +143,60 @@ export class LiveSessionManager {
     return { disconnected: true, remoteWorkStopped: false }
   }
 
+  async discover(options = {}, signal) {
+    const controller = new AbortController()
+    const abort = () => controller.abort()
+    this.shutdown.signal.addEventListener("abort", abort, { once: true })
+    signal?.addEventListener("abort", abort, { once: true })
+    if (signal?.aborted || this.closed) abort()
+    let result
+    try { result = await discoverLiveConnections({ profiles: await this.profiles(), defaults: this.discovery, ...options, signal: controller.signal }) }
+    finally {
+      this.shutdown.signal.removeEventListener("abort", abort)
+      signal?.removeEventListener("abort", abort)
+    }
+    if (this.closed) throw new ConnectionError("Connection manager is closed.")
+    const candidates = []
+    for (const candidate of result.candidates) {
+      let id = [...this.candidates].find(([, item]) => JSON.stringify(item.profile) === JSON.stringify(candidate.profile))?.[0]
+      if (!id) {
+        if (this.candidates.size >= 32) throw new ConnectionError("Discovery candidate limit reached. Restart discovery in a new MCP process.")
+        id = randomUUID()
+      }
+      this.candidates.set(id, candidate)
+      candidates.push({ candidateId: id, savedName: candidate.profile.name === "discovered" ? undefined : candidate.profile.name,
+        url: candidate.profile.url, directory: candidate.profile.directory, sessions: candidate.sessions, subagentCount: candidate.subagentCount })
+    }
+    return { candidates, diagnostics: candidates.length ? [] : result.diagnostics,
+      nextStep: candidates.length ? "Select the intended connection, save it with a short name, then choose a session by title."
+        : "Open the intended SSH tunnel and select an existing protected live-control token file. Do not paste credentials into chat." }
+  }
+
+  saveDiscovered(candidateId, name) {
+    // Serialize local saves so concurrent chats cannot overwrite each other's connection profiles.
+    const save = this.saving.then(async () => {
+      const candidate = this.candidates.get(candidateId)
+      if (!candidate || this.closed) throw new ConnectionError("Discovery candidate not found. Discover connections again.")
+      const profile = connectionProfile({ ...candidate.profile, name })
+      const client = await this.client(profile)
+      try { this.checkProject(profile, await client.listSessions()) }
+      finally { await this.release(client) }
+      if (this.closed) throw new ConnectionError("Connection manager is closed.")
+      const profiles = await this.profiles()
+      const existing = profiles.find(item => item.name === name)
+      if (existing && JSON.stringify(existing) !== JSON.stringify(profile)) throw new ConnectionError("Connection name already belongs to another target. Choose another name.")
+      if (!existing) await saveConnectionProfiles(this.profilesFile, [...profiles, profile])
+      return { connection: name, directory: profile.directory, saved: true, sessionStored: false }
+    })
+    this.saving = save.catch(() => {})
+    return save
+  }
+
   async close() {
     this.closed = true
+    this.shutdown.abort()
     this.bindings.clear()
+    this.candidates.clear()
     await Promise.allSettled([...this.clients].map(client => this.release(client)))
   }
 }

package/src/opencode-v2-client.js

@@ -28,25 +28,26 @@ function questionForm(form) {
     )
 }
 
+function questionProperties(form) {
+  return { 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,
+    })) }
+}
+
 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"
@@ -79,7 +80,7 @@ export function normalizeV2Event(event) {
 }
 
 export function createV2Client(ctx, resolveFormApi = (sessionID) => getFormApi(ctx, sessionID)) {
-  return {
+  const client = {
     liveBridge: createV2LiveClient(ctx),
     app: {
       async log({ body }) {
@@ -144,4 +145,15 @@ export function createV2Client(ctx, resolveFormApi = (sessionID) => getFormApi(c
       }
     },
   }
+  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 },
+  })
+  return client
 }

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.6.0"
+export const PLUGIN_VERSION = "0.8.0"
 
 const PACKAGE_NAME = "backeer-opencode"
 const NPM_REGISTRY_URL = "https://registry.npmjs.org"