@bybrawe/opencode-loop 0.5.27 → 0.5.29

package/scripts/v2-command-adapter-test.mjs

@@ -0,0 +1,113 @@
+import assert from "node:assert/strict"
+import { mkdtemp, rm } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import OpenCodeLoopV2ExperimentalPlugin from "../src/source/opencode2/experimental.js"
+import { createOpenCode2RuntimeAdapter } from "../src/source/opencode2/runtime-adapter.js"
+
+function controllableStream() {
+  const queued = []
+  const waiting = []
+  let closed = false
+  const iterator = {
+    next() {
+      if (queued.length) return Promise.resolve({ done: false, value: queued.shift() })
+      if (closed) return Promise.resolve({ done: true, value: undefined })
+      return new Promise((resolve) => waiting.push(resolve))
+    },
+    async return() {
+      closed = true
+      while (waiting.length) waiting.shift()({ done: true, value: undefined })
+      return { done: true, value: undefined }
+    },
+  }
+  return {
+    stream: { [Symbol.asyncIterator]: () => iterator },
+    push(value) {
+      if (waiting.length) waiting.shift()({ done: false, value })
+      else queued.push(value)
+    },
+  }
+}
+
+async function waitFor(predicate, description, timeoutMs = 2_000) {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    if (await predicate()) return
+    await new Promise((resolve) => setTimeout(resolve, 10))
+  }
+  throw new Error(`timed out waiting for ${description}`)
+}
+
+{
+  const events = controllableStream()
+  const commands = []
+  const ctx = {
+    event: { subscribe: () => events.stream },
+    session: {
+      prompt: async () => ({ accepted: true }),
+      command: async (request) => {
+        commands.push(structuredClone(request))
+        return { accepted: true }
+      },
+    },
+  }
+  const adapter = createOpenCode2RuntimeAdapter(ctx)
+  await adapter.start()
+  const result = await adapter.command({ sessionID: "ses_adapter", command: "/review", arguments: "--quick" })
+  assert.deepEqual(result, { accepted: true })
+  assert.deepEqual(commands, [{ sessionID: "ses_adapter", command: "review", arguments: "--quick" }])
+  assert.equal(Object.prototype.hasOwnProperty.call(commands[0], "id"), false)
+  await adapter.dispose()
+}
+
+{
+  const events = controllableStream()
+  const adapter = createOpenCode2RuntimeAdapter({
+    event: { subscribe: () => events.stream },
+    session: { prompt: async () => ({ accepted: true }) },
+  })
+  await adapter.start()
+  await assert.rejects(adapter.command({ sessionID: "ses_adapter", command: "review" }), /session\.command capability is unavailable/)
+  await adapter.dispose()
+}
+
+{
+  const directory = await mkdtemp(path.join(os.tmpdir(), "opencode-loop-v2-command-wiring-"))
+  const sessionID = "ses_v2_command_wiring"
+  const events = controllableStream()
+  const commands = []
+  const ctx = {
+    command: { transform: async () => ({ dispose: async () => {} }) },
+    event: { subscribe: () => events.stream },
+    session: {
+      prompt: async () => ({ accepted: true }),
+      command: async (request) => {
+        commands.push(structuredClone(request))
+        return { accepted: true }
+      },
+    },
+  }
+  const cleanup = await OpenCodeLoopV2ExperimentalPlugin.setup(ctx)
+  try {
+    events.push({
+      directory,
+      payload: {
+        type: "command.executed",
+        properties: {
+          sessionID,
+          name: "loop",
+          arguments: '0s --max-runs 1 --command "/review --quick"',
+        },
+      },
+    })
+    events.push({ directory, payload: { type: "session.idle", properties: { sessionID } } })
+    await waitFor(() => commands.length === 1, "V2 command dispatch")
+    assert.deepEqual(commands[0], { sessionID, command: "review", arguments: "--quick" })
+  } finally {
+    await cleanup?.()
+    await rm(directory, { recursive: true, force: true })
+  }
+}
+
+console.log("OpenCode 2 command adapter tests passed")

package/scripts/v2-command-runtime-test.mjs

