@bybrawe/opencode-loop 0.5.27 → 0.5.29

package/src/source/opencode2/commands.js

@@ -0,0 +1,60 @@
+export const OPENCODE_LOOP_V2_COMMANDS = Object.freeze({
+  loop: Object.freeze({
+    description: "Start an OpenCode auto-continue loop. Usage: /loop 5m <task>",
+    template: "OpenCode Loop local command handled. Reply exactly: OK.",
+  }),
+  "loop-pause": Object.freeze({
+    description: "Pause OpenCode Loop jobs.",
+    template: "OpenCode Loop pause command handled locally. Reply exactly: OK.",
+  }),
+  "loop-resume": Object.freeze({
+    description: "Resume OpenCode Loop jobs.",
+    template: "OpenCode Loop resume command handled locally. Reply exactly: OK.",
+  }),
+  "loop-stop": Object.freeze({
+    description: "Stop OpenCode Loop jobs.",
+    template: "OpenCode Loop stop command handled locally. Reply exactly: OK.",
+  }),
+  "loop-remove": Object.freeze({
+    description: "Remove OpenCode Loop jobs.",
+    template: "OpenCode Loop remove command handled locally. Reply exactly: OK.",
+  }),
+  "loop-clear": Object.freeze({
+    description: "Clear all OpenCode Loop jobs.",
+    template: "OpenCode Loop clear command handled locally. Reply exactly: OK.",
+  }),
+  "loop-status": Object.freeze({
+    description: "Show OpenCode Loop status for the current session.",
+    template: "OpenCode Loop status command handled locally. Reply exactly: OK.",
+  }),
+  "loop-now": Object.freeze({
+    description: "Run matching OpenCode Loop jobs on the next idle boundary.",
+    template: "OpenCode Loop run-now command handled locally. Reply exactly: OK.",
+  }),
+})
+
+export function registerOpenCode2LoopCommands(draft) {
+  if (!draft || typeof draft.update !== "function") {
+    throw new Error("OpenCode 2 command draft.update capability is unavailable")
+  }
+  for (const [name, definition] of Object.entries(OPENCODE_LOOP_V2_COMMANDS)) {
+    draft.update(name, (command) => {
+      command.template = definition.template
+      command.description = definition.description
+    })
+  }
+}
+
+export function parseOpenCode2LoopCommandText(value) {
+  if (typeof value !== "string") return undefined
+  for (const [name, definition] of Object.entries(OPENCODE_LOOP_V2_COMMANDS)) {
+    const template = definition.template
+    if (value === template) return Object.freeze({ name, arguments: "" })
+    if (!value.startsWith(`${template}\n\n`)) continue
+    return Object.freeze({
+      name,
+      arguments: value.slice(template.length + 2).trim(),
+    })
+  }
+  return undefined
+}

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

@@ -0,0 +1,174 @@
+import { normalizeOpenCodeEvent } from "../runtime/events.js"
+import { createSessionRuntimeManager } from "../runtime/session-manager.js"
+import { normalizeOpenCode2NativeEvent } from "./events.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()
+  const sessionDirectories = new Map()
+
+  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)
+  }
+
+  function normalize(raw) {
+    const current = normalizeOpenCode2NativeEvent(raw) || normalizeOpenCodeEvent(raw)
+    if (!current) return undefined
+    const sessionID = current.sessionID
+    const rememberedDirectory = sessionID ? sessionDirectories.get(sessionID) : undefined
+    const eventDirectory = current.directory || rememberedDirectory || directory
+    const event = eventDirectory === current.directory
+      ? current
+      : Object.freeze({ ...current, directory: eventDirectory })
+    if (sessionID && event.directory) sessionDirectories.set(sessionID, event.directory)
+    return event
+  }
+
+  async function process(raw) {
+    if (stopped) return undefined
+    const event = normalize(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") {
+      sessionDirectories.delete(event.sessionID)
+      runtimeManager.remove(event.sessionID, { expectedRuntime: runtime, reason: "session-deleted" })
+    }
+
+    if (event.kind === "server" && event.action === "disposed") {
+      stopped = true
+      sessionDirectories.clear()
+      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()
+    sessionDirectories.clear()
+    disposeManager(reason)
+    return true
+  }
+
+  return Object.freeze({
+    attach,
+    dispatch,
+    dispose,
+    runtimeManager,
+    isAttached: () => attached,
+    isDisposed: () => disposed,
+  })
+}

package/src/source/opencode2/events.js

