@bybrawe/opencode-loop 0.5.27 → 0.5.29

package/scripts/v2-prompt-interval-test.mjs

@@ -0,0 +1,171 @@
+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-interval-"))
+let clock = 1_000
+let nextTimerID = 1
+const timers = new Map()
+const prompts = []
+const errors = []
+
+function setTimer(callback, delay) {
+  const handle = {
+    id: nextTimerID++,
+    unref() {},
+  }
+  timers.set(handle.id, { handle, callback, delay, dueAt: clock + delay })
+  return handle
+}
+
+function clearTimer(handle) {
+  timers.delete(handle?.id)
+}
+
+async function fireEarliestTimer() {
+  const timer = [...timers.values()].sort((a, b) => a.dueAt - b.dueAt)[0]
+  assert.ok(timer, "expected a scheduled timer")
+  clock = timer.dueAt
+  timers.delete(timer.handle.id)
+  return await timer.callback()
+}
+
+async function readState(sessionID) {
+  const file = path.join(directory, ".opencode", "opencode-loop", `${sessionID}.json`)
+  try {
+    return JSON.parse(await readFile(file, "utf8"))
+  } catch (error) {
+    if (error?.code === "ENOENT") return { jobs: [] }
+    throw error
+  }
+}
+
+const runtime = createOpenCode2PromptRuntime({
+  prompt: async (request) => { prompts.push({ ...request, at: clock }) },
+  now: () => clock,
+  setTimer,
+  clearTimer,
+  onError: (error) => { errors.push(error) },
+})
+
+try {
+  const sessionID = "ses_interval"
+  const added = await runtime.onEvent({
+    kind: "command",
+    action: "executed",
+    name: "loop",
+    sessionID,
+    directory,
+    arguments: "5s --max-runs 3 interval work",
+  })
+  assert.equal(added.accepted, true)
+  assert.equal(added.job.intervalMs, 5_000)
+  assert.equal(runtime.scheduledCount(), 0, "first interval run waits for an idle event")
+
+  const statusIdle = await runtime.onEvent({ kind: "session", action: "status", status: "idle", sessionID, directory })
+  assert.equal(statusIdle.dispatched, false, "status=idle records readiness but must not duplicate session.idle dispatch")
+  assert.equal(prompts.length, 0)
+
+  const first = await runtime.onEvent({ kind: "session", action: "idle", sessionID, directory })
+  assert.equal(first.dispatched, true)
+  assert.equal(prompts.length, 1)
+  assert.equal(prompts[0].at, 1_000)
+  assert.equal(runtime.scheduledCount(), 1)
+  assert.equal(timers.size, 1)
+  assert.equal([...timers.values()][0].delay, 5_000)
+
+  let state = await readState(sessionID)
+  assert.equal(state.jobs[0].runCount, 1)
+  assert.equal(state.jobs[0].lastRunAt, 1_000)
+  assert.equal(state.jobs[0].enabled, true)
+
+  await runtime.onEvent({ kind: "session", action: "status", status: "busy", sessionID, directory })
+  const busyTimer = await fireEarliestTimer()
+  assert.equal(busyTimer.dispatched, false)
+  assert.equal(busyTimer.reason, "not-idle")
+  assert.equal(prompts.length, 1, "due timer must never prompt while session is known busy")
+  assert.equal(runtime.scheduledCount(), 0, "due work waits for the next idle event instead of spinning timers")
+
+  const second = await runtime.onEvent({ kind: "session", action: "idle", sessionID, directory })
+  assert.equal(second.dispatched, true)
+  assert.equal(prompts.length, 2)
+  assert.equal(prompts[1].at, 6_000)
+  assert.equal(runtime.scheduledCount(), 1)
+
+  const secondStatusIdle = await runtime.onEvent({ kind: "session", action: "status", status: "idle", sessionID, directory })
+  assert.equal(secondStatusIdle.dispatched, false)
+  assert.equal(prompts.length, 2)
+
+  const idleTimer = await fireEarliestTimer()
+  assert.equal(idleTimer.dispatched, true, "timer may dispatch once the session is already known idle")
+  assert.equal(prompts.length, 3)
+  assert.equal(prompts[2].at, 11_000)
+  assert.equal(runtime.scheduledCount(), 0)
+
+  state = await readState(sessionID)
+  assert.equal(state.jobs[0].runCount, 3)
+  assert.equal(state.jobs[0].enabled, false)
+  assert.equal((await runtime.onEvent({ kind: "session", action: "idle", sessionID, directory })).dispatched, false)
+  assert.equal(prompts.length, 3)
+
+  const pauseSession = "ses_pause"
+  await runtime.onEvent({
+    kind: "command",
+    action: "executed",
+    name: "loop",
+    sessionID: pauseSession,
+    directory,
+    arguments: "4s --max-runs 2 pause work",
+  })
+  await runtime.onEvent({ kind: "session", action: "idle", sessionID: pauseSession, directory })
+  assert.equal(runtime.scheduledCount(), 1)
+  assert.equal(timers.size, 1)
+
+  const paused = await runtime.onEvent({ kind: "command", action: "executed", name: "loop-pause", sessionID: pauseSession, directory, arguments: "" })
+  assert.equal(paused.count, 1)
+  assert.equal(runtime.scheduledCount(), 0)
+  assert.equal(timers.size, 0)
+
+  const resumed = await runtime.onEvent({ kind: "command", action: "executed", name: "loop-resume", sessionID: pauseSession, directory, arguments: "" })
+  assert.equal(resumed.count, 1)
+  assert.equal((await readState(pauseSession)).jobs[0].lastRunAt, 0)
+  assert.equal(runtime.scheduledCount(), 0, "resume makes the job immediately due but still idle-gated")
+  const resumedRun = await runtime.onEvent({ kind: "session", action: "idle", sessionID: pauseSession, directory })
+  assert.equal(resumedRun.dispatched, true)
+  assert.equal((await readState(pauseSession)).jobs[0].enabled, false)
+
+  const cleanupSession = "ses_cleanup"
+  await runtime.onEvent({ kind: "command", action: "executed", name: "loop", sessionID: cleanupSession, directory, arguments: "10s cleanup work" })
+  await runtime.onEvent({ kind: "session", action: "idle", sessionID: cleanupSession, directory })
+  assert.equal(runtime.scheduledCount(), 1)
+  const stopped = await runtime.onEvent({ kind: "command", action: "executed", name: "loop-stop", sessionID: cleanupSession, directory, arguments: "all" })
+  assert.equal(stopped.count, 1)
+  assert.equal(runtime.scheduledCount(), 0)
+  assert.equal(timers.size, 0)
+
+  const deletedSession = "ses_deleted"
+  await runtime.onEvent({ kind: "command", action: "executed", name: "loop", sessionID: deletedSession, directory, arguments: "8s delete work" })
+  await runtime.onEvent({ kind: "session", action: "idle", sessionID: deletedSession, directory })
+  assert.equal(runtime.scheduledCount(), 1)
+  const deleted = await runtime.onEvent({ kind: "session", action: "deleted", sessionID: deletedSession, directory })
+  assert.equal(deleted.disposedScope, true)
+  assert.equal(runtime.scheduledCount(), 0)
+  assert.equal(timers.size, 0)
+
+  const disposeSession = "ses_dispose"
+  await runtime.onEvent({ kind: "command", action: "executed", name: "loop", sessionID: disposeSession, directory, arguments: "9s dispose work" })
+  await runtime.onEvent({ kind: "session", action: "idle", sessionID: disposeSession, directory })
+  assert.equal(runtime.scheduledCount(), 1)
+  assert.equal(await runtime.dispose(), true)
+  assert.equal(runtime.scheduledCount(), 0)
+  assert.equal(timers.size, 0)
+  assert.equal(await runtime.dispose(), false)
+  assert.deepEqual(errors, [])
+
+  console.log("OpenCode 2 idle-safe interval runtime tests passed")
+} finally {
+  await runtime.dispose().catch(() => undefined)
+  await rm(directory, { recursive: true, force: true })
+}

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

