@bybrawe/opencode-loop 0.5.27 → 0.5.29

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
+}

package/src/source/runtime/scheduler.js

@@ -0,0 +1,212 @@
+import { now } from "../core/args.js"
+import { isGoalJob } from "../core/jobs.js"
+import { readState } from "../core/state.js"
+
+const DEFAULT_IDLE_DEBOUNCE_MS = 1_200
+const DEFAULT_BUSY_RETRY_MS = 5_000
+const DEFAULT_MIN_DUE_TIMER_MS = 250
+const DEFAULT_MAX_DUE_TIMER_MS = 2_147_000_000
+const DEFAULT_HEARTBEAT_MS = 2_500
+const DEFAULT_SESSION_TTL_MS = 12 * 60 * 60 * 1000
+
+export function jobDueAt(job, current = now()) {
+  if (isGoalJob(job) && ["completed", "blocked", "cleared"].includes(job.goalStatus)) return Infinity
+  if (!job.enabled || job.paused) return Infinity
+  if (job.maxRuns > 0 && (job.runCount || 0) >= job.maxRuns) return Infinity
+  if (Number(job.runNowRequestedAt || 0) > 0) return current
+  if (job.watchPaths?.length) return Infinity
+  const created = Date.parse(job.createdAt || "")
+  if (job.maxRuntimeMs > 0 && Number.isFinite(created) && current - created >= job.maxRuntimeMs) return current
+  if (job.intervalMs === 0) return current
+  if (!job.lastRunAt) {
+    if (job.immediate === false) return (Number.isFinite(created) ? created : current) + (job.intervalMs || 0)
+    return current
+  }
+  return job.lastRunAt + (job.intervalMs || 0)
+}
+
+export function nextDueDelay(state, current = now()) {
+  let soonest = Infinity
+  for (const job of state.jobs || []) soonest = Math.min(soonest, jobDueAt(job, current))
+  if (!Number.isFinite(soonest)) return Infinity
+  return Math.max(0, soonest - current)
+}
+
+export function createSchedulerRuntime(options = {}) {
+  const idleTimers = new Map()
+  const dueTimers = new Map()
+  const watchdogTimers = new Map()
+  const knownSessions = new Map()
+  let heartbeatTimer
+
+  const clock = options.now || now
+  const readStateFn = options.readState || readState
+  const setTimeoutFn = options.setTimeout || setTimeout
+  const clearTimeoutFn = options.clearTimeout || clearTimeout
+  const setIntervalFn = options.setInterval || setInterval
+  const clearIntervalFn = options.clearInterval || clearInterval
+  const idleDebounceMs = options.idleDebounceMs ?? DEFAULT_IDLE_DEBOUNCE_MS
+  const busyRetryMs = options.busyRetryMs ?? DEFAULT_BUSY_RETRY_MS
+  const minDueTimerMs = options.minDueTimerMs ?? DEFAULT_MIN_DUE_TIMER_MS
+  const maxDueTimerMs = options.maxDueTimerMs ?? DEFAULT_MAX_DUE_TIMER_MS
+  const heartbeatMs = options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS
+  const sessionTtlMs = options.sessionTtlMs ?? DEFAULT_SESSION_TTL_MS
+
+  const errorMessage = (error) => options.errorMessage ? options.errorMessage(error) : (error instanceof Error ? error.message : String(error || "unknown error"))
+  const appendLog = async (directory, event, extra) => { if (options.appendLoopLog) await options.appendLoopLog(directory, event, extra) }
+  const toast = async (client, message, level) => { if (options.toast) await options.toast(client, message, level) }
+
+  function stopHeartbeatIfIdle() {
+    if (!knownSessions.size && heartbeatTimer) {
+      clearIntervalFn(heartbeatTimer)
+      heartbeatTimer = undefined
+    }
+  }
+
+  function startHeartbeat() {
+    if (heartbeatTimer) return
+    heartbeatTimer = setIntervalFn(() => {
+      for (const [sessionID, info] of [...knownSessions.entries()]) {
+        if (!info || clock() - (info.seenAt || 0) > sessionTtlMs) {
+          knownSessions.delete(sessionID)
+          continue
+        }
+        Promise.resolve()
+          .then(async () => {
+            await options.finalizeActiveRun?.(info.directory, info.client, sessionID, { requireIdle: true, forceStale: true })
+            await options.maybeRunDueJobs?.(info.directory, info.client, sessionID, { heartbeat: true })
+          })
+          .catch((error) => appendLog(info.directory, "heartbeat-error", { sessionID, error: errorMessage(error) }).catch(() => {}))
+      }
+      stopHeartbeatIfIdle()
+    }, heartbeatMs)
+  }
+
+  function rememberSession(directory, client, sessionID) {
+    if (!sessionID) return
+    knownSessions.set(sessionID, { directory, client, seenAt: clock() })
+    startHeartbeat()
+  }
+
+  function cancelIdleWork(sessionID) {
+    const timer = idleTimers.get(sessionID)
+    if (timer) clearTimeoutFn(timer)
+    idleTimers.delete(sessionID)
+  }
+
+  function cancelDueWork(sessionID) {
+    const timer = dueTimers.get(sessionID)
+    if (timer) clearTimeoutFn(timer)
+    dueTimers.delete(sessionID)
+  }
+
+  function scheduleIdleWork(directory, client, sessionID) {
+    cancelIdleWork(sessionID)
+    const timer = setTimeoutFn(() => {
+      idleTimers.delete(sessionID)
+      Promise.resolve()
+        .then(async () => {
+          if (!await options.sessionIsIdle?.(client, sessionID, directory)) {
+            await scheduleDueWork(directory, client, sessionID, busyRetryMs)
+            return
+          }
+          await options.finalizeActiveRun?.(directory, client, sessionID)
+          if (!await options.sessionIsIdle?.(client, sessionID, directory)) {
+            await scheduleDueWork(directory, client, sessionID, busyRetryMs)
+            return
+          }
+          await options.maybeRunDueJobs?.(directory, client, sessionID)
+        })
+        .catch((error) => {
+          toast(client, `Loop idle handler failed: ${errorMessage(error)}`, "error").catch(() => {})
+          appendLog(directory, "idle-error", { sessionID, error: errorMessage(error) }).catch(() => {})
+        })
+    }, idleDebounceMs)
+    idleTimers.set(sessionID, timer)
+  }
+
+  async function startWatchdog(directory, client, sessionID) {
+    if (watchdogTimers.has(sessionID)) return
+    const timer = setIntervalFn(() => {
+      Promise.resolve()
+        .then(async () => {
+          const state = await readStateFn(directory, sessionID)
+          const delay = nextDueDelay(state, clock())
+          const hasJobs = (state.jobs || []).some((job) => job.enabled !== false && !job.paused && (!isGoalJob(job) || !["completed", "blocked", "cleared"].includes(job.goalStatus)))
+          if (!hasJobs || !Number.isFinite(delay)) {
+            stopWatchdog(sessionID)
+            return
+          }
+          if (delay <= 0) await options.maybeRunDueJobs?.(directory, client, sessionID)
+          else await scheduleDueWork(directory, client, sessionID)
+        })
+        .catch((error) => appendLog(directory, "watchdog-error", { sessionID, error: errorMessage(error) }).catch(() => {}))
+    }, Math.max(1_000, busyRetryMs))
+    watchdogTimers.set(sessionID, timer)
+  }
+
+  function stopWatchdog(sessionID) {
+    const timer = watchdogTimers.get(sessionID)
+    if (timer) clearIntervalFn(timer)
+    watchdogTimers.delete(sessionID)
+  }
+
+  async function scheduleDueWork(directory, client, sessionID, minDelayMs = 0) {
+    cancelDueWork(sessionID)
+
+    const state = await readStateFn(directory, sessionID)
+    const delay = nextDueDelay(state, clock())
+    if (!Number.isFinite(delay)) return
+
+    const wait = Math.min(Math.max(delay, minDelayMs, minDueTimerMs), maxDueTimerMs)
+    const timer = setTimeoutFn(() => {
+      dueTimers.delete(sessionID)
+      Promise.resolve()
+        .then(async () => {
+          if (!await options.sessionIsIdle?.(client, sessionID, directory)) {
+            await scheduleDueWork(directory, client, sessionID, busyRetryMs)
+            return
+          }
+          await options.finalizeActiveRun?.(directory, client, sessionID)
+          if (!await options.sessionIsIdle?.(client, sessionID, directory)) {
+            await scheduleDueWork(directory, client, sessionID, busyRetryMs)
+            return
+          }
+          await options.maybeRunDueJobs?.(directory, client, sessionID)
+        })
+        .catch((error) => {
+          toast(client, `Loop due timer failed: ${errorMessage(error)}`, "error").catch(() => {})
+          appendLog(directory, "due-timer-error", { sessionID, error: errorMessage(error) }).catch(() => {})
+        })
+    }, wait)
+    dueTimers.set(sessionID, timer)
+    await startWatchdog(directory, client, sessionID)
+  }
+
+  function sessionIDsForHost(directory, client) {
+    return [...knownSessions.entries()]
+      .filter(([, info]) => info?.directory === directory && info?.client === client)
+      .map(([sessionID]) => sessionID)
+  }
+
+  function clearSessionScheduling(sessionID) {
+    cancelIdleWork(sessionID)
+    cancelDueWork(sessionID)
+    stopWatchdog(sessionID)
+    knownSessions.delete(sessionID)
+    stopHeartbeatIfIdle()
+  }
+
+  return {
+    rememberSession,
+    scheduleIdleWork,
+    scheduleDueWork,
+    startWatchdog,
+    stopWatchdog,
+    cancelIdleWork,
+    cancelDueWork,
+    sessionIDsForHost,
+    clearSessionScheduling,
+    knownSessionCount: () => knownSessions.size,
+  }
+}