@@ -0,0 +1,64 @@
+import { parseOpenCode2LoopCommandText } from "./commands.js"
+
+function record(value) {
+  return value && typeof value === "object" ? value : undefined
+}
+
+function text(value) {
+  return typeof value === "string" && value.trim() ? value : undefined
+}
+
+function directoryFrom(raw) {
+  return text(record(raw?.location)?.directory)
+}
+
+function sessionIDFrom(raw) {
+  const data = record(raw?.data)
+  return text(data?.sessionID)
+}
+
+export function normalizeOpenCode2NativeEvent(raw) {
+  const type = text(raw?.type)
+  if (!type) return undefined
+
+  const data = record(raw?.data) || {}
+  const directory = directoryFrom(raw)
+  const sessionID = sessionIDFrom(raw)
+
+  if (type === "session.inbox.enqueued") {
+    const item = record(data.item)
+    const payload = record(item?.payload)
+    const parsed = item?.type === "user" ? parseOpenCode2LoopCommandText(payload?.text) : undefined
+    if (!sessionID || !parsed) return undefined
+    return Object.freeze({
+      kind: "command",
+      action: "executed",
+      sessionID,
+      directory,
+      name: parsed.name,
+      arguments: parsed.arguments,
+    })
+  }
+
+  if (type === "session.execution.started") {
+    if (!sessionID) return undefined
+    return Object.freeze({ kind: "session", action: "status", sessionID, directory, status: "busy" })
+  }
+
+  if (type === "session.execution.succeeded") {
+    if (!sessionID) return undefined
+    return Object.freeze({ kind: "session", action: "idle", sessionID, directory })
+  }
+
+  if (type === "session.created") {
+    if (!sessionID) return undefined
+    return Object.freeze({ kind: "session", action: "created", sessionID, directory: directory || text(record(data.location)?.directory) })
+  }
+
+  if (type === "session.deleted") {
+    if (!sessionID) return undefined
+    return Object.freeze({ kind: "session", action: "deleted", sessionID, directory })
+  }
+
+  return undefined
+}

package/src/source/opencode2/experimental.js

@@ -0,0 +1,47 @@
+import { inspectOpenCode2Context } from "./capabilities.js"
+import { OPENCODE_LOOP_V2_COMMANDS, registerOpenCode2LoopCommands } from "./commands.js"
+import { createOpenCode2PromptRuntime } from "./prompt-runtime.js"
+import { createOpenCode2RuntimeAdapter } from "./runtime-adapter.js"
+
+export const OPENCODE_LOOP_V2_PLUGIN_ID = "bybrawe.opencode-loop.v2.experimental"
+export { OPENCODE_LOOP_V2_COMMANDS }
+
+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")
+    }
+
+    const commandRegistration = await ctx.command.transform(registerOpenCode2LoopCommands)
+    if (!capabilities.eventSubscribe || !capabilities.sessionPrompt) {
+      await commandRegistration?.dispose?.()
+      return undefined
+    }
+
+    let promptRuntime
+    const onRuntimeEvent = async (event) => promptRuntime?.onEvent(event)
+    const runtime = createOpenCode2RuntimeAdapter(ctx, { onEvent: onRuntimeEvent })
+    promptRuntime = createOpenCode2PromptRuntime({
+      prompt: (request) => runtime.prompt(request),
+      command: capabilities.sessionCommand ? (request) => runtime.command(request) : undefined,
+    })
+
+    try {
+      await runtime.start()
+    } catch (error) {
+      await promptRuntime?.dispose?.().catch(() => undefined)
+      await commandRegistration?.dispose?.().catch(() => undefined)
+      throw error
+    }
+
+    return async () => {
+      await promptRuntime?.dispose?.()
+      await runtime.dispose("plugin-cleanup")
+      await commandRegistration?.dispose?.()
+    }
+  },
+}
+
+export default OpenCodeLoopV2ExperimentalPlugin

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

@@ -0,0 +1,94 @@
+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,
+  })
+}
+
+function normalizeCommand(input) {
+  const sessionID = String(input?.sessionID || "").trim()
+  const command = String(input?.command || "").trim().replace(/^\/+/, "")
+  if (!sessionID) throw new TypeError("command requires a session ID")
+  if (!command) throw new TypeError("command requires a command name")
+  return Object.freeze({
+    sessionID,
+    command,
+    arguments: input?.arguments === undefined ? undefined : String(input.arguments),
+    agent: input?.agent,
+    model: input?.model,
+    delivery: input?.delivery,
+    resume: input?.resume,
+  })
+}
+
+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 command(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")
+    if (typeof options.sendCommand !== "function") throw new Error("OpenCode 2 session.command capability is unavailable")
+    const request = normalizeCommand(input)
+    const runtime = bridge.runtimeManager.observeExternal(request.sessionID)
+    return await options.sendCommand(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,
+    command,
+    dispose,
+    runtimeManager: bridge.runtimeManager,
+    isStarted: () => started,
+    isDisposed: () => disposed,
+    isHostDisposed: () => hostDisposed,
+  })
+}