@bybrawe/opencode-loop 0.5.26 → 0.5.28

package/src/source/opencode/adapter.js

@@ -0,0 +1,21 @@
+import {
+  activeRunCompletionFromMessages,
+  compactSession,
+  executeTuiCommand,
+  log,
+  readRecentSessionMessages,
+  resolveCompactionModel,
+  toast,
+} from "./host.js"
+
+export function createOpenCodeHostAdapter(client, directory) {
+  return Object.freeze({
+    executeTuiCommand: (command) => executeTuiCommand(client, command),
+    readRecentMessages: (sessionID, limit = 12) => readRecentSessionMessages(client, sessionID, directory, limit),
+    activeRunCompletion: (sessionID, active) => activeRunCompletionFromMessages(directory, client, sessionID, active),
+    resolveCompactionModel: (sessionID, preferredModel) => resolveCompactionModel(directory, client, sessionID, preferredModel),
+    compactSession: (sessionID, preferredModel) => compactSession(directory, client, sessionID, preferredModel),
+    log: (level, message, extra) => log(client, level, message, extra),
+    toast: (message, variant) => toast(client, message, variant),
+  })
+}

package/src/source/opencode/host.js

@@ -0,0 +1,134 @@
+import { sdkErrorMessage, sdkCall } from "./sdk.js"
+import { normalizedModelRef, captureSessionExecutionContext, getSessionExecutionContext, setSessionExecutionContext } from "./session-context.js"
+
+const SERVICE = "opencode-loop"
+
+export function fireSdk(client, label, method, ...argsList) {
+  const pending = Promise.resolve().then(() => sdkCall(method, ...argsList))
+  void pending.catch((error) => {
+    log(client, "warn", `${label} failed`, { error: sdkErrorMessage(error) }).catch(() => {})
+  })
+  return pending
+}
+
+export async function executeTuiCommand(client, command) {
+  if (!client?.tui?.executeCommand) throw new Error("client.tui.executeCommand is not available")
+  return await sdkCall(
+    client.tui.executeCommand.bind(client.tui),
+    { body: { command } },
+    { command },
+  )
+}
+
+export function compactTuiCommandName(command = "compact") {
+  const normalized = String(command || "compact").replace(/^\/+/, "").trim().toLowerCase()
+  if (normalized === "compact" || normalized === "summarize") return "session_compact"
+  return undefined
+}
+
+export async function readRecentSessionMessages(client, sessionID, directory, limit = 20) {
+  if (!client?.session?.messages) return undefined
+  const query = { limit }
+  if (directory) query.directory = directory
+  try {
+    const messages = await sdkCall(
+      client.session.messages.bind(client.session),
+      { path: { id: sessionID }, query },
+      { path: { sessionID }, query },
+      { sessionID, ...query },
+    )
+    return Array.isArray(messages) ? messages : undefined
+  } catch {
+    return undefined
+  }
+}
+
+export function orderedSessionMessages(messages) {
+  return (messages || [])
+    .map((message, index) => {
+      const info = message?.info || message || {}
+      const created = Number(info?.time?.created || 0)
+      return { message, index, created: Number.isFinite(created) ? created : 0 }
+    })
+    .sort((a, b) => a.created - b.created || a.index - b.index)
+    .map((entry) => entry.message)
+}
+
+export async function activeRunCompletionFromMessages(directory, client, sessionID, active) {
+  const messages = await readRecentSessionMessages(client, sessionID, directory)
+  if (!messages) return "unknown"
+  const tail = orderedSessionMessages(messages).at(-1)
+  const info = tail?.info || tail
+  if (!info || info.role !== "assistant") return "incomplete"
+  const completed = Number(info?.time?.completed || 0)
+  const created = Number(info?.time?.created || 0)
+  if (!Number.isFinite(completed) || completed <= 0) return "incomplete"
+  const startedAt = Number(active?.startedAt || 0)
+  if (startedAt > 0 && completed < startedAt && (!Number.isFinite(created) || created < startedAt)) return "incomplete"
+  return "completed"
+}
+
+export async function resolveCompactionModel(directory, client, sessionID, preferredModel) {
+  const preferred = normalizedModelRef(preferredModel)
+  if (preferred) return preferred
+  const cached = normalizedModelRef(getSessionExecutionContext(sessionID)?.model)
+  if (cached) return cached
+  const captured = await captureSessionExecutionContext(client, sessionID)
+  const capturedModel = normalizedModelRef(captured?.model)
+  if (capturedModel) return capturedModel
+  const messages = await readRecentSessionMessages(client, sessionID, directory)
+  for (const message of orderedSessionMessages(messages).reverse()) {
+    const info = message?.info || message
+    const model = normalizedModelRef(info?.model) || normalizedModelRef(info)
+    if (!model) continue
+    const previous = getSessionExecutionContext(sessionID) || {}
+    setSessionExecutionContext(sessionID, { ...previous, model })
+    return model
+  }
+  return undefined
+}
+
+export async function compactSession(directory, client, sessionID, preferredModel) {
+  // Prefer the native TUI command when a TUI is present. Headless/server hosts
+  // fall back to session.summarize, whose current API requires an explicit
+  // provider/model pair.
+  for (const command of ["session.compact", "session_compact"]) {
+    try {
+      await executeTuiCommand(client, command)
+      return true
+    } catch (error) {
+      await log(client, "warn", `tui ${command} failed`, { error: sdkErrorMessage(error) })
+    }
+  }
+  try {
+    if (!client?.session?.summarize) throw new Error("client.session.summarize is not available")
+    const model = await resolveCompactionModel(directory, client, sessionID, preferredModel)
+    if (!model) throw new Error("could not resolve a provider/model for session.summarize")
+    const body = { providerID: model.providerID, modelID: model.modelID, auto: false }
+    await sdkCall(
+      client.session.summarize.bind(client.session),
+      { path: { id: sessionID }, body },
+      { path: { sessionID }, body },
+      { sessionID, ...body },
+    )
+    return true
+  } catch (error) {
+    await log(client, "warn", "session.summarize fallback failed", { error: sdkErrorMessage(error) })
+  }
+  await toast(client, "Could not run /compact from loop. Check OpenCode version and active session model.", "error")
+  return false
+}
+
+export async function log(client, level, message, extra) {
+  try {
+    await sdkCall(
+      client.app.log.bind(client.app),
+      { body: extra === undefined ? { service: SERVICE, level, message } : { service: SERVICE, level, message, extra } },
+      extra === undefined ? { service: SERVICE, level, message } : { service: SERVICE, level, message, extra },
+    )
+  } catch {}
+}
+
+export async function toast(client, message, variant = "info") {
+  try { await sdkCall(client.tui.showToast.bind(client.tui), { body: { message, variant } }, { message, variant }) } catch {}
+}

