@bybrawe/opencode-loop 0.5.26 → 0.5.28

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

package/src/source/runtime/timers.js

@@ -0,0 +1,45 @@
+function createOwnedTimer(scope, callback, delay, repeat, api, ref) {
+  if (!scope?.isActive?.()) return undefined
+  let active = true
+  let release
+  let handle
+
+  const invoke = scope.guard((...args) => {
+    if (!active) return
+    if (!repeat) {
+      active = false
+      release?.()
+    }
+    callback(...args)
+  })
+
+  handle = repeat ? api.setInterval(invoke, delay) : api.setTimeout(invoke, delay)
+  release = scope.track(() => {
+    if (repeat) api.clearInterval(handle)
+    else api.clearTimeout(handle)
+  })
+  if (!ref) handle?.unref?.()
+
+  return Object.freeze({
+    handle,
+    cancel() {
+      if (!active) return false
+      active = false
+      if (repeat) api.clearInterval(handle)
+      else api.clearTimeout(handle)
+      release()
+      return true
+    },
+  })
+}
+
+export function createRuntimeTimers(scope, api = globalThis) {
+  return Object.freeze({
+    timeout(callback, delay, options = {}) {
+      return createOwnedTimer(scope, callback, delay, false, api, options.ref !== false)
+    },
+    interval(callback, delay, options = {}) {
+      return createOwnedTimer(scope, callback, delay, true, api, options.ref !== false)
+    },
+  })
+}

package/src/source/v1.js

@@ -0,0 +1,69 @@
+import LegacyOpenCodeLoopPlugin from "./legacy-v1.js"
+import { createSessionRuntimeManager } from "./runtime/session-manager.js"
+import { observeRuntimeEvent } from "./runtime/observer.js"
+
+const clientGenerations = new WeakMap()
+
+function reserveClientGeneration(client, directory) {
+  if (!client || typeof client !== "object") return () => true
+  let generations = clientGenerations.get(client)
+  if (!generations) {
+    generations = new Map()
+    clientGenerations.set(client, generations)
+  }
+  const key = String(directory || "")
+  const generation = (generations.get(key) || 0) + 1
+  generations.set(key, generation)
+  return () => generations.get(key) === generation
+}
+
+function scopedClient(client) {
+  if (!client || typeof client !== "object") return client
+  return new Proxy(client, {
+    get(target, property) {
+      const value = Reflect.get(target, property, target)
+      return typeof value === "function" ? value.bind(target) : value
+    },
+  })
+}
+
+function scheduleLegacyCleanup(dispose, isCurrentGeneration) {
+  for (const delay of [0, 25, 100, 500, 2_000, 10_000, 30_000]) {
+    const timer = setTimeout(() => {
+      if (!isCurrentGeneration()) return
+      Promise.resolve(dispose()).catch(() => {})
+    }, delay)
+    timer.unref?.()
+  }
+}
+
+export const OpenCodeLoopPlugin = async (input = {}) => {
+  const realClient = input?.client
+  const isCurrentGeneration = reserveClientGeneration(realClient, input?.directory)
+  const client = scopedClient(realClient)
+  const hooks = await LegacyOpenCodeLoopPlugin({ ...input, client })
+  const legacyDispose = typeof hooks?.dispose === "function" ? hooks.dispose.bind(hooks) : undefined
+  if (!legacyDispose) return hooks
+
+  const runtimeManager = createSessionRuntimeManager()
+  const legacyEvent = typeof hooks?.event === "function" ? hooks.event.bind(hooks) : undefined
+  let disposed = false
+  return {
+    ...hooks,
+    ...(legacyEvent ? {
+      event: async (payload) => {
+        observeRuntimeEvent(runtimeManager, payload)
+        return await legacyEvent(payload)
+      },
+    } : {}),
+    dispose: async () => {
+      if (disposed) return
+      disposed = true
+      try { runtimeManager.dispose("plugin-disposed") } catch {}
+      await legacyDispose()
+      scheduleLegacyCleanup(legacyDispose, isCurrentGeneration)
+    },
+  }
+}
+
+export default OpenCodeLoopPlugin