@@ -0,0 +1,98 @@
+import assert from "node:assert/strict"
+import { mkdtemp, readFile, rm } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { createOpenCode2PromptRuntime } from "../src/source/opencode2/prompt-runtime.js"
+
+const directory = await mkdtemp(path.join(os.tmpdir(), "opencode-loop-v2-command-"))
+const sessionID = "ses_v2_command_runtime"
+const prompts = []
+const commands = []
+const runtime = createOpenCode2PromptRuntime({
+  prompt: async (request) => { prompts.push(request) },
+  command: async (request) => { commands.push(request); return { accepted: true } },
+})
+
+async function readState() {
+  const file = path.join(directory, ".opencode", "opencode-loop", `${sessionID}.json`)
+  return JSON.parse(await readFile(file, "utf8"))
+}
+
+try {
+  const added = await runtime.onEvent({
+    kind: "command",
+    action: "executed",
+    name: "loop",
+    sessionID,
+    directory,
+    arguments: '0s --max-runs 2 --command "/review --quick"',
+  })
+  assert.equal(added.accepted, true)
+  assert.equal(added.job.kind, "command")
+  assert.equal(added.job.action, "/review --quick")
+
+  const first = await runtime.onEvent({ kind: "session", action: "idle", sessionID, directory })
+  assert.equal(first.dispatched, true)
+  assert.equal(first.kind, "command")
+  assert.deepEqual(first.request, { sessionID, command: "review", arguments: "--quick" })
+  assert.deepEqual(commands, [{ sessionID, command: "review", arguments: "--quick" }])
+  assert.equal(Object.prototype.hasOwnProperty.call(commands[0], "id"), false, "OpenCode 2 id is a msg_ message ID, never the command name")
+  assert.equal(prompts.length, 0)
+  let state = await readState()
+  assert.equal(state.jobs[0].runCount, 1)
+  assert.equal(state.jobs[0].enabled, true)
+
+  const second = await runtime.onEvent({ kind: "session", action: "idle", sessionID, directory })
+  assert.equal(second.dispatched, true)
+  assert.deepEqual(commands[1], { sessionID, command: "review", arguments: "--quick" })
+  state = await readState()
+  assert.equal(state.jobs[0].runCount, 2)
+  assert.equal(state.jobs[0].enabled, false)
+
+  const third = await runtime.onEvent({ kind: "session", action: "idle", sessionID, directory })
+  assert.equal(third.dispatched, false)
+  assert.equal(commands.length, 2)
+
+  const compact = await runtime.onEvent({
+    kind: "command",
+    action: "executed",
+    name: "loop",
+    sessionID,
+    directory,
+    arguments: '0s --command "/compact"',
+  })
+  assert.equal(compact.accepted, false)
+  assert.ok(compact.blockers.includes("kind"), "shared actionKind keeps /compact on the dedicated compact path")
+
+  const shell = await runtime.onEvent({
+    kind: "command",
+    action: "executed",
+    name: "loop",
+    sessionID,
+    directory,
+    arguments: '0s --shell "echo hello"',
+  })
+  assert.equal(shell.accepted, false)
+  assert.ok(shell.blockers.includes("kind"), "shell actions remain unsupported because OpenCode 2 plugin ctx has no session.shell")
+
+  const noCommandRuntime = createOpenCode2PromptRuntime({ prompt: async () => {} })
+  try {
+    const unavailable = await noCommandRuntime.onEvent({
+      kind: "command",
+      action: "executed",
+      name: "loop",
+      sessionID: "ses_no_command",
+      directory,
+      arguments: '0s --command "/review"',
+    })
+    assert.equal(unavailable.accepted, false)
+    assert.ok(unavailable.blockers.includes("command-capability"))
+  } finally {
+    await noCommandRuntime.dispose()
+  }
+
+  console.log("OpenCode 2 command runtime tests passed")
+} finally {
+  await runtime.dispose()
+  await rm(directory, { recursive: true, force: true })
+}

package/scripts/v2-event-bridge-test.mjs