package/src/source/opencode/sdk.js

@@ -0,0 +1,38 @@
+// OpenCode SDK compatibility helpers.
+export function sdkError(result) {
+  if (!result || typeof result !== "object") return undefined
+  return result.error || result.error === null ? result.error : undefined
+}
+
+export function sdkData(result) {
+  if (!result || typeof result !== "object") return result
+  return Object.prototype.hasOwnProperty.call(result, "data") ? result.data : result
+}
+
+export function sdkErrorMessage(error) {
+  if (!error) return "unknown SDK error"
+  if (error instanceof Error) return error.message
+  if (typeof error === "string") return error
+  if (typeof error === "object") {
+    if (typeof error.message === "string") return error.message
+    if (typeof error.name === "string") return error.name
+    try { return JSON.stringify(error).slice(0, 400) } catch {}
+  }
+  return String(error)
+}
+
+export async function sdkCall(method, ...argsList) {
+  let firstError
+  for (const args of argsList) {
+    if (args === undefined) continue
+    try {
+      const result = await method(args)
+      const error = sdkError(result)
+      if (!error) return sdkData(result)
+      firstError = firstError || new Error(sdkErrorMessage(error))
+    } catch (error) {
+      firstError = firstError || error
+    }
+  }
+  throw firstError || new Error("SDK call failed without arguments")
+}

package/src/source/opencode/session-context.js