package/src/source/runtime/scope.js

@@ -0,0 +1,56 @@
+export function createRuntimeScope() {
+  const controller = new AbortController()
+  const cleanups = new Set()
+  let disposed = false
+
+  function track(cleanup) {
+    if (typeof cleanup !== "function") throw new TypeError("runtime scope cleanup must be a function")
+    if (disposed) {
+      cleanup()
+      return () => false
+    }
+
+    const entry = { cleanup }
+    cleanups.add(entry)
+    let tracked = true
+    return () => {
+      if (!tracked) return false
+      tracked = false
+      return cleanups.delete(entry)
+    }
+  }
+
+  function guard(callback) {
+    if (typeof callback !== "function") throw new TypeError("runtime scope guard requires a function")
+    return function (...args) {
+      if (disposed) return undefined
+      return callback.apply(this, args)
+    }
+  }
+
+  function dispose(reason) {
+    if (disposed) return false
+    disposed = true
+    controller.abort(reason)
+
+    const errors = []
+    for (const entry of [...cleanups].reverse()) {
+      cleanups.delete(entry)
+      try {
+        entry.cleanup()
+      } catch (error) {
+        errors.push(error)
+      }
+    }
+    if (errors.length) throw new AggregateError(errors, "runtime scope cleanup failed")
+    return true
+  }
+
+  return Object.freeze({
+    signal: controller.signal,
+    isActive: () => !disposed,
+    track,
+    guard,
+    dispose,
+  })
+}

