fix(opencode): reset caches and emit hot reload event

Author: benjaminshafii

packages/opencode/src/agent/agent.ts

@@ -253,6 +253,10 @@ export namespace Agent {
     return state().then((x) => x[agent])
   }
 
+  export async function reset() {
+    await state.reset()
+  }
+
   export async function list() {
     const cfg = await Config.get()
     return pipe(

packages/opencode/src/command/index.ts

@@ -144,6 +144,10 @@ export namespace Command {
     return state().then((x) => x[name])
   }
 
+  export async function reset() {
+    await state.reset()
+  }
+
   export async function list() {
     return state().then((x) => Object.values(x))
   }

packages/opencode/src/config/config.ts

@@ -1361,6 +1361,10 @@ export namespace Config {
     return state().then((x) => x.config)
   }
 
+  export async function reset() {
+    await state.reset()
+  }
+
   export async function getGlobal() {
     return global()
   }

packages/opencode/src/project/hotreload.ts

@@ -1,13 +1,30 @@
 import path from "path"
 import { Bus } from "@/bus"
+import { BusEvent } from "@/bus/bus-event"
+import { Agent } from "@/agent/agent"
+import { Command } from "@/command"
+import { Config } from "@/config/config"
 import { FileWatcher } from "@/file/watcher"
 import { Flag } from "@/flag/flag"
+import { SessionStatus } from "@/session/status"
+import { Skill } from "@/skill"
 import { Log } from "@/util/log"
 import { Instance } from "./instance"
+import z from "zod"
 
 export namespace HotReload {
   const log = Log.create({ service: "project.hotreload" })
 
+  export const Event = {
+    Applied: BusEvent.define(
+      "opencode.hotreload.applied",
+      z.object({
+        file: z.string(),
+        event: z.enum(["add", "change", "unlink"]),
+      }),
+    ),
+  }
+
   const watched = new Set([
     "agent",
     "agents",
@@ -99,45 +116,80 @@ export namespace HotReload {
       let timer: ReturnType<typeof setTimeout> | undefined
       let busy = false
       let last = 0
+      let queued = false
       let latest:
         | {
             file: string
             event: "add" | "change" | "unlink"
           }
         | undefined
 
-      const flush = () => {
+      const active = () =>
+        Object.values(SessionStatus.list()).filter((status) => status.type === "busy" || status.type === "retry").length
+
+      const reload = async () => {
+        await Config.reset()
+        await Skill.reset()
+        await Agent.reset()
+        await Command.reset()
+      }
+
+      const flush = (reason: "timer" | "session") => {
         timer = undefined
         if (busy) return
 
+        const hit = latest
+        if (!hit) return
+
+        const sessions = active()
+        if (sessions > 0) {
+          if (!queued) {
+            log.info("hot reload queued", {
+              file: hit.file,
+              event: hit.event,
+              sessions,
+            })
+          }
+          queued = true
+          return
+        }
+
         const now = Date.now()
         const wait = cooldown - (now - last)
         if (wait > 0) {
-          timer = setTimeout(flush, wait)
+          timer = setTimeout(() => flush(reason), wait)
           return
         }
 
-        const hit = latest
-        if (!hit) return
-
         busy = true
+        queued = false
+        latest = undefined
         last = now
-        log.info("hot reload triggered", { file: hit.file, event: hit.event })
-        void Instance.dispose()
+        log.info("hot reload triggered", { file: hit.file, event: hit.event, reason })
+        void reload()
+          .then(() =>
+            Bus.publish(Event.Applied, {
+              file: hit.file,
+              event: hit.event,
+            }),
+          )
           .catch((error) => {
             log.error("hot reload failed", { error, file: hit.file, event: hit.event })
           })
           .finally(() => {
             busy = false
+            if (!latest) return
+            if (timer) clearTimeout(timer)
+            timer = setTimeout(() => flush("timer"), debounce)
           })
       }
 
       const schedule = () => {
         if (timer) clearTimeout(timer)
-        timer = setTimeout(flush, debounce)
+        timer = setTimeout(() => flush("timer"), debounce)
       }
 
-      const unsub = Bus.subscribe(FileWatcher.Event.Updated, (event) => {
+      const unsubFile = Bus.subscribe(FileWatcher.Event.Updated, (event) => {
         const rel = classify(Instance.directory, event.properties.file)
         if (!rel) return
         latest = {
@@ -147,9 +199,16 @@ export namespace HotReload {
         schedule()
       })
 
+      const unsubSession = Bus.subscribe(SessionStatus.Event.Status, () => {
+        if (!queued) return
+        if (timer) return
+        timer = setTimeout(() => flush("session"), 0)
+      })
+
       log.info("hot reload enabled", { debounce, cooldown })
       return {
-        unsub,
+        unsubFile,
+        unsubSession,
         clear() {
           if (!timer) return
           clearTimeout(timer)
@@ -158,7 +217,8 @@ export namespace HotReload {
       }
     },
     async (entry) => {
-      entry.unsub?.()
+      entry.unsubFile?.()
+      entry.unsubSession?.()
       entry.clear?.()
     },
   )

packages/opencode/src/project/instance.ts

@@ -63,7 +63,7 @@ export const Instance = {
     if (Instance.worktree === "/") return false
     return Filesystem.contains(Instance.worktree, filepath)
   },
-  state<S>(init: () => S, dispose?: (state: Awaited<S>) => Promise<void>): () => S {
+  state<S>(init: () => S, dispose?: (state: Awaited<S>) => Promise<void>): State.Accessor<S> {
     return State.create(() => Instance.directory, init, dispose)
   },
   async dispose() {

packages/opencode/src/project/state.ts

@@ -1,6 +1,10 @@
 import { Log } from "@/util/log"
 
 export namespace State {
+  export type Accessor<S> = (() => S) & {
+    reset: () => Promise<void>
+  }
+
   interface Entry {
     state: any
     dispose?: (state: any) => Promise<void>
@@ -9,8 +13,8 @@ export namespace State {
   const log = Log.create({ service: "state" })
   const recordsByKey = new Map<string, Map<any, Entry>>()
 
-  export function create<S>(root: () => string, init: () => S, dispose?: (state: Awaited<S>) => Promise<void>) {
-    return () => {
+  export function create<S>(root: () => string, init: () => S, dispose?: (state: Awaited<S>) => Promise<void>): Accessor<S> {
+    const fn = (() => {
       const key = root()
       let entries = recordsByKey.get(key)
       if (!entries) {
@@ -25,7 +29,32 @@ export namespace State {
         dispose,
       })
       return state
+    }) as Accessor<S>
+
+    fn.reset = async () => {
+      await disposeInit(root(), init)
     }
+
+    return fn
+  }
+
+  async function disposeInit(key: string, init: any) {
+    const entries = recordsByKey.get(key)
+    if (!entries) return
+    const entry = entries.get(init)
+    if (!entry) return
+
+    if (entry.dispose) {
+      await Promise.resolve(entry.state)
+        .then((state) => entry.dispose!(state))
+        .catch((error) => {
+          const label = typeof init === "function" ? init.name : String(init)
+          log.error("Error while disposing state:", { error, key, init: label })
+        })
+    }
+
+    entries.delete(init)
+    if (!entries.size) recordsByKey.delete(key)
   }
 
   export async function dispose(key: string) {

packages/opencode/src/skill/skill.ts

@@ -178,6 +178,10 @@ export namespace Skill {
     return state().then((x) => x.skills[name])
   }
 
+  export async function reset() {
+    await state.reset()
+  }
+
   export async function all() {
     return state().then((x) => Object.values(x.skills))
   }