@@ -0,0 +1,50 @@
+import { sdkCall } from "./sdk.js"
+
+const LOCAL_COMMAND_AGENT = "opencode-loop-local"
+const sessionExecutionContexts = new Map()
+
+export function normalizedModelRef(model) {
+  if (typeof model === "string") {
+    const separator = model.indexOf("/")
+    if (separator > 0) return { providerID: model.slice(0, separator), modelID: model.slice(separator + 1) }
+    return undefined
+  }
+  const providerID = model?.providerID
+  const modelID = model?.modelID || model?.id
+  if (typeof providerID !== "string" || typeof modelID !== "string") return undefined
+  return { providerID, modelID }
+}
+
+export function updateSessionExecutionContext(info) {
+  const sessionID = info?.sessionID || info?.id
+  if (typeof sessionID !== "string") return
+  const previous = sessionExecutionContexts.get(sessionID) || {}
+  const candidateAgent = info?.agent || (info?.role === "assistant" ? info?.mode : undefined)
+  const agent = typeof candidateAgent === "string" && candidateAgent !== LOCAL_COMMAND_AGENT
+    ? candidateAgent
+    : previous.agent
+  const model = normalizedModelRef(info?.model) || normalizedModelRef(info) || previous.model
+  sessionExecutionContexts.set(sessionID, { agent, model })
+}
+
+export async function captureSessionExecutionContext(client, sessionID) {
+  if (client?.session?.get) {
+    try {
+      const info = await sdkCall(
+        client.session.get.bind(client.session),
+        { path: { id: sessionID } },
+        { path: { sessionID } },
+        { sessionID },
+      )
+      updateSessionExecutionContext(info)
+    } catch {}
+  }
+  const context = sessionExecutionContexts.get(sessionID) || {}
+  const normalized = { agent: context.agent || "build", model: context.model }
+  sessionExecutionContexts.set(sessionID, normalized)
+  return normalized
+}
+
+export function getSessionExecutionContext(sessionID) { return sessionExecutionContexts.get(sessionID) }
+export function setSessionExecutionContext(sessionID, context) { sessionExecutionContexts.set(sessionID, context); return context }
+export function deleteSessionExecutionContext(sessionID) { sessionExecutionContexts.delete(sessionID) }

package/src/source/opencode2/capabilities.js

@@ -0,0 +1,69 @@
+function hasFunction(value, key) {
+  return Boolean(value && typeof value[key] === "function")
+}
+
+function frozenRecord(value) {
+  return Object.freeze(value)
+}
+
+export const OPENCODE_LOOP_V2_HOST_REQUIREMENTS = Object.freeze([
+  "event.subscribe",
+  "session.prompt",
+])
+
+export const OPENCODE_LOOP_V2_RUNTIME_IMPLEMENTED = false
+
+export const OPENCODE_LOOP_V2_RUNTIME_REQUIREMENTS = Object.freeze([
+  ...OPENCODE_LOOP_V2_HOST_REQUIREMENTS,
+  "runtime.adapter",
+])
+
+export const OPENCODE_LOOP_V2_COMMAND_SOURCE = "file-definitions"
+
+export function inspectOpenCode2Context(ctx) {
+  const command = ctx?.command
+  const session = ctx?.session
+  const event = ctx?.event
+  const tool = ctx?.tool
+
+  return frozenRecord({
+    commandTransform: hasFunction(command, "transform"),
+    eventSubscribe: hasFunction(event, "subscribe"),
+    sessionHook: hasFunction(session, "hook"),
+    sessionPrompt: hasFunction(session, "prompt"),
+    toolTransform: hasFunction(tool, "transform"),
+    toolHook: hasFunction(tool, "hook"),
+  })
+}
+
+export function inspectOpenCode2CommandDraft(draft) {
+  return frozenRecord({
+    list: hasFunction(draft, "list"),
+    get: hasFunction(draft, "get"),
+    update: hasFunction(draft, "update"),
+    remove: hasFunction(draft, "remove"),
+  })
+}
+
+export function openCode2LoopRuntimeStatus(ctx, commandDraft) {
+  const context = inspectOpenCode2Context(ctx)
+  const command = inspectOpenCode2CommandDraft(commandDraft)
+  const hostBlockers = []
+
+  if (!context.eventSubscribe) hostBlockers.push("event.subscribe")
+  if (!context.sessionPrompt) hostBlockers.push("session.prompt")
+
+  const blockers = [...hostBlockers]
+  if (!OPENCODE_LOOP_V2_RUNTIME_IMPLEMENTED) blockers.push("runtime.adapter")
+
+  return frozenRecord({
+    ready: blockers.length === 0,
+    hostReady: hostBlockers.length === 0,
+    implementationReady: OPENCODE_LOOP_V2_RUNTIME_IMPLEMENTED,
+    blockers: Object.freeze(blockers),
+    hostBlockers: Object.freeze(hostBlockers),
+    commandSource: OPENCODE_LOOP_V2_COMMAND_SOURCE,
+    context,
+    command,
+  })
+}