package/src/source/runtime/session-activity.js

@@ -0,0 +1,112 @@
+import { now } from "../core/args.js"
+import { sdkCall } from "../opencode/sdk.js"
+import { updateSessionExecutionContext, deleteSessionExecutionContext } from "../opencode/session-context.js"
+
+export const activeToolCalls = new Map()
+export const sessionParents = new Map()
+export const sessionStatuses = new Map()
+export const sessionStatusSeenAt = new Map()
+
+export function hasActiveToolCalls(sessionID) {
+  return (activeToolCalls.get(sessionID)?.size || 0) > 0
+}
+
+export function markToolCallActive(input) {
+  const sessionID = input?.sessionID
+  const callID = input?.callID
+  if (typeof sessionID !== "string" || typeof callID !== "string") return
+  const calls = activeToolCalls.get(sessionID) || new Set()
+  calls.add(callID)
+  activeToolCalls.set(sessionID, calls)
+  sessionStatuses.set(sessionID, "busy")
+  sessionStatusSeenAt.set(sessionID, now())
+}
+
+export function markToolCallFinished(input) {
+  const sessionID = input?.sessionID
+  const callID = input?.callID
+  if (typeof sessionID !== "string" || typeof callID !== "string") return
+  const calls = activeToolCalls.get(sessionID)
+  if (!calls) return
+  calls.delete(callID)
+  if (!calls.size) activeToolCalls.delete(sessionID)
+}
+
+export function updateSessionRelationship(info, removed = false) {
+  const sessionID = info?.id
+  if (typeof sessionID !== "string") return
+  if (removed || typeof info?.parentID !== "string") sessionParents.delete(sessionID)
+  else sessionParents.set(sessionID, info.parentID)
+  if (!removed) updateSessionExecutionContext(info)
+  else deleteSessionExecutionContext(sessionID)
+}
+
+export function updateSessionRelationshipFromEvent(event) {
+  if (!["session.created", "session.updated", "session.deleted"].includes(event?.type)) return
+  updateSessionRelationship(event?.properties?.info, event.type === "session.deleted")
+}
+
+export function isDescendantSession(sessionID, ancestorID) {
+  const visited = new Set()
+  let current = sessionID
+  while (sessionParents.has(current) && !visited.has(current)) {
+    visited.add(current)
+    current = sessionParents.get(current)
+    if (current === ancestorID) return true
+  }
+  return false
+}
+
+export function hasBusyDescendant(sessionID) {
+  for (const childID of sessionParents.keys()) {
+    if (!isDescendantSession(childID, sessionID)) continue
+    const status = sessionStatuses.get(childID)
+    if (status === "busy" || status === "retry" || hasActiveToolCalls(childID)) return true
+  }
+  return false
+}
+
+export async function refreshSessionRelationships(client, directory) {
+  if (!client?.session?.list) return
+  try {
+    const sessions = await sdkCall(
+      client.session.list.bind(client.session),
+      { query: { directory } },
+      { directory },
+      {},
+    )
+    if (Array.isArray(sessions)) for (const info of sessions) updateSessionRelationship(info)
+  } catch {}
+}
+
+export function updateToolActivityFromEvent(event) {
+  const props = event?.properties || {}
+  if (event?.type === "message.part.updated") {
+    const part = props.part
+    if (part?.type !== "tool") return
+    const sessionID = part.sessionID || props.sessionID
+    if (["pending", "running"].includes(part.state?.status)) {
+      markToolCallActive({ sessionID, callID: part.callID })
+    }
+    if (["completed", "error"].includes(part.state?.status)) {
+      // Task/subagent hooks have used the part id as their hook call id in some
+      // OpenCode versions, while normal tools use part.callID. Clear either.
+      const identifiers = [...new Set([part.callID, part.id].filter((value) => typeof value === "string"))]
+      for (const callID of identifiers) markToolCallFinished({ sessionID, callID })
+    }
+    return
+  }
+
+  const started = ["session.next.shell.started", "session.next.tool.called"].includes(event?.type)
+  const finished = ["session.next.shell.ended", "session.next.tool.success", "session.next.tool.failed"].includes(event?.type)
+  if (started) markToolCallActive(props)
+  if (finished) markToolCallFinished(props)
+}
+
+export function clearSessionActivity(sessionID) {
+  activeToolCalls.delete(sessionID)
+  sessionParents.delete(sessionID)
+  sessionStatuses.delete(sessionID)
+  sessionStatusSeenAt.delete(sessionID)
+  deleteSessionExecutionContext(sessionID)
+}

