feat: update config api

Author: neriousy

packages/opencode/src/config/config.ts

@@ -14,6 +14,8 @@ import { Flag } from "../flag/flag"
 import { Auth } from "../auth"
 import { type ParseError as JsoncParseError, parse as parseJsonc, printParseErrorCode } from "jsonc-parser"
 import { Instance } from "../project/instance"
+import { Bus } from "../bus"
+import { State } from "../project/state"
 
 export namespace Config {
   const log = Log.create({ service: "config" })
@@ -673,4 +675,59 @@ export namespace Config {
   export async function directories() {
     return state().then((x) => x.directories)
   }
+
+  export type ConfigScope = "global" | "project"
+
+  export async function update(scope: ConfigScope, updates: Partial<Info>) {
+    const validated = Info.partial().parse(updates)
+
+    const targetPath =
+      scope === "global"
+        ? path.join(Global.Path.config, "opencode.json")
+        : path.join(Instance.directory, "opencode.json")
+
+    log.info("updating config", { scope, path: targetPath })
+
+    let existing: Info = {}
+    try {
+      const content = await Bun.file(targetPath).text()
+      const errors: JsoncParseError[] = []
+      existing = parseJsonc(content, errors, { allowTrailingComma: true }) || {}
+    } catch (err) {
+      if ((err as any).code !== "ENOENT") {
+        throw new JsonError({ path: targetPath, message: "Failed to read existing config" }, { cause: err })
+      }
+    }
+
+    const merged = mergeDeep(existing, validated)
+
+    if (!merged.$schema) {
+      merged.$schema = "https://opencode.ai/config.json"
+    }
+
+    await Bun.write(targetPath, JSON.stringify(merged, null, 2))
+
+    const reloaded = await reload()
+
+    log.info("config updated", { scope })
+    return reloaded
+  }
+
+  export async function reload() {
+    log.info("reloading config")
+
+    global.clear()
+
+    await State.dispose(Instance.directory)
+
+    const reloaded = await get()
+
+    Bus.publish(Event.Reloaded, { config: reloaded })
+
+    return reloaded
+  }
+
+  export const Event = {
+    Reloaded: Bus.event("config.reloaded", z.object({ config: Info })),
+  }
 }

packages/opencode/src/project/state.ts

@@ -26,9 +26,14 @@ export namespace State {
   }
 
   export async function dispose(key: string) {
-    for (const [_, entry] of entries.get(key)?.entries() ?? []) {
+    const collection = entries.get(key)
+    if (!collection) return
+
+    for (const [_, entry] of collection.entries()) {
       if (!entry.dispose) continue
       await entry.dispose(await entry.state)
     }
+
+    entries.delete(key)
   }
 }

packages/opencode/src/server/server.ts

@@ -135,6 +135,36 @@ export namespace Server {
           return c.json(await Config.get())
         },
       )
+      .patch(
+        "/config",
+        describeRoute({
+          description: "Update configuration",
+          operationId: "config.update",
+          responses: {
+            200: {
+              description: "Updated config",
+              content: {
+                "application/json": {
+                  schema: resolver(Config.Info),
+                },
+              },
+            },
+            ...ERRORS,
+          },
+        }),
+        validator(
+          "json",
+          z.object({
+            scope: z.enum(["global", "project"]).describe("Scope of config to update"),
+            updates: Config.Info.partial().describe("Partial config updates to apply"),
+          }),
+        ),
+        async (c) => {
+          const { scope, updates } = c.req.valid("json")
+          const updated = await Config.update(scope, updates)
+          return c.json(updated)
+        },
+      )
       .get(
         "/experimental/tool/ids",
         describeRoute({

packages/opencode/src/util/lazy.ts

@@ -2,10 +2,17 @@ export function lazy<T>(fn: () => T) {
   let value: T | undefined
   let loaded = false
 
-  return (): T => {
+  const result = (): T => {
     if (loaded) return value as T
     loaded = true
     value = fn()
     return value as T
   }
+
+  result.clear = () => {
+    loaded = false
+    value = undefined
+  }
+
+  return result
 }