backeer-opencode 0.8.1 → 0.10.0

package/src/live-session-manager.js

@@ -2,11 +2,12 @@ import { randomUUID } from "node:crypto"
 import { LiveControlClient, readLiveControlToken } from "./live-control-client.js"
 import { ConnectionError, loadConnectionProfiles, saveConnectionProfiles, connectionProfile } from "./live-profiles.js"
 import { discoverLiveConnections, discoveryDefaults } from "./live-discovery.js"
+import { connectionDiagnostic } from "./live-diagnostics.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 = Infinity,
     discovery = discoveryDefaults() }) {
     this.profilesFile = profilesFile
     this.clientFactory = clientFactory
@@ -18,6 +19,7 @@ export class LiveSessionManager {
     this.candidates = new Map()
     this.saving = Promise.resolve()
     this.shutdown = new AbortController()
+    this.pendingBindings = 0
   }
 
   async profiles() {
@@ -31,11 +33,12 @@ export class LiveSessionManager {
     return profile
   }
 
-  async client(profile) {
-    const token = await readLiveControlToken(profile.tokenFile)
+  async client(profile, sessionId) {
+    let token
+    try { token = await readLiveControlToken(profile.tokenFile) }
+    catch (error) { throw Object.assign(error, { connectionCode: connectionDiagnostic(error, { tokenFile: true }).code }) }
     if (this.closed) throw new ConnectionError("Connection manager is closed.")
-    if (this.clients.size >= this.maxBindings) throw new ConnectionError("Connection limit reached. Disconnect an unused chat binding first.")
-    const client = this.clientFactory({ url: profile.url, token, expectedDirectory: profile.directory })
+    const client = this.clientFactory({ url: profile.url, token, expectedDirectory: profile.directory, sessionId })
     this.clients.add(client)
     return client
   }
@@ -51,6 +54,7 @@ export class LiveSessionManager {
     try {
       const result = await client.listSessions()
       this.checkProject(profile, result)
+      this.checkSessionList(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) }
@@ -58,26 +62,43 @@ export class LiveSessionManager {
 
   checkProject(profile, result) {
     if (result?.directory !== profile.directory) {
-      throw new ConnectionError("Project verification failed. Check the tunnel target and exact project directory; the remote bridge must support project verification (0.6.0 or newer).")
+      throw Object.assign(new ConnectionError("Project verification failed. Check the tunnel target and exact project directory; the remote bridge must support project verification (0.6.0 or newer)."), { connectionCode: "project_mismatch" })
+    }
+  }
+
+  checkSessionList(result) {
+    if (!Array.isArray(result?.sessions) || result.sessions.some(item =>
+      typeof item?.id !== "string" || !/^[A-Za-z0-9_-]+$/.test(item.id) || typeof item.title !== "string")) {
+      throw Object.assign(new Error("Invalid bridge session list"), { connectionCode: "invalid_bridge_response" })
     }
   }
 
   async connect(connection, sessionId, { sessionTitle } = {}) {
+    if (this.closed) throw new ConnectionError("Connection manager is closed.")
+    if (this.bindings.size + this.pendingBindings >= this.maxBindings) {
+      throw new ConnectionError("Connection limit reached. Disconnect an unused chat binding first.")
+    }
+    this.pendingBindings++
+    try { return await this.connectSelected(connection, sessionId, { sessionTitle }) }
+    finally { this.pendingBindings-- }
+  }
+
+  async connectSelected(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.")
+      if (typeof sessionTitle !== "string" || !sessionTitle.trim()) 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") {
+    if (typeof sessionId !== "string" || !/^[A-Za-z0-9_-]+$/.test(sessionId) || sessionId === "global") {
       throw new ConnectionError("Invalid OpenCode session ID.")
     }
     const profile = await this.profile(connection)
-    const client = await this.client(profile)
+    const client = await this.client(profile, sessionId)
     try {
       const session = await client.sessionStatus(sessionId)
       this.checkProject(profile, session)
@@ -85,7 +106,7 @@ export class LiveSessionManager {
       await client.start()
       if (this.closed) throw new ConnectionError("Connection manager is closed.")
       const bindingId = randomUUID()
-      this.bindings.set(bindingId, { profile, sessionId, client })
+      this.bindings.set(bindingId, { profile, sessionId, client, session })
       return { bindingId, connection, session, cursor: client.cursor,
         connectionStatus: client.status, scope: "Keep this bindingId only in this chat. Other chats connect separately." }
     } catch (error) { await this.release(client); throw error }
@@ -113,7 +134,8 @@ export class LiveSessionManager {
 
   async status(bindingId) {
     const value = await this.verified(bindingId)
-    return { bindingId, connection: value.profile.name, session: value.session, connectionStatus: value.client.status }
+    return { bindingId, connection: value.profile.name, session: value.session, verified: true,
+      connectionStatus: value.client.status, transport: value.client.connectionState() }
   }
 
   async send(bindingId, { requestId, prompt }, signal) {
@@ -132,8 +154,68 @@ export class LiveSessionManager {
   }
 
   async read(bindingId, options, waitMs = 0, signal) {
-    const value = await this.verified(bindingId)
-    return value.client.readEvents({ ...options, sessionId: value.sessionId }, { waitMs, signal })
+    let value
+    try { value = await this.verified(bindingId) }
+    catch (error) {
+      // A temporary tunnel outage must not hide output already buffered for this
+      // immutable binding. Permission/project/session failures still fail closed.
+      if (!error.connectionCode || !connectionDiagnostic(error).retryable) throw error
+      value = this.binding(bindingId)
+      const current = await this.profile(value.profile.name)
+      if (JSON.stringify(current) !== JSON.stringify(value.profile)) throw new ConnectionError("Connection profile changed. Disconnect and reconnect this chat to verify the new target.")
+      const result = value.client.snapshot({ ...options, sessionId: value.sessionId })
+      return { ...result, verified: false, diagnostic: connectionDiagnostic(error),
+        nextStep: "Keep this binding and cursor. The stream retries every 3 seconds; verify the same session after reconnection before sending or acknowledging a gap." }
+    }
+    const result = await value.client.readEvents({ ...options, sessionId: value.sessionId }, { waitMs, signal })
+    return { ...result, verified: true }
+  }
+
+  async diagnose({ connection, bindingId } = {}) {
+    if ((connection === undefined) === (bindingId === undefined)) throw new ConnectionError("Choose one saved connection or one chat binding to diagnose.")
+    const bound = bindingId ? this.binding(bindingId) : undefined
+    const profile = bound?.profile ?? await this.profile(connection)
+    let client
+    try {
+      if (bound) {
+        const result = await this.status(bindingId)
+        return { ...result, healthy: result.connectionStatus === "connected" }
+      }
+      client = await this.client(profile)
+      const result = await client.listSessions()
+      this.checkProject(profile, result)
+      this.checkSessionList(result)
+      return { connection: profile.name, directory: profile.directory, healthy: true, verified: true,
+        nextStep: "Choose an existing session by title. No remote work was changed." }
+    } catch (error) {
+      // Local profile errors should retain their own precise safe message.
+      if (error instanceof ConnectionError && !error.connectionCode) throw error
+      return { connection: profile.name, ...(bindingId ? { bindingId } : {}), healthy: false, verified: false,
+        diagnostic: connectionDiagnostic(error), ...(bound ? { transport: bound.client.connectionState() } : {}) }
+    } finally { if (client) await this.release(client) }
+  }
+
+  async setup({ connection, url, tokenFile } = {}, signal) {
+    if (connection !== undefined) {
+      if (url !== undefined || tokenFile !== undefined) throw new ConnectionError("Choose a saved connection or discovery inputs, not both.")
+      try {
+        const result = await this.listSessions(connection)
+        return { stage: "choose_session", ...result, nextTool: "connect_session", requiresSelection: true,
+          nextStep: result.sessions.length ? "Ask the user to choose a session by title, then connect this chat. Never select the newest automatically."
+            : "No main sessions are available. Keep existing work intact; ask the user which session to use." }
+      } catch (error) {
+        if (error instanceof ConnectionError && !error.connectionCode) throw error
+        return { stage: "fix_connection", connection, diagnostic: connectionDiagnostic(error), nextTool: "diagnose_connection" }
+      }
+    }
+    const profiles = await this.profiles()
+    if (profiles.length && url === undefined && tokenFile === undefined) {
+      return { stage: "choose_connection", connections: profiles.map(({ name, url, directory }) => ({ name, url, directory })),
+        nextTool: "connection_setup", requiresSelection: true, nextStep: "Ask the user to select the intended connection, then call connection_setup with its name." }
+    }
+    const result = await this.discover({ url, tokenFile }, signal)
+    return { stage: result.candidates.length ? "choose_candidate" : "fix_connection", ...result,
+      nextTool: result.candidates.length ? "save_connection" : "discover_connections", requiresSelection: true }
   }
 
   async disconnect(bindingId) {
@@ -160,7 +242,6 @@ export class LiveSessionManager {
     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)
@@ -168,6 +249,7 @@ export class LiveSessionManager {
         url: candidate.profile.url, directory: candidate.profile.directory, sessions: candidate.sessions, subagentCount: candidate.subagentCount })
     }
     return { candidates, diagnostics: candidates.length ? [] : result.diagnostics,
+      diagnosticDetails: candidates.length ? [] : result.diagnosticDetails,
       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." }
   }
@@ -179,7 +261,11 @@ export class LiveSessionManager {
       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()) }
+      try {
+        const result = await client.listSessions()
+        this.checkProject(profile, result)
+        this.checkSessionList(result)
+      }
       finally { await this.release(client) }
       if (this.closed) throw new ConnectionError("Connection manager is closed.")
       const profiles = await this.profiles()

package/src/live-session-scope.js

@@ -14,9 +14,9 @@ async function commonDirectory(directory) {
 // Follow only an already observed exact session into a real worktree of the
 // same Git repository. A path prefix or a remote projectID alone is not proof.
 export function approvedWorktreeSessions(value) {
-  if (!Array.isArray(value) || value.length > 16) return []
-  return value.filter(item => /^[A-Za-z0-9_-]{1,160}$/.test(item?.sessionID) && item.sessionID !== "global" &&
-    typeof item.directory === "string" && isAbsolute(item.directory) && item.directory.length <= 4096)
+  if (!Array.isArray(value)) return []
+  return value.filter(item => /^[A-Za-z0-9_-]+$/.test(item?.sessionID) && item.sessionID !== "global" &&
+    typeof item.directory === "string" && isAbsolute(item.directory))
 }
 
 export function createSessionScope(directory, { resolveCommon = commonDirectory, approvedSessions = [] } = {}) {
@@ -28,7 +28,6 @@ export function createSessionScope(directory, { resolveCommon = commonDirectory,
     if (location === directory) {
       if (info.id) {
         observed.set(info.id, info.projectID)
-        if (observed.size > 256) observed.delete(observed.keys().next().value)
       }
       return true
     }

package/src/opencode-v2-endpoint.js

@@ -28,14 +28,20 @@ export async function ownLoopbackUrls({ platform = process.platform, fs = { read
 }
 
 export async function privateEndpoint({ argv = process.argv, env = process.env, pid = process.pid,
+  platform = process.platform, initialEnvironment = () => readFile("/proc/self/environ", "utf8"),
   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()
+    if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error()
+    // OpenCode removes this variable at runtime. Linux retains this process's
+    // initial environment; read only our own existing password, never another PID.
+    const password = env.OPENCODE_PASSWORD || (platform === "linux"
+      ? (await initialEnvironment()).split("\0").find(value => value.startsWith("OPENCODE_PASSWORD="))?.slice(18)
+      : undefined)
+    if (!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 } }

package/src/permission-controller.js

@@ -10,7 +10,7 @@ import {
   validateQuestionCommand,
 } from "./question-command.js"
 import { runCommandStream } from "./sse.js"
-import { rememberBounded } from "./utilities.js"
+import { remember } from "./utilities.js"
 
 async function replyToOpenCode(client, pending, decision) {
   const result = await client.postSessionIdPermissionsPermissionId({
@@ -110,7 +110,7 @@ export async function replyToQuestion(client, pending, response) {
 
 async function postQuestionState(config, eventID, path, body = {}) {
   const url = new URL(`/v1/events/${encodeURIComponent(eventID)}/${path}`, config.origin)
-  await postJsonWithRetry(config, url, body, { retryDelays: [0, 500] })
+  await postJsonWithRetry(config, url, body)
 }
 
 export function createPermissionController({
@@ -173,7 +173,7 @@ export function createPermissionController({
   async function handleCommand(command) {
     if (!command || typeof command !== "object") return
     if (!["opencode_permission_reply", "opencode_question_reply"].includes(command.type)) return
-    if (typeof command.id !== "string" || command.id.length > 200) return
+    if (typeof command.id !== "string") return
 
     const previousAcknowledgement = completedCommands.get(command.id)
     if (previousAcknowledgement) {
@@ -238,7 +238,7 @@ export function createPermissionController({
       externalId: command.externalId,
       processedAt: new Date().toISOString(),
     }
-    rememberBounded(completedCommands, command.id, acknowledgement)
+    remember(completedCommands, command.id, acknowledgement)
 
     if (isQuestion) {
       reportQuestionAcknowledgement(acknowledgement, pending, reporter, conversation)

package/src/plugin.js

@@ -45,10 +45,13 @@ export default async function BackeerPlugin({ client, directory, feedback, v2 =
     return {}
   }
 
+  const shutdown = new AbortController()
+  config.signal = shutdown.signal
   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 bridgeConfig = config.liveBridge.owner === "tui"
+  const bridgeConfig = config.liveBridge.owner === "tui" ||
+    (config.liveBridge.owner === "standalone" && (!v2 || !process.argv.includes("--stdio")))
     ? { ...config, liveBridge: { enabled: false } } : config
   const liveBridge = await createLiveBridge({ config: bridgeConfig, client, directory, reporter }).catch((error) => {
     reporter.error("Live control unavailable", error)
@@ -232,6 +235,7 @@ export default async function BackeerPlugin({ client, directory, feedback, v2 =
       await Promise.all([handleNotificationEvent(event), liveBridge.handle(event)])
     },
     dispose: async () => {
+      shutdown.abort()
       await liveBridge.dispose()
       await permissionController.dispose()
       lifecycleController.dispose()

package/src/reporter.js

@@ -1,4 +1,4 @@
-import { limit } from "./utilities.js"
+import { formatText } from "./utilities.js"
 
 const LOG_LEVELS = new Set(["silent", "error", "info", "debug"])
 const LOG_RANK = { silent: 0, error: 1, info: 2, debug: 3 }
@@ -36,13 +36,10 @@ export function createConsoleReporter(levelValue) {
       if (previous && now - previous < LOG_DEDUPLICATION_MS) return
       recentlyEmitted.delete(key)
       recentlyEmitted.set(key, now)
-      while (recentlyEmitted.size > 100) {
-        recentlyEmitted.delete(recentlyEmitted.keys().next().value)
-      }
     }
 
     const technical = level === "debug" && detail
-      ? decorate("2", ` · ${limit(detail, 500)}`)
+      ? decorate("2", ` · ${formatText(detail)}`)
       : ""
     const line = `${symbols[kind]} ${brand}  ${message}${technical}`
     if (kind === "error" || kind === "warning") console.error(line)
@@ -80,10 +77,10 @@ export function createOpenCodeReporter(client, levelValue) {
       level: kind === "warning" ? "warn" : kind === "applied" || kind === "success"
         ? "info"
         : kind,
-      message: limit(message, 500),
+      message: formatText(message),
     }
     if (level === "debug" && detail) {
-      body.extra = { detail: limit(detail?.message ?? detail, 500) }
+      body.extra = { detail: formatText(detail?.message ?? detail) }
     }
 
     // Logging during plugin initialization can deadlock older OpenCode builds.
@@ -106,5 +103,4 @@ export function createOpenCodeReporter(client, levelValue) {
 function rememberRecent(map, key, value) {
   map.delete(key)
   map.set(key, value)
-  while (map.size > 100) map.delete(map.keys().next().value)
 }

package/src/session-messages.js

@@ -1,5 +1,5 @@
 import { FeedbackSessionStore } from "./feedback-session-store.js"
-import { limit } from "./utilities.js"
+import { formatText } from "./utilities.js"
 
 const FEEDBACK_SYMBOLS = {
   info: "•",
@@ -82,7 +82,7 @@ export async function sendSessionMessage(client, sessionID, text) {
 
 export function formatBackeerFeedback(kind, message) {
   const symbol = FEEDBACK_SYMBOLS[kind] ?? FEEDBACK_SYMBOLS.info
-  return `▣ Backeer | ${symbol} ${limit(message, 300)}`
+  return `▣ Backeer | ${symbol} ${formatText(message)}`
 }
 
 export function formatBackeerFeedbackBatch(items) {
@@ -93,7 +93,7 @@ export function formatBackeerFeedbackBatch(items) {
     "▣ Backeer",
     ...items.map((item) => {
       const symbol = FEEDBACK_SYMBOLS[item.kind] ?? FEEDBACK_SYMBOLS.info
-      return `${symbol} ${limit(item.message, 300)}`
+      return `${symbol} ${formatText(item.message)}`
     }),
   ].join("\n")
 }

package/src/sse.js

@@ -1,5 +1,5 @@
 import { HttpError, isAbortError, sleep } from "./http.js"
-import { limit } from "./utilities.js"
+import { formatText } from "./utilities.js"
 
 export function parseSseFrame(frame) {
   const data = []
@@ -87,7 +87,7 @@ async function openCommandStream(config, state, signal, fetchImplementation) {
     signal,
   })
   if (!response.ok) {
-    const responseBody = limit(await response.text(), 500)
+    const responseBody = formatText(await response.text())
     throw new HttpError(
       `Backeer command stream failed with status ${response.status}`,
       response.status,
@@ -123,7 +123,7 @@ async function consumeConnection({
 function streamErrorState(error, lastLoggedError, reconnectDelay, reporter) {
   const message = error instanceof HttpError
     ? `${error.message}: ${error.responseBody}`
-    : limit(error, 500)
+    : formatText(error)
   if (message !== lastLoggedError) {
     const authenticationFailure = error instanceof HttpError &&
       [401, 403].includes(error.status)
@@ -137,7 +137,7 @@ function streamErrorState(error, lastLoggedError, reconnectDelay, reporter) {
   return {
     lastLoggedError: message,
     reconnectDelay: error instanceof HttpError && [401, 403, 404].includes(error.status)
-      ? 60_000
+      ? 3000
       : reconnectDelay,
   }
 }
@@ -156,7 +156,7 @@ export async function runCommandStream(
   },
 ) {
   const state = { lastEventID: "", framesReceived: 0 }
-  let reconnectDelay = 1000
+  let reconnectDelay = 3000
   let lastLoggedError = ""
 
   while (!signal.aborted && hasPending()) {
@@ -176,7 +176,7 @@ export async function runCommandStream(
         now,
         stableConnectionMs,
         onStable: () => {
-          reconnectDelay = 1000
+          reconnectDelay = 3000
           lastLoggedError = ""
         },
       })
@@ -189,7 +189,7 @@ export async function runCommandStream(
 
     if (!signal.aborted && hasPending()) {
       await sleepImplementation(reconnectDelay, signal)
-      reconnectDelay = Math.min(reconnectDelay * 2, 60_000)
+      reconnectDelay = 3000
     }
   }
 }

package/src/updates.js

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

package/src/utilities.js

@@ -1,7 +1,5 @@
-const MAX_TRACKED_ITEMS = 500
-
-export const limit = (value, length = 1000) =>
-  String(value ?? "").slice(0, length)
+// Legacy formatting API: normalize text without truncating it.
+export const formatText = value => String(value ?? "")
 
 export function enabled(value, fallback = true) {
   if (typeof value === "boolean") return value
@@ -18,8 +16,7 @@ export function stableHash(value) {
   return (hash >>> 0).toString(16).padStart(8, "0")
 }
 
-export function rememberBounded(map, key, value) {
+export function remember(map, key, value) {
   map.delete(key)
   map.set(key, value)
-  while (map.size > MAX_TRACKED_ITEMS) map.delete(map.keys().next().value)
 }