Merge branch 'dev' into kit/effectify-plugin

Replace the legacy Instance.state() lazy-init pattern with the standard
Effect service pattern (Interface, Service class, Layer, promise facades).
Register Plugin.Service in InstanceServices and add its layer to the
instance lookup.

packages/opencode/specs/effect-migration.md

@@ -123,11 +123,10 @@ Done now:
 - [x] `Discovery`
 - [x] `File`
 - [x] `Snapshot`
-- [x] `SessionStatus`
 
 Still open and likely worth migrating:
 
-- [ ] `Plugin`
+- [x] `Plugin`
 - [ ] `ToolRegistry`
 - [ ] `Pty`
 - [ ] `Worktree`

packages/opencode/src/bus/bus-event.ts

@@ -1,5 +1,5 @@
 import z from "zod"
-import type { ZodType } from "zod"
+import type { ZodObject, ZodRawShape } from "zod"
 import { Log } from "../util/log"
 
 export namespace BusEvent {
@@ -9,7 +9,7 @@ export namespace BusEvent {
 
   const registry = new Map<string, Definition>()
 
-  export function define<Type extends string, Properties extends ZodType>(type: Type, properties: Properties) {
+  export function define<Type extends string, Properties extends ZodObject<ZodRawShape>>(type: Type, properties: Properties) {
     const result = {
       type,
       properties,

packages/opencode/src/bus/global.ts

@@ -4,7 +4,7 @@ export const GlobalBus = new EventEmitter<{
   event: [
     {
       directory?: string
-      payload: any
+      payload: { type: string; properties: Record<string, unknown> }
     },
   ]
 }>()

packages/opencode/src/control-plane/workspace.ts

@@ -124,7 +124,7 @@ export namespace Workspace {
       await parseSSE(res.body, stop, (event) => {
         GlobalBus.emit("event", {
           directory: space.id,
-          payload: event,
+          payload: event as { type: string; properties: Record<string, unknown> },
         })
       })
       // Wait 250ms and retry if SSE connection fails

packages/opencode/src/effect/instances.ts

@@ -8,9 +8,9 @@ import { Instance } from "@/project/instance"
 import { Vcs } from "@/project/vcs"
 import { ProviderAuth } from "@/provider/auth-service"
 import { Question } from "@/question/service"
-import { SessionStatus } from "@/session/status"
 import { Skill } from "@/skill/service"
 import { Snapshot } from "@/snapshot/service"
+import { Plugin } from "@/plugin"
 import { InstanceContext } from "./instance-context"
 import { registerDisposer } from "./instance-registry"
 
@@ -25,9 +25,9 @@ export type InstanceServices =
   | FileTime.Service
   | Format.Service
   | File.Service
-  | SessionStatus.Service
   | Skill.Service
   | Snapshot.Service
+  | Plugin.Service
 
 // NOTE: LayerMap only passes the key (directory string) to lookup, but we need
 // the full instance context (directory, worktree, project). We read from the
@@ -46,9 +46,9 @@ function lookup(_key: string) {
     FileTime.layer,
     Format.layer,
     File.layer,
-    SessionStatus.layer,
     Skill.defaultLayer,
     Snapshot.defaultLayer,
+    Plugin.layer,
   ).pipe(Layer.provide(ctx))
 }
 

packages/opencode/src/effect/runtime.ts

@@ -20,10 +20,6 @@ export function runPromiseInstance<A, E>(effect: Effect.Effect<A, E, InstanceSer
   return runtime.runPromise(effect.pipe(Effect.provide(Instances.get(Instance.directory))))
 }
 
-export function runSyncInstance<A, E>(effect: Effect.Effect<A, E, InstanceServices>) {
-  return runtime.runSync(effect.pipe(Effect.provide(Instances.get(Instance.directory))))
-}
-
 export function disposeRuntime() {
   return runtime.dispose()
 }

packages/opencode/src/plugin/index.ts

@@ -1,144 +1,206 @@
 import type { Hooks, PluginInput, Plugin as PluginInstance } from "@opencode-ai/plugin"
-import { Config } from "../config/config"
 import { Bus } from "../bus"
 import { Log } from "../util/log"
 import { createOpencodeClient } from "@opencode-ai/sdk"
-import { Server } from "../server/server"
 import { BunProc } from "../bun"
-import { Instance } from "../project/instance"
 import { Flag } from "../flag/flag"
-import { CodexAuthPlugin } from "./codex"
-import { Session } from "../session"
 import { NamedError } from "@opencode-ai/util/error"
-import { CopilotAuthPlugin } from "./copilot"
-import { gitlabAuthPlugin as GitlabAuthPlugin } from "opencode-gitlab-auth"
+import { Effect, Layer, ServiceMap } from "effect"
+import { InstanceContext } from "@/effect/instance-context"
 
 export namespace Plugin {
   const log = Log.create({ service: "plugin" })
 
-  // Built-in plugins that are directly imported (not installed from npm)
-  const INTERNAL_PLUGINS: PluginInstance[] = [CodexAuthPlugin, CopilotAuthPlugin, GitlabAuthPlugin]
+  export interface Interface {
+    readonly trigger: <
+      Name extends Exclude<keyof Required<Hooks>, "auth" | "event" | "tool">,
+      Input = Parameters<Required<Hooks>[Name]>[0],
+      Output = Parameters<Required<Hooks>[Name]>[1],
+    >(
+      name: Name,
+      input: Input,
+      output: Output,
+    ) => Effect.Effect<Output>
+    readonly list: () => Effect.Effect<Hooks[]>
+    readonly init: () => Effect.Effect<void>
+  }
 
-  const state = Instance.state(async () => {
-    const client = createOpencodeClient({
-      baseUrl: "http://localhost:4096",
-      directory: Instance.directory,
-      headers: Flag.OPENCODE_SERVER_PASSWORD
-        ? {
-            Authorization: `Basic ${Buffer.from(`${Flag.OPENCODE_SERVER_USERNAME ?? "opencode"}:${Flag.OPENCODE_SERVER_PASSWORD}`).toString("base64")}`,
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Plugin") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const instance = yield* InstanceContext
+      const hooks: Hooks[] = []
+      let task: Promise<void> | undefined
+
+      const load = Effect.fn("Plugin.load")(function* () {
+        yield* Effect.promise(async () => {
+          const [{ Config }, { Server }, codex, copilot, gitlab] = await Promise.all([
+            import("../config/config"),
+            import("../server/server"),
+            import("./codex"),
+            import("./copilot"),
+            import("opencode-gitlab-auth"),
+          ])
+          const internal: PluginInstance[] = [codex.CodexAuthPlugin, copilot.CopilotAuthPlugin, gitlab.gitlabAuthPlugin]
+          const client = createOpencodeClient({
+            baseUrl: "http://localhost:4096",
+            directory: instance.directory,
+            headers: Flag.OPENCODE_SERVER_PASSWORD
+              ? {
+                  Authorization: `Basic ${Buffer.from(`${Flag.OPENCODE_SERVER_USERNAME ?? "opencode"}:${Flag.OPENCODE_SERVER_PASSWORD}`).toString("base64")}`,
+                }
+              : undefined,
+            fetch: async (...args) => Server.Default().fetch(...args),
+          })
+          const config = await Config.get()
+          const input: PluginInput = {
+            client,
+            project: instance.project,
+            worktree: instance.worktree,
+            directory: instance.directory,
+            get serverUrl(): URL {
+              return Server.url ?? new URL("http://localhost:4096")
+            },
+            $: Bun.$,
           }
-        : undefined,
-      fetch: async (...args) => Server.Default().fetch(...args),
-    })
-    const config = await Config.get()
-    const hooks: Hooks[] = []
-    const input: PluginInput = {
-      client,
-      project: Instance.project,
-      worktree: Instance.worktree,
-      directory: Instance.directory,
-      get serverUrl(): URL {
-        return Server.url ?? new URL("http://localhost:4096")
-      },
-      $: Bun.$,
-    }
 
-    for (const plugin of INTERNAL_PLUGINS) {
-      log.info("loading internal plugin", { name: plugin.name })
-      const init = await plugin(input).catch((err) => {
-        log.error("failed to load internal plugin", { name: plugin.name, error: err })
+          for (const plugin of internal) {
+            log.info("loading internal plugin", { name: plugin.name })
+            const init = await plugin(input).catch((err) => {
+              log.error("failed to load internal plugin", { name: plugin.name, error: err })
+            })
+            if (init) hooks.push(init)
+          }
+
+          let plugins = config.plugin ?? []
+          if (plugins.length) await Config.waitForDependencies()
+
+          for (let plugin of plugins) {
+            // ignore old codex plugin since it is supported first party now
+            if (plugin.includes("opencode-openai-codex-auth") || plugin.includes("opencode-copilot-auth")) continue
+            log.info("loading plugin", { path: plugin })
+            if (!plugin.startsWith("file://")) {
+              const lastAtIndex = plugin.lastIndexOf("@")
+              const pkg = lastAtIndex > 0 ? plugin.substring(0, lastAtIndex) : plugin
+              const version = lastAtIndex > 0 ? plugin.substring(lastAtIndex + 1) : "latest"
+              plugin = await BunProc.install(pkg, version).catch((err) => {
+                const cause = err instanceof Error ? err.cause : err
+                const detail = cause instanceof Error ? cause.message : String(cause ?? err)
+                log.error("failed to install plugin", { pkg, version, error: detail })
+                void import("../session").then(({ Session }) =>
+                  Bus.publish(Session.Event.Error, {
+                    error: new NamedError.Unknown({
+                      message: `Failed to install plugin ${pkg}@${version}: ${detail}`,
+                    }).toObject(),
+                  }),
+                )
+                return ""
+              })
+              if (!plugin) continue
+            }
+            // Prevent duplicate initialization when plugins export the same function
+            // as both a named export and default export (e.g., `export const X` and `export default X`).
+            // Object.entries(mod) would return both entries pointing to the same function reference.
+            await import(plugin)
+              .then(async (mod) => {
+                const seen = new Set<PluginInstance>()
+                for (const [_name, fn] of Object.entries<PluginInstance>(mod)) {
+                  if (seen.has(fn)) continue
+                  seen.add(fn)
+                  hooks.push(await fn(input))
+                }
+              })
+              .catch((err) => {
+                const message = err instanceof Error ? err.message : String(err)
+                log.error("failed to load plugin", { path: plugin, error: message })
+                void import("../session").then(({ Session }) =>
+                  Bus.publish(Session.Event.Error, {
+                    error: new NamedError.Unknown({
+                      message: `Failed to load plugin ${plugin}: ${message}`,
+                    }).toObject(),
+                  }),
+                )
+              })
+          }
+        })
       })
-      if (init) hooks.push(init)
-    }
 
-    let plugins = config.plugin ?? []
-    if (plugins.length) await Config.waitForDependencies()
-
-    for (let plugin of plugins) {
-      // ignore old codex plugin since it is supported first party now
-      if (plugin.includes("opencode-openai-codex-auth") || plugin.includes("opencode-copilot-auth")) continue
-      log.info("loading plugin", { path: plugin })
-      if (!plugin.startsWith("file://")) {
-        const lastAtIndex = plugin.lastIndexOf("@")
-        const pkg = lastAtIndex > 0 ? plugin.substring(0, lastAtIndex) : plugin
-        const version = lastAtIndex > 0 ? plugin.substring(lastAtIndex + 1) : "latest"
-        plugin = await BunProc.install(pkg, version).catch((err) => {
-          const cause = err instanceof Error ? err.cause : err
-          const detail = cause instanceof Error ? cause.message : String(cause ?? err)
-          log.error("failed to install plugin", { pkg, version, error: detail })
-          Bus.publish(Session.Event.Error, {
-            error: new NamedError.Unknown({
-              message: `Failed to install plugin ${pkg}@${version}: ${detail}`,
-            }).toObject(),
-          })
-          return ""
+      const ensure = Effect.fn("Plugin.ensure")(function* () {
+        yield* Effect.promise(() => {
+          task ??= Effect.runPromise(
+            load().pipe(Effect.catchCause((cause) => Effect.sync(() => log.error("init failed", { cause })))),
+          )
+          return task
         })
-        if (!plugin) continue
-      }
-      // Prevent duplicate initialization when plugins export the same function
-      // as both a named export and default export (e.g., `export const X` and `export default X`).
-      // Object.entries(mod) would return both entries pointing to the same function reference.
-      await import(plugin)
-        .then(async (mod) => {
-          const seen = new Set<PluginInstance>()
-          for (const [_name, fn] of Object.entries<PluginInstance>(mod)) {
-            if (seen.has(fn)) continue
-            seen.add(fn)
-            hooks.push(await fn(input))
+      })
+
+      const trigger = Effect.fn("Plugin.trigger")(function* <
+        Name extends Exclude<keyof Required<Hooks>, "auth" | "event" | "tool">,
+        Input = Parameters<Required<Hooks>[Name]>[0],
+        Output = Parameters<Required<Hooks>[Name]>[1],
+      >(name: Name, input: Input, output: Output) {
+        if (!name) return output
+        yield* ensure()
+        yield* Effect.promise(async () => {
+          for (const hook of hooks) {
+            const fn = hook[name]
+            if (!fn) continue
+            // @ts-expect-error if you feel adventurous, please fix the typing, make sure to bump the try-counter if you
+            // give up.
+            // try-counter: 2
+            await fn(input, output)
           }
         })
-        .catch((err) => {
-          const message = err instanceof Error ? err.message : String(err)
-          log.error("failed to load plugin", { path: plugin, error: message })
-          Bus.publish(Session.Event.Error, {
-            error: new NamedError.Unknown({
-              message: `Failed to load plugin ${plugin}: ${message}`,
-            }).toObject(),
+        return output
+      })
+
+      const list = Effect.fn("Plugin.list")(function* () {
+        yield* ensure()
+        return hooks
+      })
+
+      const init = Effect.fn("Plugin.init")(function* () {
+        yield* ensure()
+        yield* Effect.promise(async () => {
+          const { Config } = await import("../config/config")
+          const config = await Config.get()
+          for (const hook of hooks) {
+            await (hook as any).config?.(config)
+          }
+          Bus.subscribeAll(async (input) => {
+            for (const hook of hooks) {
+              hook["event"]?.({
+                event: input,
+              })
+            }
           })
         })
-    }
+      })
 
-    return {
-      hooks,
-      input,
-    }
-  })
+      return Service.of({ trigger, list, init })
+    }),
+  ).pipe(Layer.fresh)
+
+  async function run<A, E>(effect: Effect.Effect<A, E, Service>) {
+    const { runPromiseInstance } = await import("@/effect/runtime")
+    return runPromiseInstance(effect)
+  }
 
   export async function trigger<
     Name extends Exclude<keyof Required<Hooks>, "auth" | "event" | "tool">,
     Input = Parameters<Required<Hooks>[Name]>[0],
     Output = Parameters<Required<Hooks>[Name]>[1],
   >(name: Name, input: Input, output: Output): Promise<Output> {
-    if (!name) return output
-    for (const hook of await state().then((x) => x.hooks)) {
-      const fn = hook[name]
-      if (!fn) continue
-      // @ts-expect-error if you feel adventurous, please fix the typing, make sure to bump the try-counter if you
-      // give up.
-      // try-counter: 2
-      await fn(input, output)
-    }
-    return output
+    return run(Service.use((svc) => svc.trigger(name, input, output)))
   }
 
-  export async function list() {
-    return state().then((x) => x.hooks)
+  export async function list(): Promise<Hooks[]> {
+    return run(Service.use((svc) => svc.list()))
   }
 
   export async function init() {
-    const hooks = await state().then((x) => x.hooks)
-    const config = await Config.get()
-    for (const hook of hooks) {
-      // @ts-expect-error this is because we haven't moved plugin to sdk v2
-      await hook.config?.(config)
-    }
-    Bus.subscribeAll(async (input) => {
-      const hooks = await state().then((x) => x.hooks)
-      for (const hook of hooks) {
-        hook["event"]?.({
-          event: input,
-        })
-      }
-    })
+    return run(Service.use((svc) => svc.init()))
   }
 }

packages/opencode/src/provider/auth-service.ts

@@ -1,4 +1,4 @@
-import type { AuthOuathResult } from "@opencode-ai/plugin"
+import type { AuthOuathResult, Hooks } from "@opencode-ai/plugin"
 import { NamedError } from "@opencode-ai/util/error"
 import * as Auth from "@/auth/effect"
 import { ProviderID } from "./schema"
@@ -6,6 +6,8 @@ import { Array as Arr, Effect, Layer, Record, Result, ServiceMap, Struct } from
 import z from "zod"
 
 export namespace ProviderAuth {
+  type Hook = NonNullable<Hooks["auth"]>
+
   export const Method = z
     .object({
       type: z.union([z.literal("oauth"), z.literal("api")]),
@@ -105,20 +107,26 @@ export namespace ProviderAuth {
     Service,
     Effect.gen(function* () {
       const auth = yield* Auth.Auth.Service
-      const hooks = yield* Effect.promise(async () => {
-        const mod = await import("../plugin")
-        const plugins = await mod.Plugin.list()
-        return Record.fromEntries(
-          Arr.filterMap(plugins, (x) =>
-            x.auth?.provider !== undefined
-              ? Result.succeed([ProviderID.make(x.auth.provider), x.auth] as const)
-              : Result.failVoid,
-          ),
-        )
-      })
+      let hooks: Record<ProviderID, Hook> | undefined
       const pending = new Map<ProviderID, AuthOuathResult>()
 
+      const load = Effect.fn("ProviderAuth.load")(function* () {
+        if (hooks) return hooks
+        hooks = yield* Effect.promise(async () => {
+          const mod = await import("../plugin")
+          const plugins = await mod.Plugin.list()
+          const result = {} as Record<ProviderID, Hook>
+          for (const item of plugins) {
+            if (item.auth?.provider === undefined) continue
+            result[ProviderID.make(item.auth.provider)] = item.auth
+          }
+          return result
+        })
+        return hooks
+      })
+
       const methods = Effect.fn("ProviderAuth.methods")(function* () {
+        const hooks = yield* load()
         return Record.map(hooks, (item) =>
           item.methods.map(
             (method): Method => ({
@@ -152,6 +160,7 @@ export namespace ProviderAuth {
         method: number
         inputs?: Record<string, string>
       }) {
+        const hooks = yield* load()
         const method = hooks[input.providerID].methods[input.method]
         if (method.type !== "oauth") return
 
@@ -178,6 +187,7 @@ export namespace ProviderAuth {
         method: number
         code?: string
       }) {
+        yield* load()
         const match = pending.get(input.providerID)
         if (!match) return yield* Effect.fail(new OauthMissing({ providerID: input.providerID }))
         if (match.method === "code" && !input.code) {

packages/opencode/src/session/status.ts

@@ -1,8 +1,7 @@
 import { BusEvent } from "@/bus/bus-event"
 import { Bus } from "@/bus"
-import { runSyncInstance } from "@/effect/runtime"
+import { Instance } from "@/project/instance"
 import { SessionID } from "./schema"
-import { Effect, Layer, ServiceMap } from "effect"
 import z from "zod"
 
 export namespace SessionStatus {
@@ -43,51 +42,36 @@ export namespace SessionStatus {
     ),
   }
 
-  export interface Interface {
-    readonly get: (sessionID: SessionID) => Effect.Effect<Info>
-    readonly list: () => Effect.Effect<Record<string, Info>>
-    readonly set: (sessionID: SessionID, status: Info) => Effect.Effect<void>
+  const state = Instance.state(() => {
+    const data: Record<string, Info> = {}
+    return data
+  })
+
+  export function get(sessionID: SessionID) {
+    return (
+      state()[sessionID] ?? {
+        type: "idle",
+      }
+    )
   }
 
-  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/SessionStatus") {}
-
-  export const layer = Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const data = new Map<SessionID, Info>()
-
-      const get = Effect.fn("SessionStatus.get")(function* (sessionID: SessionID) {
-        return data.get(sessionID) ?? { type: "idle" as const }
-      })
-
-      const list = Effect.fn("SessionStatus.list")(function* () {
-        return Object.fromEntries(data)
-      })
-
-      const set = Effect.fn("SessionStatus.set")(function* (sessionID: SessionID, status: Info) {
-        Bus.publish(Event.Status, { sessionID, status })
-        if (status.type === "idle") {
-          // deprecated
-          Bus.publish(Event.Idle, { sessionID })
-          data.delete(sessionID)
-          return
-        }
-        data.set(sessionID, status)
-      })
-
-      return Service.of({ get, list, set })
-    }),
-  )
-
-  export function get(sessionID: SessionID): Info {
-    return runSyncInstance(Service.use((svc) => svc.get(sessionID)))
-  }
-
-  export function list(): Record<string, Info> {
-    return runSyncInstance(Service.use((svc) => svc.list()))
+  export function list() {
+    return state()
   }
 
   export function set(sessionID: SessionID, status: Info) {
-    runSyncInstance(Service.use((svc) => svc.set(sessionID, status)))
+    Bus.publish(Event.Status, {
+      sessionID,
+      status,
+    })
+    if (status.type === "idle") {
+      // deprecated
+      Bus.publish(Event.Idle, {
+        sessionID,
+      })
+      delete state()[sessionID]
+      return
+    }
+    state()[sessionID] = status
   }
 }

packages/opencode/test/file/watcher.test.ts

@@ -16,7 +16,7 @@ const describeWatcher = FileWatcher.hasNativeBinding() && !process.env.CI ? desc
 // Helpers
 // ---------------------------------------------------------------------------
 
-type BusUpdate = { directory?: string; payload: { type: string; properties: WatcherEvent } }
+type BusUpdate = { directory?: string; payload: { type: string; properties: Record<string, unknown> } }
 type WatcherEvent = { file: string; event: "add" | "change" | "unlink" }
 
 /** Run `body` with a live FileWatcher service. */
@@ -40,18 +40,18 @@ function listen(directory: string, check: (evt: WatcherEvent) => boolean, hit: (
     if (done) return
     if (evt.directory !== directory) return
     if (evt.payload.type !== FileWatcher.Event.Updated.type) return
-    if (!check(evt.payload.properties)) return
-    hit(evt.payload.properties)
+    const props = evt.payload.properties as WatcherEvent
+    if (!check(props)) return
+    hit(props)
   }
 
-  function cleanup() {
+  GlobalBus.on("event", on)
+
+  return () => {
     if (done) return
     done = true
     GlobalBus.off("event", on)
   }
-
-  GlobalBus.on("event", on)
-  return cleanup
 }
 
 function wait(directory: string, check: (evt: WatcherEvent) => boolean) {