@bybrawe/opencode-loop 0.5.27 → 0.5.28

package/scripts/runtime-scope-test.mjs

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict"
+import { createRuntimeScope } from "../src/source/runtime/scope.js"
+import { createRuntimeTimers } from "../src/source/runtime/timers.js"
+
+const scope = createRuntimeScope()
+const events = []
+scope.track(() => events.push("first"))
+const release = scope.track(() => events.push("released"))
+scope.track(() => events.push("last"))
+assert.equal(release(), true)
+
+let calls = 0
+const guarded = scope.guard(() => ++calls)
+assert.equal(guarded(), 1)
+
+const cleared = []
+const api = {
+  setTimeout(callback) { return { callback } },
+  clearTimeout(handle) { cleared.push(handle) },
+  setInterval(callback) { return { callback } },
+  clearInterval(handle) { cleared.push(handle) },
+}
+const timers = createRuntimeTimers(scope, api)
+const repeating = timers.interval(() => ++calls, 1)
+repeating.handle.callback()
+assert.equal(calls, 2)
+assert.equal(repeating.cancel(), true)
+repeating.handle.callback()
+assert.equal(calls, 2)
+const pending = timers.interval(() => ++calls, 1)
+
+assert.equal(scope.dispose("done"), true)
+assert.deepEqual(events, ["last", "first"])
+assert.equal(scope.signal.aborted, true)
+assert.equal(scope.isActive(), false)
+pending.handle.callback()
+assert.equal(calls, 2)
+assert.ok(cleared.includes(pending.handle))
+assert.equal(timers.timeout(() => {}, 1), undefined)
+assert.equal(scope.dispose(), false)
+assert.equal(guarded(), undefined)
+
+scope.track(() => events.push("late"))
+assert.deepEqual(events, ["last", "first", "late"])
+
+console.log("OpenCode runtime scope test passed")

package/scripts/session-manager-test.mjs

@@ -0,0 +1,48 @@
+import assert from "node:assert/strict"
+import { createSessionRuntimeManager } from "../src/source/runtime/session-manager.js"
+
+let clock = 1000
+const cleared = []
+const timerAPI = {
+  setTimeout(callback) { return { callback } },
+  clearTimeout(handle) { cleared.push(handle) },
+  setInterval(callback) { return { callback } },
+  clearInterval(handle) { cleared.push(handle) },
+}
+const manager = createSessionRuntimeManager({ now: () => clock, staleAfterMs: 100, timerAPI })
+
+const first = manager.observeExternal("ses_a")
+assert.equal(manager.entries()[0].seenAt, 1000)
+clock = 1050
+assert.equal(manager.peek("ses_a"), first)
+assert.equal(manager.entries()[0].seenAt, 1000, "reads must not refresh external activity")
+assert.equal(manager.observeExternal("ses_a"), first)
+assert.equal(manager.entries()[0].seenAt, 1050)
+
+first.dispose("replace")
+clock = 1060
+const second = manager.observeExternal("ses_a")
+assert.notEqual(second, first)
+assert.equal(manager.remove("ses_a", { expectedRuntime: first }), false)
+assert.equal(manager.peek("ses_a"), second)
+
+let calls = 0
+const pending = second.timers.interval(() => ++calls, 10)
+clock = 1159
+assert.deepEqual(manager.pruneStale(), [])
+clock = 1160
+assert.deepEqual(manager.pruneStale(), ["ses_a"])
+assert.equal(manager.peek("ses_a"), undefined)
+assert.ok(cleared.includes(pending.handle))
+pending.handle.callback()
+assert.equal(calls, 0)
+
+const third = manager.observeExternal("ses_a")
+assert.notEqual(third, second)
+assert.equal(manager.remove("ses_a", { expectedRuntime: third, reason: "done" }), true)
+assert.equal(third.scope.isActive(), false)
+assert.equal(manager.dispose(), true)
+assert.equal(manager.dispose(), false)
+assert.throws(() => manager.observeExternal("ses_b"), /disposed/)
+
+console.log("OpenCode session runtime manager test passed")

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,55 @@
+import assert from "node:assert/strict"
+import { createOpenCode2HostContract } from "../src/source/opencode2/host-contract.js"
+
+let listener
+let unsubscribeCalls = 0
+const prompts = []
+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 }
+  },
+  onEvent: async (event, runtime) => events.push({ event, runtime }),
+})
+
+await assert.rejects(host.prompt({ sessionID: "ses_a", text: "early" }), /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)
+
+await assert.rejects(host.prompt({ sessionID: "", text: "missing" }), /session ID/)
+await assert.rejects(host.prompt({ sessionID: "ses_a", text: "   " }), /requires text/)
+
+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/)
+
+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,87 @@
+import assert from "node:assert/strict"
+import plugin, { OPENCODE_LOOP_V2_PLUGIN_ID } from "../src/source/opencode2/experimental.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, "file-definitions")
+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"])
+
+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 currentDraft = {
+  list: () => [],
+  get: () => undefined,
+  update: () => {},
+  remove: () => {},
+}
+await registered(currentDraft)
+
+assert.deepEqual(inspectOpenCode2Context(currentContext), {
+  commandTransform: true,
+  eventSubscribe: false,
+  sessionHook: false,
+  sessionPrompt: 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, "file-definitions")
+
+const futureContext = {
+  command: { transform: async () => {} },
+  event: { subscribe: async () => {} },
+  session: { prompt: async () => ({}) },
+}
+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)
+
+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")