@@ -0,0 +1,267 @@
+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"
+import { formatOpenCode2LoopStatus } from "../src/source/opencode2/status.js"
+
+const directory = await mkdtemp(path.join(os.tmpdir(), "opencode-loop-v2-prompt-"))
+const sessionID = "ses_v2_prompt_runtime"
+const prompts = []
+const runtime = createOpenCode2PromptRuntime({ prompt: async (request) => { prompts.push(request) } })
+
+async function readState() {
+  const file = path.join(directory, ".opencode", "opencode-loop", `${sessionID}.json`)
+  try {
+    return JSON.parse(await readFile(file, "utf8"))
+  } catch (error) {
+    if (error?.code === "ENOENT") return { jobs: [] }
+    throw error
+  }
+}
+
+try {
+  const added = await runtime.onEvent({ kind: "command", action: "executed", name: "loop", sessionID, directory, arguments: "0s --max-runs 2 --ask-never continue the current task" })
+  assert.equal(added.accepted, true)
+  let state = await readState()
+  assert.equal(state.jobs.length, 1)
+  assert.equal(state.jobs[0].runCount, 0)
+
+  assert.equal((await runtime.onEvent({ kind: "session", action: "idle", sessionID, directory })).dispatched, true)
+  assert.equal(prompts.length, 1)
+  assert.ok(prompts[0].text.includes("AUTONOMOUS OPENCODE LOOP ITERATION"))
+  assert.ok(prompts[0].text.includes("continue the current task"))
+  assert.ok(prompts[0].text.includes("Do not ask the user questions"))
+  state = await readState()
+  assert.equal(state.jobs[0].runCount, 1)
+  assert.equal(state.jobs[0].enabled, true)
+
+  const paused = await runtime.onEvent({ kind: "command", action: "executed", name: "loop-pause", sessionID, directory, arguments: "" })
+  assert.equal(paused.count, 1)
+  state = await readState()
+  assert.equal(state.jobs[0].paused, true)
+  assert.equal((await runtime.onEvent({ kind: "session", action: "idle", sessionID, directory })).dispatched, false)
+  assert.equal(prompts.length, 1)
+
+  const resumed = await runtime.onEvent({ kind: "command", action: "executed", name: "loop-resume", sessionID, directory, arguments: "" })
+  assert.equal(resumed.count, 1)
+  state = await readState()
+  assert.equal(state.jobs[0].paused, false)
+  assert.equal(state.jobs[0].lastRunAt, 0)
+
+  assert.equal((await runtime.onEvent({ kind: "session", action: "idle", sessionID, directory })).dispatched, true)
+  state = await readState()
+  assert.equal(state.jobs[0].runCount, 2)
+  assert.equal(state.jobs[0].enabled, false)
+
+  assert.equal((await runtime.onEvent({ kind: "session", action: "idle", sessionID, directory })).dispatched, false)
+  assert.equal(prompts.length, 2)
+
+  const status = await runtime.onEvent({ kind: "command", action: "executed", name: "loop-status", sessionID, directory, arguments: "" })
+  assert.equal(status.accepted, true)
+  assert.equal(prompts.length, 3)
+  assert.equal(prompts[2].noReply, true)
+  assert.match(prompts[2].text, /^OpenCode loop status:/)
+  assert.match(prompts[2].text, /runs=2/)
+  assert.match(prompts[2].text, /continue the current task/)
+
+  const interval = await runtime.onEvent({ kind: "command", action: "executed", name: "loop", sessionID, directory, arguments: "5m --name later --multi do this later" })
+  assert.equal(interval.accepted, true)
+  assert.equal(interval.job.intervalMs, 300_000)
+  assert.equal(runtime.scheduledCount(), 0)
+  assert.equal((await readState()).jobs.length, 2)
+
+  const intervalRemoved = await runtime.onEvent({ kind: "command", action: "executed", name: "loop-stop", sessionID, directory, arguments: "later" })
+  assert.equal(intervalRemoved.count, 1)
+  assert.equal((await readState()).jobs.length, 1)
+
+  const command = await runtime.onEvent({ kind: "command", action: "executed", name: "loop", sessionID, directory, arguments: "0s --command /review" })
+  assert.equal(command.accepted, false)
+  assert.ok(command.blockers.includes("command-capability"))
+  assert.equal((await readState()).jobs.length, 1)
+
+  const named = await runtime.onEvent({ kind: "command", action: "executed", name: "loop", sessionID, directory, arguments: "0s --name keep --multi keep working" })
+  assert.equal(named.accepted, true)
+  assert.equal((await readState()).jobs.length, 2)
+
+  const removed = await runtime.onEvent({ kind: "command", action: "executed", name: "loop-stop", sessionID, directory, arguments: "keep" })
+  assert.equal(removed.count, 1)
+  assert.equal((await readState()).jobs.length, 1)
+
+  const cleared = await runtime.onEvent({ kind: "command", action: "executed", name: "loop-clear", sessionID, directory, arguments: "missing-target-is-ignored" })
+  assert.equal(cleared.count, 1)
+  assert.equal(cleared.target, "all")
+  assert.equal((await readState()).jobs.length, 0)
+
+  const emptyStatus = await runtime.onEvent({ kind: "command", action: "executed", name: "loop-status", sessionID, directory, arguments: "" })
+  assert.equal(emptyStatus.accepted, true)
+  assert.equal(prompts.at(-1).noReply, true)
+  assert.equal(prompts.at(-1).text, "OpenCode loop status:\nNo active loop jobs.")
+
+  console.log("OpenCode 2 prompt runtime contract passed")
+} finally {
+  await runtime.dispose()
+  await rm(directory, { recursive: true, force: true })
+}
+
+{
+  const current = Date.parse("2026-08-18T00:00:00.000Z")
+  const status = formatOpenCode2LoopStatus({
+    jobs: [{
+      id: "job_no_now",
+      name: "delayed",
+      action: "wait before the first run",
+      kind: "prompt",
+      intervalMs: 1_000,
+      immediate: false,
+      createdAt: new Date(current).toISOString(),
+      lastRunAt: 0,
+      runCount: 0,
+      failureCount: 0,
+      noOverlap: true,
+    }],
+  }, current)
+  assert.match(status.text, /due in 1s/)
+}
+
+{
+  const delayedDirectory = await mkdtemp(path.join(os.tmpdir(), "opencode-loop-v2-no-now-"))
+  const delayedSessionID = "ses_v2_no_now"
+  const delayedPrompts = []
+  const scheduled = []
+  let clock = Date.now()
+  const delayedRuntime = createOpenCode2PromptRuntime({
+    prompt: async (request) => { delayedPrompts.push(request) },
+    now: () => clock,
+    setTimer: (fn, ms) => {
+      const handle = { fn, ms, unref() {} }
+      scheduled.push(handle)
+      return handle
+    },
+    clearTimer: () => {},
+  })
+  const delayedFile = path.join(delayedDirectory, ".opencode", "opencode-loop", `${delayedSessionID}.json`)
+
+  try {
+    const added = await delayedRuntime.onEvent({
+      kind: "command",
+      action: "executed",
+      name: "loop",
+      sessionID: delayedSessionID,
+      directory: delayedDirectory,
+      arguments: "1s --no-now --max-runs 1 wait before the first run",
+    })
+    assert.equal(added.accepted, true)
+    assert.equal(added.job.immediate, false)
+
+    let state = JSON.parse(await readFile(delayedFile, "utf8"))
+    const createdAt = Date.parse(state.jobs[0].createdAt)
+    assert.ok(Number.isFinite(createdAt))
+    assert.ok(scheduled.some((timer) => timer.ms > 0), "--no-now must schedule a future first run")
+
+    clock = createdAt + 999
+    const earlyIdle = await delayedRuntime.onEvent({ kind: "session", action: "idle", sessionID: delayedSessionID, directory: delayedDirectory })
+    assert.equal(earlyIdle.dispatched, false)
+    assert.equal(delayedPrompts.length, 0, "--no-now must not dispatch before createdAt + interval")
+
+    clock = createdAt + 1_001
+    const dueIdle = await delayedRuntime.onEvent({ kind: "session", action: "idle", sessionID: delayedSessionID, directory: delayedDirectory })
+    assert.equal(dueIdle.dispatched, true)
+    assert.equal(delayedPrompts.length, 1)
+    state = JSON.parse(await readFile(delayedFile, "utf8"))
+    assert.equal(state.jobs[0].runCount, 1)
+    assert.equal(state.jobs[0].enabled, false)
+  } finally {
+    await delayedRuntime.dispose()
+    await rm(delayedDirectory, { recursive: true, force: true })
+  }
+}
+
+{
+  const nowDirectory = await mkdtemp(path.join(os.tmpdir(), "opencode-loop-v2-run-now-"))
+  const nowSessionID = "ses_v2_run_now"
+  const nowPrompts = []
+  const clock = Date.parse("2026-08-18T00:00:00.000Z")
+  const nowRuntime = createOpenCode2PromptRuntime({
+    prompt: async (request) => { nowPrompts.push(request) },
+    now: () => clock,
+    setTimer: () => ({ unref() {} }),
+    clearTimer: () => {},
+  })
+  const nowFile = path.join(nowDirectory, ".opencode", "opencode-loop", `${nowSessionID}.json`)
+
+  try {
+    await nowRuntime.onEvent({
+      kind: "command",
+      action: "executed",
+      name: "loop",
+      sessionID: nowSessionID,
+      directory: nowDirectory,
+      arguments: "0s --name first --multi --max-runs 1 first naturally due job",
+    })
+    await nowRuntime.onEvent({
+      kind: "command",
+      action: "executed",
+      name: "loop",
+      sessionID: nowSessionID,
+      directory: nowDirectory,
+      arguments: "10m --no-now --name second --multi --max-runs 1 second forced job",
+    })
+    const paused = await nowRuntime.onEvent({
+      kind: "command",
+      action: "executed",
+      name: "loop-pause",
+      sessionID: nowSessionID,
+      directory: nowDirectory,
+      arguments: "second",
+    })
+    assert.equal(paused.count, 1)
+
+    const missing = await nowRuntime.onEvent({
+      kind: "command",
+      action: "executed",
+      name: "loop-now",
+      sessionID: nowSessionID,
+      directory: nowDirectory,
+      arguments: "missing",
+    })
+    assert.equal(missing.count, 0)
+
+    const requested = await nowRuntime.onEvent({
+      kind: "command",
+      action: "executed",
+      name: "loop-now",
+      sessionID: nowSessionID,
+      directory: nowDirectory,
+      arguments: "second",
+    })
+    assert.equal(requested.count, 1)
+    assert.equal(requested.target, "second")
+
+    let state = JSON.parse(await readFile(nowFile, "utf8"))
+    const first = state.jobs.find((job) => job.name === "first")
+    const second = state.jobs.find((job) => job.name === "second")
+    assert.equal(first.runNowRequestedAt, undefined)
+    assert.equal(second.paused, false)
+    assert.equal(second.runNowRequestedAt, clock)
+    const status = formatOpenCode2LoopStatus(state, clock)
+    assert.match(status.text, /second forced job[^\n]*due in every idle[^\n]*run-now/)
+
+    const forcedIdle = await nowRuntime.onEvent({ kind: "session", action: "idle", sessionID: nowSessionID, directory: nowDirectory })
+    assert.equal(forcedIdle.dispatched, true)
+    assert.match(nowPrompts[0].text, /second forced job/)
+    state = JSON.parse(await readFile(nowFile, "utf8"))
+    assert.equal(state.jobs.find((job) => job.name === "second").runNowRequestedAt, undefined)
+    assert.equal(state.jobs.find((job) => job.name === "second").runCount, 1)
+    assert.equal(state.jobs.find((job) => job.name === "first").runCount, 0)
+
+    const naturalIdle = await nowRuntime.onEvent({ kind: "session", action: "idle", sessionID: nowSessionID, directory: nowDirectory })
+    assert.equal(naturalIdle.dispatched, true)
+    assert.match(nowPrompts[1].text, /first naturally due job/)
+  } finally {
+    await nowRuntime.dispose()
+    await rm(nowDirectory, { recursive: true, force: true })
+  }
+}
+
+console.log("OpenCode 2 --no-now and loop-now contracts passed")