package/src/source/runtime/session-manager.js

@@ -0,0 +1,100 @@
+import { DEFAULT_SESSION_STALE_MS, createSessionRegistry } from "./session-registry.js"
+import { createRuntimeScope } from "./scope.js"
+import { createRuntimeTimers } from "./timers.js"
+
+function defaultRuntimeFactory({ sessionID, timerAPI }) {
+  const scope = createRuntimeScope()
+  return Object.freeze({
+    sessionID,
+    scope,
+    timers: createRuntimeTimers(scope, timerAPI),
+    dispose: (reason) => scope.dispose(reason),
+  })
+}
+
+function validateRuntime(runtime, sessionID) {
+  if (!runtime || runtime.sessionID !== sessionID) throw new TypeError("session runtime factory must preserve the session ID")
+  if (typeof runtime?.scope?.isActive !== "function") throw new TypeError("session runtime factory must provide an active scope")
+  if (typeof runtime.dispose !== "function") throw new TypeError("session runtime factory must provide dispose()")
+  return runtime
+}
+
+export function createSessionRuntimeManager({
+  now = Date.now,
+  staleAfterMs = DEFAULT_SESSION_STALE_MS,
+  timerAPI = globalThis,
+  runtimeFactory = defaultRuntimeFactory,
+} = {}) {
+  if (typeof runtimeFactory !== "function") throw new TypeError("session runtime manager requires a runtime factory")
+  const registry = createSessionRegistry({ now, staleAfterMs })
+  let disposed = false
+
+  function observeExternal(sessionID) {
+    if (disposed) throw new Error("session runtime manager is disposed")
+    const key = String(sessionID || "").trim()
+    if (!key) throw new TypeError("session runtime manager requires a session ID")
+    const current = registry.peek(key)
+    const runtime = current?.runtime?.scope?.isActive?.()
+      ? current.runtime
+      : validateRuntime(runtimeFactory({ sessionID: key, timerAPI }), key)
+    registry.observeExternal(key, runtime)
+    return runtime
+  }
+
+  function peek(sessionID) {
+    return registry.peek(sessionID)?.runtime
+  }
+
+  function entries() {
+    return registry.entries()
+  }
+
+  function remove(sessionID, { expectedRuntime, reason } = {}) {
+    const current = registry.peek(sessionID)
+    if (!current) return false
+    if (expectedRuntime !== undefined && current.runtime !== expectedRuntime) return false
+    if (!registry.remove(sessionID, current.runtime)) return false
+    current.runtime.dispose(reason)
+    return true
+  }
+
+  function pruneStale(at = now()) {
+    const before = new Map(registry.entries().map((entry) => [entry.sessionID, entry.runtime]))
+    const removed = registry.pruneStale(at)
+    const errors = []
+    for (const sessionID of removed) {
+      try {
+        before.get(sessionID)?.dispose("stale-session")
+      } catch (error) {
+        errors.push(error)
+      }
+    }
+    if (errors.length) throw new AggregateError(errors, "stale session cleanup failed")
+    return removed
+  }
+
+  function dispose(reason) {
+    if (disposed) return false
+    disposed = true
+    const errors = []
+    for (const entry of registry.entries()) {
+      registry.remove(entry.sessionID, entry.runtime)
+      try {
+        entry.runtime.dispose(reason)
+      } catch (error) {
+        errors.push(error)
+      }
+    }
+    if (errors.length) throw new AggregateError(errors, "session runtime manager cleanup failed")
+    return true
+  }
+
+  return Object.freeze({
+    observeExternal,
+    peek,
+    entries,
+    remove,
+    pruneStale,
+    dispose,
+  })
+}