@@ -0,0 +1,72 @@
+import assert from "node:assert/strict"
+import { createOpenCode2EventBridge } from "../src/source/opencode2/event-bridge.js"
+
+const seen = []
+let listener
+let unsubscribeCalls = 0
+
+const bridge = createOpenCode2EventBridge({
+  directory: "/project",
+  onEvent: async (event, runtime) => seen.push({ event, runtime }),
+})
+
+await bridge.attach(async (callback) => {
+  listener = callback
+  return { unsubscribe: async () => { unsubscribeCalls += 1 } }
+})
+
+await listener({
+  directory: "/project",
+  payload: { type: "session.created", properties: { info: { id: "ses_a", directory: "/project" } } },
+})
+const first = bridge.runtimeManager.peek("ses_a")
+assert.ok(first)
+assert.equal(first.scope.isActive(), true)
+
+await listener({
+  directory: "/project",
+  payload: { type: "session.status", properties: { sessionID: "ses_a", status: { type: "busy" } } },
+})
+assert.equal(bridge.runtimeManager.peek("ses_a"), first)
+
+await listener({
+  directory: "/project",
+  payload: { type: "session.created", properties: { info: { id: "ses_b", directory: "/project" } } },
+})
+const second = bridge.runtimeManager.peek("ses_b")
+assert.ok(second)
+assert.notEqual(second, first)
+
+await listener({
+  directory: "/other-project",
+  payload: { type: "session.status", properties: { sessionID: "ses_other", status: { type: "busy" } } },
+})
+assert.equal(bridge.runtimeManager.peek("ses_other"), undefined)
+
+await listener({
+  directory: "/project",
+  payload: { type: "session.deleted", properties: { info: { id: "ses_a", directory: "/project" } } },
+})
+assert.equal(bridge.runtimeManager.peek("ses_a"), undefined)
+assert.equal(first.scope.isActive(), false)
+assert.equal(second.scope.isActive(), true)
+
+await listener({
+  directory: "/project",
+  payload: { type: "server.instance.disposed", properties: { directory: "/project" } },
+})
+assert.equal(second.scope.isActive(), false)
+assert.deepEqual(bridge.runtimeManager.entries(), [])
+
+const seenCount = seen.length
+await listener({
+  directory: "/project",
+  payload: { type: "session.status", properties: { sessionID: "ses_late", status: { type: "busy" } } },
+})
+assert.equal(seen.length, seenCount)
+
+assert.equal(await bridge.dispose(), true)
+assert.equal(await bridge.dispose(), false)
+assert.equal(unsubscribeCalls, 1)
+
+console.log("OpenCode 2 event bridge lifecycle passed")

package/scripts/v2-event-stream-contract-test.mjs

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict"
+import { createOpenCode2EventBridge } from "../src/source/opencode2/event-bridge.js"
+
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+const seen = []
+let subscribeArgs = -1
+let cleanupCalls = 0
+
+async function* stream() {
+  yield {
+    directory: "/project",
+    payload: {
+      type: "session.created",
+      properties: { info: { id: "ses_stream", directory: "/project" } },
+    },
+  }
+}
+
+const bridge = createOpenCode2EventBridge({
+  directory: "/project",
+  onEvent: async (event) => seen.push(event),
+})
+
+await bridge.attach(async (...args) => {
+  subscribeArgs = args.length
+  return { stream: stream(), dispose: async () => { cleanupCalls += 1 } }
+})
+
+for (let attempt = 0; attempt < 50 && seen.length === 0; attempt++) await delay(5)
+assert.equal(subscribeArgs, 0)
+assert.equal(seen[0]?.action, "created")
+assert.ok(bridge.runtimeManager.peek("ses_stream"))
+
+assert.equal(await bridge.dispose(), true)
+assert.equal(cleanupCalls, 1)
+assert.equal(bridge.runtimeManager.peek("ses_stream"), undefined)
+
+console.log("OpenCode 2 event stream contract passed")

package/scripts/v2-host-contract-test.mjs

