@bybrawe/opencode-loop 0.5.28 → 0.5.29

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/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-status.js

@@ -0,0 +1,197 @@
+import { now as defaultNow } from "../core/args.js"
+import { appendLoopLog as defaultAppendLoopLog } from "../core/process.js"
+import { sdkData, sdkError } from "../opencode/sdk.js"
+import { activeRunCompletionFromMessages as defaultActiveRunCompletionFromMessages } from "../opencode/host.js"
+import {
+  sessionParents,
+  sessionStatuses,
+  sessionStatusSeenAt,
+  hasActiveToolCalls,
+  isDescendantSession,
+  hasBusyDescendant,
+} from "./session-activity.js"
+
+const DEFAULT_STALE_ACTIVE_RECOVERY_MS = 45_000
+const DEFAULT_SESSION_STATUS_CACHE_MS = 1_500
+
+function positiveNumber(value, fallback) {
+  const number = Number(value)
+  return Number.isFinite(number) && number > 0 ? number : fallback
+}
+
+function nonNegativeNumber(value, fallback) {
+  const number = Number(value)
+  return Number.isFinite(number) && number >= 0 ? number : fallback
+}
+
+export function createSessionStatusRuntime(options = {}) {
+  const activeRuns = options.activeRuns
+  if (!(activeRuns instanceof Map)) throw new TypeError("createSessionStatusRuntime requires activeRuns Map")
+  const now = typeof options.now === "function" ? options.now : defaultNow
+  const appendLoopLog = typeof options.appendLoopLog === "function" ? options.appendLoopLog : defaultAppendLoopLog
+  const activeRunCompletionFromMessages = typeof options.activeRunCompletionFromMessages === "function"
+    ? options.activeRunCompletionFromMessages
+    : defaultActiveRunCompletionFromMessages
+  const staleActiveRecoveryMs = positiveNumber(options.staleActiveRecoveryMs, DEFAULT_STALE_ACTIVE_RECOVERY_MS)
+  const sessionStatusCacheMs = nonNegativeNumber(options.sessionStatusCacheMs, DEFAULT_SESSION_STATUS_CACHE_MS)
+
+  function markSessionStatus(sessionID, type, observedAt = now()) {
+    if (typeof sessionID !== "string" || typeof type !== "string") return false
+    sessionStatuses.set(sessionID, type)
+    sessionStatusSeenAt.set(sessionID, observedAt)
+    return true
+  }
+
+  function clearSessionStatus(sessionID) {
+    sessionStatuses.delete(sessionID)
+    sessionStatusSeenAt.delete(sessionID)
+  }
+
+  function updateSessionStatusFromEvent(event) {
+    const sessionID = event?.properties?.sessionID
+    if (typeof sessionID !== "string") return undefined
+    if (event?.type === "session.idle") {
+      markSessionStatus(sessionID, "idle")
+      return { sessionID, idle: true }
+    }
+    if (event?.type === "session.status") {
+      const status = event?.properties?.status
+      const type = status && typeof status === "object" ? status.type : undefined
+      if (typeof type === "string") markSessionStatus(sessionID, type)
+      return { sessionID, idle: type === "idle" }
+    }
+    return undefined
+  }
+
+  function staleActiveRun(sessionID) {
+    const active = activeRuns.get(sessionID)
+    if (!active) return false
+    const age = now() - (active.startedAt || 0)
+    const configured = Number(active.job?.staleActiveRecoveryMs || active.job?.activeRecoveryMs || 0)
+    const threshold = Number.isFinite(configured) && configured > 0 ? configured : staleActiveRecoveryMs
+    return age >= threshold
+  }
+
+  async function readLiveSessionStatus(client, sessionID, directory) {
+    const statusMethod = client?.session?.status
+    if (typeof statusMethod !== "function") return undefined
+    const argsList = []
+    if (directory) argsList.push({ query: { directory } }, { directory }, { workspace: directory })
+    argsList.push({})
+    for (const args of argsList) {
+      try {
+        const result = await statusMethod.call(client.session, args)
+        const error = sdkError(result)
+        if (error) continue
+        const data = sdkData(result)
+        if (!data || typeof data !== "object" || Array.isArray(data)) continue
+        const observedAt = now()
+        for (const [observedSessionID, observedStatus] of Object.entries(data)) {
+          const observedType = observedStatus && typeof observedStatus === "object" ? observedStatus.type : undefined
+          if (typeof observedType !== "string") continue
+          markSessionStatus(observedSessionID, observedType, observedAt)
+        }
+        // OpenCode's status list contains active sessions; idle sessions are
+        // normally omitted. Clear a completed descendant that was previously busy.
+        for (const childID of sessionParents.keys()) {
+          if (!isDescendantSession(childID, sessionID) || data[childID]) continue
+          markSessionStatus(childID, "idle", observedAt)
+        }
+        if (hasBusyDescendant(sessionID)) return { type: "busy", source: "descendant" }
+        const status = data?.[sessionID]
+        const type = status && typeof status === "object" ? status.type : undefined
+        if (typeof type === "string") return { type, source: "sdk" }
+        return { type: "idle", source: "sdk" }
+      } catch {}
+    }
+    return undefined
+  }
+
+  async function canFinalizeActiveRun(directory, client, sessionID, active, options = {}) {
+    if (hasActiveToolCalls(sessionID) || hasBusyDescendant(sessionID)) return false
+    if (!options.requireIdle && !options.forceStale) return true
+
+    const completion = options.forceStale
+      ? await activeRunCompletionFromMessages(directory, client, sessionID, active)
+      : undefined
+    if (completion === "completed") return true
+    if (!options.requireIdle) return completion === "unknown" && staleActiveRun(sessionID)
+
+    const live = await readLiveSessionStatus(client, sessionID, directory)
+    if (live?.type === "idle") return true
+    if (live?.type) {
+      if ((live.type === "busy" || live.type === "retry") && options.forceStale && completion === "unknown" && staleActiveRun(sessionID)) return true
+      return false
+    }
+
+    if (options.forceStale && completion === "unknown" && staleActiveRun(sessionID)) return true
+    const cached = sessionStatuses.get(sessionID)
+    const seenAt = sessionStatusSeenAt.get(sessionID) || 0
+    return cached === "idle" && seenAt > (active.startedAt || 0)
+  }
+
+  async function sessionStatusType(client, sessionID, directory, options = {}) {
+    // OpenCode can briefly report an idle session while a long-running tool or
+    // subtask is still executing. Tool lifecycle hooks are the more specific
+    // signal here, so never enqueue another turn until every active call ends.
+    if (hasActiveToolCalls(sessionID) || hasBusyDescendant(sessionID)) {
+      markSessionStatus(sessionID, "busy")
+      return "busy"
+    }
+
+    const cached = sessionStatuses.get(sessionID)
+    const seenAt = sessionStatusSeenAt.get(sessionID) || 0
+
+    // Idle is safe to trust until OpenCode tells us otherwise. Busy/retry is only
+    // trusted briefly: OpenCode custom commands such as /loop-status create their
+    // own short assistant turn, and some TUI builds do not always emit the final
+    // idle event after that turn. If we cache busy forever, due loop work can get
+    // stuck at "due in every idle" until the user types another command.
+    if (cached === "idle") return cached
+    if (cached && now() - seenAt < sessionStatusCacheMs) return cached
+
+    const live = await readLiveSessionStatus(client, sessionID, directory)
+    if (live?.type) {
+      // Some OpenCode 1.15.x TUI builds can leave session.status at busy after a
+      // plugin-injected turn until the next user command touches the session.
+      // When the only reason we still think the session is busy is our own stale
+      // active-run guard, recover instead of waiting for another manual command.
+      if ((live.type === "busy" || live.type === "retry") && options.recoverStaleActive !== false) {
+        const active = activeRuns.get(sessionID)
+        if (active) {
+          const completion = await activeRunCompletionFromMessages(directory, client, sessionID, active)
+          if (completion === "completed" || (completion === "unknown" && staleActiveRun(sessionID))) {
+            markSessionStatus(sessionID, "idle")
+            await appendLoopLog(directory, completion === "completed" ? "status-message-complete-recovery" : "status-stale-recovery", {
+              sessionID,
+              job: active.job?.name || active.jobId,
+              startedAt: active.startedAt,
+            })
+            return "idle"
+          }
+        }
+      }
+      markSessionStatus(sessionID, live.type)
+      return live.type
+    }
+
+    const fallback = activeRuns.has(sessionID) && !staleActiveRun(sessionID) ? "busy" : "idle"
+    markSessionStatus(sessionID, fallback)
+    return fallback
+  }
+
+  async function sessionIsIdle(client, sessionID, directory, options = {}) {
+    return await sessionStatusType(client, sessionID, directory, options) === "idle"
+  }
+
+  return {
+    markSessionStatus,
+    clearSessionStatus,
+    updateSessionStatusFromEvent,
+    staleActiveRun,
+    canFinalizeActiveRun,
+    readLiveSessionStatus,
+    sessionStatusType,
+    sessionIsIdle,
+  }
+}

package/scripts/host-bridge-parity-test.mjs

@@ -1,22 +0,0 @@
-import assert from "node:assert/strict"
-import { promises as fs } from "node:fs"
-
-const legacy = await fs.readFile("src/source/legacy-v1.js", "utf8")
-const host = await fs.readFile("src/source/opencode/host.js", "utf8")
-
-const legacyStart = legacy.indexOf("function fireSdk(")
-const legacyEnd = legacy.indexOf("function guardLoopOwnedUserMessage(")
-const hostStart = host.indexOf("export function fireSdk(")
-assert.ok(legacyStart >= 0 && legacyEnd > legacyStart, "legacy host bridge block not found")
-assert.ok(hostStart >= 0, "host bridge module block not found")
-
-const normalize = (text) => text
-  .replace(/\bexport\s+(?=(?:async\s+)?function\b)/g, "")
-  .replace(/\r\n/g, "\n")
-  .trim()
-
-const legacyBlock = normalize(legacy.slice(legacyStart, legacyEnd))
-const hostBlock = normalize(host.slice(hostStart))
-assert.equal(hostBlock, legacyBlock, "OpenCode host bridge drifted from the stable V1 implementation")
-
-console.log("host bridge parity test passed")