package/src/source/opencode2/event-bridge.js

@@ -0,0 +1,156 @@
+import { normalizeOpenCodeEvent } from "../runtime/events.js"
+import { createSessionRuntimeManager } from "../runtime/session-manager.js"
+
+function cleanupRegistration(registration) {
+  if (typeof registration === "function") return registration
+  if (!registration || typeof registration !== "object") return undefined
+  for (const key of ["dispose", "unsubscribe", "close"]) {
+    if (typeof registration[key] === "function") return registration[key].bind(registration)
+  }
+  return undefined
+}
+
+function eventStream(registration) {
+  const stream = registration?.stream ?? registration
+  if (!stream || typeof stream[Symbol.asyncIterator] !== "function") {
+    throw new TypeError("OpenCode 2 event subscribe must return an async event stream")
+  }
+  return stream
+}
+
+function sameDirectory(expected, actual) {
+  if (!expected || !actual) return true
+  return String(expected) === String(actual)
+}
+
+export function createOpenCode2EventBridge({
+  directory,
+  onEvent = async () => {},
+  onError = () => {},
+  runtimeManager = createSessionRuntimeManager(),
+} = {}) {
+  if (typeof onEvent !== "function") throw new TypeError("OpenCode 2 event bridge requires onEvent to be a function")
+  if (typeof onError !== "function") throw new TypeError("OpenCode 2 event bridge requires onError to be a function")
+
+  let registration
+  let iterator
+  let iteratorClosed = false
+  let pump
+  let attached = false
+  let stopped = false
+  let disposed = false
+  let managerDisposed = false
+  let queue = Promise.resolve()
+
+  function report(error) {
+    try { onError(error) } catch {}
+  }
+
+  function disposeManager(reason) {
+    if (managerDisposed) return false
+    managerDisposed = true
+    return runtimeManager.dispose(reason)
+  }
+
+  async function closeIterator() {
+    if (iteratorClosed) return false
+    iteratorClosed = true
+    const current = iterator
+    iterator = undefined
+    if (typeof current?.return === "function") await current.return()
+    return Boolean(current)
+  }
+
+  async function process(raw) {
+    if (stopped) return undefined
+    const event = normalizeOpenCodeEvent(raw)
+    if (!event || !sameDirectory(directory, event.directory)) return undefined
+
+    const runtime = event.sessionID ? runtimeManager.observeExternal(event.sessionID) : undefined
+    await onEvent(event, runtime)
+
+    if (event.kind === "session" && event.action === "deleted") {
+      runtimeManager.remove(event.sessionID, { expectedRuntime: runtime, reason: "session-deleted" })
+    }
+
+    if (event.kind === "server" && event.action === "disposed") {
+      stopped = true
+      disposeManager("server-disposed")
+    }
+
+    return event
+  }
+
+  function dispatch(raw) {
+    if (stopped) return Promise.resolve(undefined)
+    const result = queue.then(() => process(raw))
+    queue = result.catch(() => undefined)
+    return result
+  }
+
+  function callback(raw) {
+    const pending = dispatch(raw)
+    pending.catch(report)
+    return pending.catch(() => undefined)
+  }
+
+  async function consume(stream) {
+    const current = stream[Symbol.asyncIterator]()
+    iterator = current
+    iteratorClosed = false
+    try {
+      while (!stopped) {
+        const next = await current.next()
+        if (next?.done) break
+        await dispatch(next?.value)
+      }
+    } catch (error) {
+      if (!stopped) report(error)
+    } finally {
+      if (stopped && !iteratorClosed) await closeIterator().catch(() => undefined)
+      if (iterator === current) iterator = undefined
+    }
+  }
+
+  async function attach(subscribe) {
+    if (disposed) throw new Error("OpenCode 2 event bridge is disposed")
+    if (attached) throw new Error("OpenCode 2 event bridge is already attached")
+    if (typeof subscribe !== "function") throw new TypeError("OpenCode 2 event bridge requires an event subscribe function")
+
+    if (subscribe.length > 0) {
+      registration = await subscribe(callback)
+      attached = true
+      return registration
+    }
+
+    registration = await subscribe()
+    const stream = eventStream(registration)
+    attached = true
+    pump = consume(stream)
+    return registration
+  }
+
+  async function dispose(reason = "bridge-disposed") {
+    if (disposed) return false
+    disposed = true
+    stopped = true
+    await closeIterator().catch(() => undefined)
+    await pump?.catch(() => undefined)
+    await queue.catch(() => undefined)
+
+    const cleanup = cleanupRegistration(registration)
+    registration = undefined
+    if (cleanup) await cleanup()
+    disposeManager(reason)
+    return true
+  }
+
+  return Object.freeze({
+    attach,
+    dispatch,
+    dispose,
+    runtimeManager,
+    isAttached: () => attached,
+    isDisposed: () => disposed,
+  })
+}