@@ -0,0 +1,82 @@
+import assert from "node:assert/strict"
+import { createOpenCode2HostContract } from "../src/source/opencode2/host-contract.js"
+
+let listener
+let unsubscribeCalls = 0
+const prompts = []
+const commands = []
+const events = []
+const host = createOpenCode2HostContract({
+  directory: "/project",
+  subscribe: async (callback) => {
+    listener = callback
+    return { unsubscribe: async () => { unsubscribeCalls += 1 } }
+  },
+  sendPrompt: async (request) => {
+    prompts.push(request)
+    return { accepted: true }
+  },
+  sendCommand: async (request) => {
+    commands.push(request)
+    return { accepted: true, kind: "command" }
+  },
+  onEvent: async (event, runtime) => events.push({ event, runtime }),
+})
+
+await assert.rejects(host.prompt({ sessionID: "ses_a", text: "early" }), /not started/)
+await assert.rejects(host.command({ sessionID: "ses_a", command: "review" }), /not started/)
+assert.equal(await host.start(), true)
+assert.equal(await host.start(), false)
+assert.equal(typeof listener, "function")
+
+await listener({
+  directory: "/project",
+  payload: { type: "session.created", properties: { info: { id: "ses_a", directory: "/project" } } },
+})
+const runtime = host.runtimeManager.peek("ses_a")
+assert.ok(runtime)
+
+const result = await host.prompt({ sessionID: "ses_a", text: "continue" })
+assert.deepEqual(result, { accepted: true })
+assert.equal(prompts.length, 1)
+assert.equal(prompts[0].sessionID, "ses_a")
+assert.equal(prompts[0].text, "continue")
+assert.equal(prompts[0].runtime, runtime)
+
+const commandResult = await host.command({ sessionID: "ses_a", command: "/review", arguments: "--quick" })
+assert.deepEqual(commandResult, { accepted: true, kind: "command" })
+assert.equal(commands.length, 1)
+assert.equal(commands[0].sessionID, "ses_a")
+assert.equal(commands[0].command, "review")
+assert.equal(Object.prototype.hasOwnProperty.call(commands[0], "id"), false)
+assert.equal(commands[0].arguments, "--quick")
+assert.equal(commands[0].runtime, runtime)
+
+await assert.rejects(host.prompt({ sessionID: "", text: "missing" }), /session ID/)
+await assert.rejects(host.prompt({ sessionID: "ses_a", text: "   " }), /requires text/)
+await assert.rejects(host.command({ sessionID: "", command: "review" }), /session ID/)
+await assert.rejects(host.command({ sessionID: "ses_a", command: "" }), /requires a command name/)
+await assert.rejects(host.command({ sessionID: "ses_a", id: "review" }), /requires a command name/)
+
+const promptOnly = createOpenCode2HostContract({
+  subscribe: async (_callback) => ({ unsubscribe: async () => {} }),
+  sendPrompt: async () => ({ accepted: true }),
+})
+await promptOnly.start()
+await assert.rejects(promptOnly.command({ sessionID: "ses_a", command: "review" }), /session\.command capability is unavailable/)
+await promptOnly.dispose()
+
+await listener({
+  directory: "/project",
+  payload: { type: "server.instance.disposed", properties: { directory: "/project" } },
+})
+assert.equal(host.isHostDisposed(), true)
+assert.deepEqual(host.runtimeManager.entries(), [])
+assert.ok(events.some(({ event }) => event.kind === "server" && event.action === "disposed"))
+await assert.rejects(host.prompt({ sessionID: "ses_a", text: "late" }), /unavailable/)
+await assert.rejects(host.command({ sessionID: "ses_a", command: "review" }), /unavailable/)
+
+assert.equal(await host.dispose(), true)
+assert.equal(await host.dispose(), false)
+assert.equal(unsubscribeCalls, 1)
+console.log("OpenCode 2 host contract passed")

package/scripts/v2-plugin-sentinel-test.mjs