package/src/source/runtime/session-registry.js

@@ -0,0 +1,58 @@
+export const DEFAULT_SESSION_STALE_MS = 12 * 60 * 60 * 1000
+
+function sessionKey(sessionID) {
+  return String(sessionID || "").trim()
+}
+
+export function createSessionRegistry({ now = Date.now, staleAfterMs = DEFAULT_SESSION_STALE_MS } = {}) {
+  if (typeof now !== "function") throw new TypeError("session registry requires a clock function")
+  if (!Number.isFinite(staleAfterMs) || staleAfterMs < 0) throw new TypeError("session registry requires a non-negative staleAfterMs")
+
+  const sessions = new Map()
+
+  function observeExternal(sessionID, runtime) {
+    const key = sessionKey(sessionID)
+    if (!key) throw new TypeError("session registry requires a session ID")
+    const seenAt = Number(now())
+    if (!Number.isFinite(seenAt)) throw new TypeError("session registry clock must return a finite number")
+    const entry = Object.freeze({ sessionID: key, runtime, seenAt })
+    sessions.set(key, entry)
+    return entry
+  }
+
+  function peek(sessionID) {
+    return sessions.get(sessionKey(sessionID))
+  }
+
+  function remove(sessionID, expectedRuntime) {
+    const key = sessionKey(sessionID)
+    const current = sessions.get(key)
+    if (!current) return false
+    if (arguments.length > 1 && current.runtime !== expectedRuntime) return false
+    return sessions.delete(key)
+  }
+
+  function pruneStale(at = now()) {
+    const timestamp = Number(at)
+    if (!Number.isFinite(timestamp)) throw new TypeError("session registry prune time must be finite")
+    const removed = []
+    for (const [key, entry] of sessions) {
+      if (timestamp - entry.seenAt < staleAfterMs) continue
+      sessions.delete(key)
+      removed.push(key)
+    }
+    return removed
+  }
+
+  function entries() {
+    return [...sessions.values()]
+  }
+
+  return Object.freeze({
+    observeExternal,
+    peek,
+    remove,
+    pruneStale,
+    entries,
+  })
+}