package/src/source/opencode2/experimental.js

@@ -0,0 +1,16 @@
+import { inspectOpenCode2Context } from "./capabilities.js"
+
+export const OPENCODE_LOOP_V2_PLUGIN_ID = "bybrawe.opencode-loop.v2.experimental"
+
+export const OpenCodeLoopV2ExperimentalPlugin = {
+  id: OPENCODE_LOOP_V2_PLUGIN_ID,
+  async setup(ctx) {
+    const capabilities = inspectOpenCode2Context(ctx)
+    if (!capabilities.commandTransform) {
+      throw new Error("OpenCode 2 command.transform capability is unavailable")
+    }
+    await ctx.command.transform(() => {})
+  },
+}
+
+export default OpenCodeLoopV2ExperimentalPlugin

package/src/source/opencode2/host-contract.js

@@ -0,0 +1,68 @@
+import { createOpenCode2EventBridge } from "./event-bridge.js"
+
+export const OPENCODE_LOOP_V2_HOST_CONTRACT = "experimental"
+
+function normalizePrompt(input) {
+  const sessionID = String(input?.sessionID || "").trim()
+  const text = String(input?.text || "")
+  if (!sessionID) throw new TypeError("prompt requires a session ID")
+  if (!text.trim()) throw new TypeError("prompt requires text")
+  return Object.freeze({
+    sessionID,
+    text,
+    agent: input?.agent,
+    model: input?.model,
+    noReply: input?.noReply === true,
+  })
+}
+
+export function createOpenCode2HostContract(options = {}) {
+  const onEvent = typeof options.onEvent === "function" ? options.onEvent : async () => {}
+  let started = false
+  let disposed = false
+  let hostDisposed = false
+
+  const bridge = createOpenCode2EventBridge({
+    directory: options.directory,
+    onError: options.onError,
+    onEvent: async (event, runtime) => {
+      if (event.kind === "server" && event.action === "disposed") hostDisposed = true
+      await onEvent(event, runtime)
+    },
+  })
+
+  async function start() {
+    if (disposed) throw new Error("OpenCode 2 host contract is disposed")
+    if (started) return false
+    if (typeof options.subscribe !== "function") throw new TypeError("subscribe must be a function")
+    if (typeof options.sendPrompt !== "function") throw new TypeError("sendPrompt must be a function")
+    await bridge.attach(options.subscribe)
+    started = true
+    return true
+  }
+
+  async function prompt(input) {
+    if (disposed || hostDisposed) throw new Error("OpenCode 2 host contract is unavailable")
+    if (!started) throw new Error("OpenCode 2 host contract is not started")
+    const request = normalizePrompt(input)
+    const runtime = bridge.runtimeManager.observeExternal(request.sessionID)
+    return await options.sendPrompt(Object.freeze({ ...request, runtime }))
+  }
+
+  async function dispose(reason = "host-contract-disposed") {
+    if (disposed) return false
+    disposed = true
+    await bridge.dispose(reason)
+    return true
+  }
+
+  return Object.freeze({
+    start,
+    prompt,
+    dispose,
+    runtimeManager: bridge.runtimeManager,
+    isStarted: () => started,
+    isDisposed: () => disposed,
+    isHostDisposed: () => hostDisposed,
+  })
+}

package/src/source/runtime/events.js