@@ -0,0 +1,136 @@
+import assert from "node:assert/strict"
+import plugin, {
+  OPENCODE_LOOP_V2_COMMANDS,
+  OPENCODE_LOOP_V2_PLUGIN_ID,
+} from "../src/source/opencode2/experimental.js"
+import { parseOpenCode2LoopCommandText } from "../src/source/opencode2/commands.js"
+import {
+  OPENCODE_LOOP_V2_COMMAND_SOURCE,
+  OPENCODE_LOOP_V2_HOST_REQUIREMENTS,
+  OPENCODE_LOOP_V2_RUNTIME_IMPLEMENTED,
+  OPENCODE_LOOP_V2_RUNTIME_REQUIREMENTS,
+  inspectOpenCode2CommandDraft,
+  inspectOpenCode2Context,
+  openCode2LoopRuntimeStatus,
+} from "../src/source/opencode2/capabilities.js"
+
+assert.equal(plugin.id, OPENCODE_LOOP_V2_PLUGIN_ID)
+assert.equal(plugin.id, "bybrawe.opencode-loop.v2.experimental")
+assert.equal(typeof plugin.setup, "function")
+assert.equal(OPENCODE_LOOP_V2_COMMAND_SOURCE, "plugin-transform")
+assert.equal(OPENCODE_LOOP_V2_RUNTIME_IMPLEMENTED, false)
+assert.deepEqual(OPENCODE_LOOP_V2_HOST_REQUIREMENTS, ["event.subscribe", "session.prompt"])
+assert.deepEqual(OPENCODE_LOOP_V2_RUNTIME_REQUIREMENTS, ["event.subscribe", "session.prompt", "runtime.adapter"])
+assert.deepEqual(Object.keys(OPENCODE_LOOP_V2_COMMANDS), [
+  "loop",
+  "loop-pause",
+  "loop-resume",
+  "loop-stop",
+  "loop-remove",
+  "loop-clear",
+  "loop-status",
+  "loop-now",
+])
+assert.deepEqual(
+  parseOpenCode2LoopCommandText(`${OPENCODE_LOOP_V2_COMMANDS["loop-now"].template}\n\nsecond`),
+  { name: "loop-now", arguments: "second" },
+)
+
+let transforms = 0
+let registered
+const currentContext = {
+  command: {
+    transform: async (callback) => {
+      transforms += 1
+      registered = callback
+    },
+  },
+}
+const setupResult = await plugin.setup(currentContext)
+assert.equal(setupResult, undefined)
+assert.equal(transforms, 1)
+assert.equal(typeof registered, "function")
+
+const commands = new Map()
+const currentDraft = {
+  list: () => [...commands.values()],
+  get: (name) => commands.get(name),
+  update: (name, update) => {
+    const command = commands.get(name) ?? { name, template: "" }
+    update(command)
+    command.name = name
+    commands.set(name, command)
+  },
+  remove: (name) => commands.delete(name),
+}
+await registered(currentDraft)
+
+assert.deepEqual([...commands.keys()], Object.keys(OPENCODE_LOOP_V2_COMMANDS))
+for (const [name, definition] of Object.entries(OPENCODE_LOOP_V2_COMMANDS)) {
+  const command = commands.get(name)
+  assert.equal(command?.name, name)
+  assert.equal(command?.template, definition.template)
+  assert.equal(command?.description, definition.description)
+}
+
+let missingDraftUpdateFailed = false
+try {
+  await registered({})
+} catch (error) {
+  missingDraftUpdateFailed = /command draft\.update capability is unavailable/.test(String(error))
+}
+assert.equal(missingDraftUpdateFailed, true)
+
+assert.deepEqual(inspectOpenCode2Context(currentContext), {
+  commandTransform: true,
+  eventSubscribe: false,
+  sessionHook: false,
+  sessionPrompt: false,
+  sessionCommand: false,
+  sessionShell: false,
+  toolTransform: false,
+  toolHook: false,
+})
+assert.deepEqual(inspectOpenCode2CommandDraft(currentDraft), {
+  list: true,
+  get: true,
+  update: true,
+  remove: true,
+})
+
+const currentStatus = openCode2LoopRuntimeStatus(currentContext, currentDraft)
+assert.deepEqual(currentStatus.hostBlockers, ["event.subscribe", "session.prompt"])
+assert.deepEqual(currentStatus.blockers, ["event.subscribe", "session.prompt", "runtime.adapter"])
+assert.equal(currentStatus.hostReady, false)
+assert.equal(currentStatus.implementationReady, false)
+assert.equal(currentStatus.ready, false)
+assert.equal(currentStatus.commandSource, "plugin-transform")
+
+const futureContext = {
+  command: { transform: async () => {} },
+  event: { subscribe: async () => {} },
+  session: {
+    prompt: async () => ({}),
+    command: async () => ({}),
+  },
+}
+const futureCapabilities = inspectOpenCode2Context(futureContext)
+assert.equal(futureCapabilities.sessionCommand, true)
+assert.equal(futureCapabilities.sessionShell, false)
+const futureStatus = openCode2LoopRuntimeStatus(futureContext, currentDraft)
+assert.deepEqual(futureStatus.hostBlockers, [])
+assert.deepEqual(futureStatus.blockers, ["runtime.adapter"])
+assert.equal(futureStatus.hostReady, true)
+assert.equal(futureStatus.implementationReady, false)
+assert.equal(futureStatus.ready, false)
+assert.equal(futureStatus.commandSource, "plugin-transform")
+
+let missingCapabilityFailed = false
+try {
+  await plugin.setup({})
+} catch (error) {
+  missingCapabilityFailed = /command\.transform capability is unavailable/.test(String(error))
+}
+assert.equal(missingCapabilityFailed, true)
+
+console.log("OpenCode 2 plugin sentinel contract passed")