@@ -0,0 +1,113 @@
+function record(value) {
+  return value && typeof value === "object" ? value : undefined
+}
+
+function text(value) {
+  return typeof value === "string" && value.trim() ? value : undefined
+}
+
+function envelope(input) {
+  const outer = record(input)
+  if (!outer) return undefined
+  const payload = record(outer.payload)
+  if (payload && text(payload.type)) {
+    return { directory: text(outer.directory), event: payload }
+  }
+  const wrappedEvent = record(outer.event)
+  if (wrappedEvent && text(wrappedEvent.type)) {
+    return { directory: text(outer.directory), event: wrappedEvent }
+  }
+  if (!text(outer.type)) return undefined
+  return { directory: undefined, event: outer }
+}
+
+function freezeEvent(value) {
+  return Object.freeze(value)
+}
+
+export function normalizeOpenCodeEvent(input) {
+  const parsed = envelope(input)
+  if (!parsed) return undefined
+
+  const { directory, event } = parsed
+  const properties = record(event.properties) || {}
+
+  if (event.type === "session.status") {
+    const sessionID = text(properties.sessionID)
+    const status = text(record(properties.status)?.type)
+    if (!sessionID || !status) return undefined
+    return freezeEvent({ kind: "session", action: "status", sessionID, directory, status })
+  }
+
+  if (event.type === "session.idle" || event.type === "session.compacted") {
+    const sessionID = text(properties.sessionID)
+    if (!sessionID) return undefined
+    return freezeEvent({
+      kind: "session",
+      action: event.type === "session.idle" ? "idle" : "compacted",
+      sessionID,
+      directory,
+    })
+  }
+
+  if (event.type === "session.created" || event.type === "session.updated" || event.type === "session.deleted") {
+    const info = record(properties.info)
+    const sessionID = text(info?.id)
+    if (!sessionID) return undefined
+    return freezeEvent({
+      kind: "session",
+      action: event.type.slice("session.".length),
+      sessionID,
+      directory: directory || text(info?.directory),
+      parentID: text(info?.parentID),
+    })
+  }
+
+  if (event.type === "session.error") {
+    const sessionID = text(properties.sessionID)
+    if (!sessionID) return undefined
+    return freezeEvent({ kind: "session", action: "error", sessionID, directory })
+  }
+
+  if (event.type === "message.updated") {
+    const info = record(properties.info)
+    const sessionID = text(info?.sessionID)
+    const messageID = text(info?.id)
+    const role = text(info?.role)
+    if (!sessionID || !messageID || !role) return undefined
+    const time = record(info?.time)
+    return freezeEvent({
+      kind: "message",
+      action: "updated",
+      sessionID,
+      directory,
+      messageID,
+      role,
+      completedAt: Number.isFinite(time?.completed) ? time.completed : undefined,
+      finish: text(info?.finish),
+    })
+  }
+
+  if (event.type === "command.executed") {
+    const sessionID = text(properties.sessionID)
+    const name = text(properties.name)
+    if (!sessionID || !name) return undefined
+    return freezeEvent({
+      kind: "command",
+      action: "executed",
+      sessionID,
+      directory,
+      name,
+      arguments: typeof properties.arguments === "string" ? properties.arguments : "",
+      messageID: text(properties.messageID),
+    })
+  }
+
+  if (event.type === "server.instance.disposed") {
+    const disposedDirectory = directory || text(properties.directory)
+    if (!disposedDirectory) return undefined
+    return freezeEvent({ kind: "server", action: "disposed", directory: disposedDirectory })
+  }
+
+  return undefined
+}

package/src/source/runtime/observer.js

@@ -0,0 +1,23 @@
+import { normalizeOpenCodeEvent } from "./events.js"
+
+export function observeRuntimeEvent(manager, input) {
+  const event = normalizeOpenCodeEvent(input)
+  if (!event || !manager) return event
+
+  try {
+    if (event.kind === "server" && event.action === "disposed") {
+      manager.dispose?.("server-disposed")
+      return event
+    }
+
+    if (!event.sessionID) return event
+    if (event.kind === "session" && event.action === "deleted") {
+      manager.remove?.(event.sessionID, { reason: "session-deleted" })
+      return event
+    }
+
+    manager.observeExternal?.(event.sessionID)
+  } catch {}
+
+  return event
+}