Merge branch 'dev' into kit/effectify-lsp

Replace the legacy Instance.state() pattern in LSP with Interface,
Service, layer, and async facades using runPromiseInstance. Wire
LSP.Service into InstanceServices and add runSyncInstance helper.

packages/opencode/specs/effect-migration.md

@@ -126,7 +126,7 @@ Done now:
 
 Still open and likely worth migrating:
 
-- [x] `Plugin`
+- [ ] `Plugin`
 - [ ] `ToolRegistry`
 - [ ] `Pty`
 - [ ] `Worktree`
@@ -140,5 +140,5 @@ Still open and likely worth migrating:
 - [ ] `SessionCompaction`
 - [ ] `Provider`
 - [ ] `Project`
-- [ ] `LSP`
+- [x] `LSP`
 - [ ] `MCP`

packages/opencode/src/account/repo.ts

@@ -136,8 +136,6 @@ export class AccountRepo extends ServiceMap.Service<AccountRepo, AccountRepo.Ser
             .onConflictDoUpdate({
               target: AccountTable.id,
               set: {
-                email: input.email,
-                url: input.url,
                 access_token: input.accessToken,
                 refresh_token: input.refreshToken,
                 token_expiry: input.expiry,

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

@@ -1,5 +1,5 @@
 import z from "zod"
-import type { ZodObject, ZodRawShape } from "zod"
+import type { ZodType } 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 ZodObject<ZodRawShape>>(type: Type, properties: Properties) {
+  export function define<Type extends string, Properties extends ZodType>(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: { type: string; properties: Record<string, unknown> }
+      payload: any
     },
   ]
 }>()

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 as { type: string; properties: Record<string, unknown> },
+          payload: event,
         })
       })
       // Wait 250ms and retry if SSE connection fails

packages/opencode/src/effect/instances.ts

@@ -3,6 +3,7 @@ import { File } from "@/file/service"
 import { FileTime } from "@/file/time-service"
 import { FileWatcher } from "@/file/watcher"
 import { Format } from "@/format/service"
+import { LSP } from "@/lsp"
 import { Permission } from "@/permission/service"
 import { Instance } from "@/project/instance"
 import { Vcs } from "@/project/vcs"
@@ -10,7 +11,6 @@ import { ProviderAuth } from "@/provider/auth-service"
 import { Question } from "@/question/service"
 import { Skill } from "@/skill/service"
 import { Snapshot } from "@/snapshot/service"
-import { Plugin } from "@/plugin"
 import { InstanceContext } from "./instance-context"
 import { registerDisposer } from "./instance-registry"
 
@@ -27,7 +27,7 @@ export type InstanceServices =
   | File.Service
   | Skill.Service
   | Snapshot.Service
-  | Plugin.Service
+  | LSP.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
@@ -48,7 +48,7 @@ function lookup(_key: string) {
     File.layer,
     Skill.defaultLayer,
     Snapshot.defaultLayer,
-    Plugin.layer,
+    LSP.layer,
   ).pipe(Layer.provide(ctx))
 }
 

packages/opencode/src/effect/runtime.ts

@@ -20,6 +20,10 @@ 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/lsp/index.ts

@@ -1,5 +1,7 @@
 import { BusEvent } from "@/bus/bus-event"
 import { Bus } from "@/bus"
+import { InstanceContext } from "@/effect/instance-context"
+import { runPromiseInstance } from "@/effect/runtime"
 import { Log } from "../util/log"
 import { LSPClient } from "./client"
 import path from "path"
@@ -7,10 +9,10 @@ import { pathToFileURL, fileURLToPath } from "url"
 import { LSPServer } from "./server"
 import z from "zod"
 import { Config } from "../config/config"
-import { Instance } from "../project/instance"
 import { Flag } from "@/flag/flag"
 import { Process } from "../util/process"
 import { spawn as lspspawn } from "./launch"
+import { Effect, Fiber, Layer, ServiceMap } from "effect"
 
 export namespace LSP {
   const log = Log.create({ service: "lsp" })
@@ -77,77 +79,6 @@ export namespace LSP {
     }
   }
 
-  const state = Instance.state(
-    async () => {
-      const clients: LSPClient.Info[] = []
-      const servers: Record<string, LSPServer.Info> = {}
-      const cfg = await Config.get()
-
-      if (cfg.lsp === false) {
-        log.info("all LSPs are disabled")
-        return {
-          broken: new Set<string>(),
-          servers,
-          clients,
-          spawning: new Map<string, Promise<LSPClient.Info | undefined>>(),
-        }
-      }
-
-      for (const server of Object.values(LSPServer)) {
-        servers[server.id] = server
-      }
-
-      filterExperimentalServers(servers)
-
-      for (const [name, item] of Object.entries(cfg.lsp ?? {})) {
-        const existing = servers[name]
-        if (item.disabled) {
-          log.info(`LSP server ${name} is disabled`)
-          delete servers[name]
-          continue
-        }
-        servers[name] = {
-          ...existing,
-          id: name,
-          root: existing?.root ?? (async () => Instance.directory),
-          extensions: item.extensions ?? existing?.extensions ?? [],
-          spawn: async (root) => {
-            return {
-              process: lspspawn(item.command[0], item.command.slice(1), {
-                cwd: root,
-                env: {
-                  ...process.env,
-                  ...item.env,
-                },
-              }),
-              initialization: item.initialization,
-            }
-          },
-        }
-      }
-
-      log.info("enabled LSP servers", {
-        serverIds: Object.values(servers)
-          .map((server) => server.id)
-          .join(", "),
-      })
-
-      return {
-        broken: new Set<string>(),
-        servers,
-        clients,
-        spawning: new Map<string, Promise<LSPClient.Info | undefined>>(),
-      }
-    },
-    async (state) => {
-      await Promise.all(state.clients.map((client) => client.shutdown()))
-    },
-  )
-
-  export async function init() {
-    return state()
-  }
-
   export const Status = z
     .object({
       id: z.string(),
@@ -160,162 +91,6 @@ export namespace LSP {
     })
   export type Status = z.infer<typeof Status>
 
-  export async function status() {
-    return state().then((x) => {
-      const result: Status[] = []
-      for (const client of x.clients) {
-        result.push({
-          id: client.serverID,
-          name: x.servers[client.serverID].id,
-          root: path.relative(Instance.directory, client.root),
-          status: "connected",
-        })
-      }
-      return result
-    })
-  }
-
-  async function getClients(file: string) {
-    const s = await state()
-    const extension = path.parse(file).ext || file
-    const result: LSPClient.Info[] = []
-
-    async function schedule(server: LSPServer.Info, root: string, key: string) {
-      const handle = await server
-        .spawn(root)
-        .then((value) => {
-          if (!value) s.broken.add(key)
-          return value
-        })
-        .catch((err) => {
-          s.broken.add(key)
-          log.error(`Failed to spawn LSP server ${server.id}`, { error: err })
-          return undefined
-        })
-
-      if (!handle) return undefined
-      log.info("spawned lsp server", { serverID: server.id })
-
-      const client = await LSPClient.create({
-        serverID: server.id,
-        server: handle,
-        root,
-      }).catch(async (err) => {
-        s.broken.add(key)
-        await Process.stop(handle.process)
-        log.error(`Failed to initialize LSP client ${server.id}`, { error: err })
-        return undefined
-      })
-
-      if (!client) {
-        return undefined
-      }
-
-      const existing = s.clients.find((x) => x.root === root && x.serverID === server.id)
-      if (existing) {
-        await Process.stop(handle.process)
-        return existing
-      }
-
-      s.clients.push(client)
-      return client
-    }
-
-    for (const server of Object.values(s.servers)) {
-      if (server.extensions.length && !server.extensions.includes(extension)) continue
-
-      const root = await server.root(file)
-      if (!root) continue
-      if (s.broken.has(root + server.id)) continue
-
-      const match = s.clients.find((x) => x.root === root && x.serverID === server.id)
-      if (match) {
-        result.push(match)
-        continue
-      }
-
-      const inflight = s.spawning.get(root + server.id)
-      if (inflight) {
-        const client = await inflight
-        if (!client) continue
-        result.push(client)
-        continue
-      }
-
-      const task = schedule(server, root, root + server.id)
-      s.spawning.set(root + server.id, task)
-
-      task.finally(() => {
-        if (s.spawning.get(root + server.id) === task) {
-          s.spawning.delete(root + server.id)
-        }
-      })
-
-      const client = await task
-      if (!client) continue
-
-      result.push(client)
-      Bus.publish(Event.Updated, {})
-    }
-
-    return result
-  }
-
-  export async function hasClients(file: string) {
-    const s = await state()
-    const extension = path.parse(file).ext || file
-    for (const server of Object.values(s.servers)) {
-      if (server.extensions.length && !server.extensions.includes(extension)) continue
-      const root = await server.root(file)
-      if (!root) continue
-      if (s.broken.has(root + server.id)) continue
-      return true
-    }
-    return false
-  }
-
-  export async function touchFile(input: string, waitForDiagnostics?: boolean) {
-    log.info("touching file", { file: input })
-    const clients = await getClients(input)
-    await Promise.all(
-      clients.map(async (client) => {
-        const wait = waitForDiagnostics ? client.waitForDiagnostics({ path: input }) : Promise.resolve()
-        await client.notify.open({ path: input })
-        return wait
-      }),
-    ).catch((err) => {
-      log.error("failed to touch file", { err, file: input })
-    })
-  }
-
-  export async function diagnostics() {
-    const results: Record<string, LSPClient.Diagnostic[]> = {}
-    for (const result of await runAll(async (client) => client.diagnostics)) {
-      for (const [path, diagnostics] of result.entries()) {
-        const arr = results[path] || []
-        arr.push(...diagnostics)
-        results[path] = arr
-      }
-    }
-    return results
-  }
-
-  export async function hover(input: { file: string; line: number; character: number }) {
-    return run(input.file, (client) => {
-      return client.connection
-        .sendRequest("textDocument/hover", {
-          textDocument: {
-            uri: pathToFileURL(input.file).href,
-          },
-          position: {
-            line: input.line,
-            character: input.character,
-          },
-        })
-        .catch(() => null)
-    })
-  }
-
   enum SymbolKind {
     File = 1,
     Module = 2,
@@ -356,114 +131,504 @@ export namespace LSP {
     SymbolKind.Enum,
   ]
 
-  export async function workspaceSymbol(query: string) {
-    return runAll((client) =>
-      client.connection
-        .sendRequest("workspace/symbol", {
-          query,
+  export interface Interface {
+    readonly init: () => Effect.Effect<void>
+    readonly status: () => Effect.Effect<Status[]>
+    readonly hasClients: (file: string) => Effect.Effect<boolean>
+    readonly touchFile: (input: string, waitForDiagnostics?: boolean) => Effect.Effect<void>
+    readonly diagnostics: () => Effect.Effect<Record<string, LSPClient.Diagnostic[]>>
+    readonly hover: (input: { file: string; line: number; character: number }) => Effect.Effect<any>
+    readonly workspaceSymbol: (query: string) => Effect.Effect<LSP.Symbol[]>
+    readonly documentSymbol: (uri: string) => Effect.Effect<(LSP.DocumentSymbol | LSP.Symbol)[]>
+    readonly definition: (input: { file: string; line: number; character: number }) => Effect.Effect<any[]>
+    readonly references: (input: { file: string; line: number; character: number }) => Effect.Effect<any[]>
+    readonly implementation: (input: { file: string; line: number; character: number }) => Effect.Effect<any[]>
+    readonly prepareCallHierarchy: (input: { file: string; line: number; character: number }) => Effect.Effect<any[]>
+    readonly incomingCalls: (input: { file: string; line: number; character: number }) => Effect.Effect<any[]>
+    readonly outgoingCalls: (input: { file: string; line: number; character: number }) => Effect.Effect<any[]>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/LSP") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const instance = yield* InstanceContext
+      const directory = instance.directory
+
+      const clients: LSPClient.Info[] = []
+      const servers: Record<string, LSPServer.Info> = {}
+      const broken = new Set<string>()
+      const spawning = new Map<string, Promise<LSPClient.Info | undefined>>()
+
+      // Load server configs lazily — forkScoped so it doesn't block layer construction
+      const load = Effect.fn("LSP.load")(function* () {
+        yield* Effect.promise(async () => {
+          const cfg = await Config.get()
+
+          if (cfg.lsp === false) {
+            log.info("all LSPs are disabled")
+            return
+          }
+
+          for (const server of Object.values(LSPServer)) {
+            servers[server.id] = server
+          }
+
+          filterExperimentalServers(servers)
+
+          for (const [name, item] of Object.entries(cfg.lsp ?? {})) {
+            const existing = servers[name]
+            if (item.disabled) {
+              log.info(`LSP server ${name} is disabled`)
+              delete servers[name]
+              continue
+            }
+            servers[name] = {
+              ...existing,
+              id: name,
+              root: existing?.root ?? (async () => directory),
+              extensions: item.extensions ?? existing?.extensions ?? [],
+              spawn: async (root) => {
+                return {
+                  process: lspspawn(item.command[0], item.command.slice(1), {
+                    cwd: root,
+                    env: {
+                      ...process.env,
+                      ...item.env,
+                    },
+                  }),
+                  initialization: item.initialization,
+                }
+              },
+            }
+          }
+
+          log.info("enabled LSP servers", {
+            serverIds: Object.values(servers)
+              .map((server) => server.id)
+              .join(", "),
+          })
         })
-        .then((result: any) => result.filter((x: LSP.Symbol) => kinds.includes(x.kind)))
-        .then((result: any) => result.slice(0, 10))
-        .catch(() => []),
-    ).then((result) => result.flat() as LSP.Symbol[])
+      })
+
+      const loadFiber = yield* load().pipe(
+        Effect.catchCause((cause) => Effect.sync(() => log.error("init failed", { cause }))),
+        Effect.forkScoped,
+      )
+
+      // Cleanup: shut down all LSP clients when the scope is closed
+      yield* Effect.addFinalizer(() =>
+        Effect.promise(async () => {
+          await Promise.all(clients.map((client) => client.shutdown()))
+        }),
+      )
+
+      async function getClientsForFile(file: string) {
+        const extension = path.parse(file).ext || file
+        const result: LSPClient.Info[] = []
+
+        async function schedule(server: LSPServer.Info, root: string, key: string) {
+          const handle = await server
+            .spawn(root)
+            .then((value) => {
+              if (!value) broken.add(key)
+              return value
+            })
+            .catch((err) => {
+              broken.add(key)
+              log.error(`Failed to spawn LSP server ${server.id}`, { error: err })
+              return undefined
+            })
+
+          if (!handle) return undefined
+          log.info("spawned lsp server", { serverID: server.id })
+
+          const client = await LSPClient.create({
+            serverID: server.id,
+            server: handle,
+            root,
+          }).catch(async (err) => {
+            broken.add(key)
+            await Process.stop(handle.process)
+            log.error(`Failed to initialize LSP client ${server.id}`, { error: err })
+            return undefined
+          })
+
+          if (!client) {
+            return undefined
+          }
+
+          const existing = clients.find((x) => x.root === root && x.serverID === server.id)
+          if (existing) {
+            await Process.stop(handle.process)
+            return existing
+          }
+
+          clients.push(client)
+          return client
+        }
+
+        for (const server of Object.values(servers)) {
+          if (server.extensions.length && !server.extensions.includes(extension)) continue
+
+          const root = await server.root(file)
+          if (!root) continue
+          if (broken.has(root + server.id)) continue
+
+          const match = clients.find((x) => x.root === root && x.serverID === server.id)
+          if (match) {
+            result.push(match)
+            continue
+          }
+
+          const inflight = spawning.get(root + server.id)
+          if (inflight) {
+            const client = await inflight
+            if (!client) continue
+            result.push(client)
+            continue
+          }
+
+          const task = schedule(server, root, root + server.id)
+          spawning.set(root + server.id, task)
+
+          task.finally(() => {
+            if (spawning.get(root + server.id) === task) {
+              spawning.delete(root + server.id)
+            }
+          })
+
+          const client = await task
+          if (!client) continue
+
+          result.push(client)
+          Bus.publish(Event.Updated, {})
+        }
+
+        return result
+      }
+
+      async function runAllClients<T>(input: (client: LSPClient.Info) => Promise<T>): Promise<T[]> {
+        const tasks = clients.map((x) => input(x))
+        return Promise.all(tasks)
+      }
+
+      async function runForFile<T>(file: string, input: (client: LSPClient.Info) => Promise<T>): Promise<T[]> {
+        const matched = await getClientsForFile(file)
+        const tasks = matched.map((x) => input(x))
+        return Promise.all(tasks)
+      }
+
+      const init = Effect.fn("LSP.init")(function* () {
+        yield* Fiber.join(loadFiber)
+      })
+
+      const status = Effect.fn("LSP.status")(function* () {
+        yield* Fiber.join(loadFiber)
+        const result: Status[] = []
+        for (const client of clients) {
+          result.push({
+            id: client.serverID,
+            name: servers[client.serverID].id,
+            root: path.relative(directory, client.root),
+            status: "connected",
+          })
+        }
+        return result
+      })
+
+      const hasClients = Effect.fn("LSP.hasClients")(function* (file: string) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          const extension = path.parse(file).ext || file
+          for (const server of Object.values(servers)) {
+            if (server.extensions.length && !server.extensions.includes(extension)) continue
+            const root = await server.root(file)
+            if (!root) continue
+            if (broken.has(root + server.id)) continue
+            return true
+          }
+          return false
+        })
+      })
+
+      const touchFile = Effect.fn("LSP.touchFile")(function* (input: string, waitForDiagnostics?: boolean) {
+        yield* Fiber.join(loadFiber)
+        yield* Effect.promise(async () => {
+          log.info("touching file", { file: input })
+          const matched = await getClientsForFile(input)
+          await Promise.all(
+            matched.map(async (client) => {
+              const wait = waitForDiagnostics ? client.waitForDiagnostics({ path: input }) : Promise.resolve()
+              await client.notify.open({ path: input })
+              return wait
+            }),
+          ).catch((err) => {
+            log.error("failed to touch file", { err, file: input })
+          })
+        })
+      })
+
+      const diagnostics = Effect.fn("LSP.diagnostics")(function* () {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          const results: Record<string, LSPClient.Diagnostic[]> = {}
+          for (const result of await runAllClients(async (client) => client.diagnostics)) {
+            for (const [path, diagnostics] of result.entries()) {
+              const arr = results[path] || []
+              arr.push(...diagnostics)
+              results[path] = arr
+            }
+          }
+          return results
+        })
+      })
+
+      const hover = Effect.fn("LSP.hover")(function* (input: { file: string; line: number; character: number }) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          return runForFile(input.file, (client) => {
+            return client.connection
+              .sendRequest("textDocument/hover", {
+                textDocument: {
+                  uri: pathToFileURL(input.file).href,
+                },
+                position: {
+                  line: input.line,
+                  character: input.character,
+                },
+              })
+              .catch(() => null)
+          })
+        })
+      })
+
+      const workspaceSymbol = Effect.fn("LSP.workspaceSymbol")(function* (query: string) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          return runAllClients((client) =>
+            client.connection
+              .sendRequest("workspace/symbol", {
+                query,
+              })
+              .then((result: any) => result.filter((x: LSP.Symbol) => kinds.includes(x.kind)))
+              .then((result: any) => result.slice(0, 10))
+              .catch(() => []),
+          ).then((result) => result.flat() as LSP.Symbol[])
+        })
+      })
+
+      const documentSymbol = Effect.fn("LSP.documentSymbol")(function* (uri: string) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          const file = fileURLToPath(uri)
+          return runForFile(file, (client) =>
+            client.connection
+              .sendRequest("textDocument/documentSymbol", {
+                textDocument: {
+                  uri,
+                },
+              })
+              .catch(() => []),
+          )
+            .then((result) => result.flat() as (LSP.DocumentSymbol | LSP.Symbol)[])
+            .then((result) => result.filter(Boolean))
+        })
+      })
+
+      const definition = Effect.fn("LSP.definition")(function* (input: {
+        file: string
+        line: number
+        character: number
+      }) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          return runForFile(input.file, (client) =>
+            client.connection
+              .sendRequest("textDocument/definition", {
+                textDocument: { uri: pathToFileURL(input.file).href },
+                position: { line: input.line, character: input.character },
+              })
+              .catch(() => null),
+          ).then((result) => result.flat().filter(Boolean))
+        })
+      })
+
+      const references = Effect.fn("LSP.references")(function* (input: {
+        file: string
+        line: number
+        character: number
+      }) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          return runForFile(input.file, (client) =>
+            client.connection
+              .sendRequest("textDocument/references", {
+                textDocument: { uri: pathToFileURL(input.file).href },
+                position: { line: input.line, character: input.character },
+                context: { includeDeclaration: true },
+              })
+              .catch(() => []),
+          ).then((result) => result.flat().filter(Boolean))
+        })
+      })
+
+      const implementation = Effect.fn("LSP.implementation")(function* (input: {
+        file: string
+        line: number
+        character: number
+      }) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          return runForFile(input.file, (client) =>
+            client.connection
+              .sendRequest("textDocument/implementation", {
+                textDocument: { uri: pathToFileURL(input.file).href },
+                position: { line: input.line, character: input.character },
+              })
+              .catch(() => null),
+          ).then((result) => result.flat().filter(Boolean))
+        })
+      })
+
+      const prepareCallHierarchy = Effect.fn("LSP.prepareCallHierarchy")(function* (input: {
+        file: string
+        line: number
+        character: number
+      }) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          return runForFile(input.file, (client) =>
+            client.connection
+              .sendRequest("textDocument/prepareCallHierarchy", {
+                textDocument: { uri: pathToFileURL(input.file).href },
+                position: { line: input.line, character: input.character },
+              })
+              .catch(() => []),
+          ).then((result) => result.flat().filter(Boolean))
+        })
+      })
+
+      const incomingCalls = Effect.fn("LSP.incomingCalls")(function* (input: {
+        file: string
+        line: number
+        character: number
+      }) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          return runForFile(input.file, async (client) => {
+            const items = (await client.connection
+              .sendRequest("textDocument/prepareCallHierarchy", {
+                textDocument: { uri: pathToFileURL(input.file).href },
+                position: { line: input.line, character: input.character },
+              })
+              .catch(() => [])) as any[]
+            if (!items?.length) return []
+            return client.connection
+              .sendRequest("callHierarchy/incomingCalls", { item: items[0] })
+              .catch(() => [])
+          }).then((result) => result.flat().filter(Boolean))
+        })
+      })
+
+      const outgoingCalls = Effect.fn("LSP.outgoingCalls")(function* (input: {
+        file: string
+        line: number
+        character: number
+      }) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          return runForFile(input.file, async (client) => {
+            const items = (await client.connection
+              .sendRequest("textDocument/prepareCallHierarchy", {
+                textDocument: { uri: pathToFileURL(input.file).href },
+                position: { line: input.line, character: input.character },
+              })
+              .catch(() => [])) as any[]
+            if (!items?.length) return []
+            return client.connection
+              .sendRequest("callHierarchy/outgoingCalls", { item: items[0] })
+              .catch(() => [])
+          }).then((result) => result.flat().filter(Boolean))
+        })
+      })
+
+      log.info("init")
+      return Service.of({
+        init,
+        status,
+        hasClients,
+        touchFile,
+        diagnostics,
+        hover,
+        workspaceSymbol,
+        documentSymbol,
+        definition,
+        references,
+        implementation,
+        prepareCallHierarchy,
+        incomingCalls,
+        outgoingCalls,
+      })
+    }),
+  )
+
+  // Async facades
+  export async function init() {
+    return runPromiseInstance(Service.use((svc) => svc.init()))
+  }
+
+  export async function status() {
+    return runPromiseInstance(Service.use((svc) => svc.status()))
+  }
+
+  export async function hasClients(file: string) {
+    return runPromiseInstance(Service.use((svc) => svc.hasClients(file)))
+  }
+
+  export async function touchFile(input: string, waitForDiagnostics?: boolean) {
+    return runPromiseInstance(Service.use((svc) => svc.touchFile(input, waitForDiagnostics)))
+  }
+
+  export async function diagnostics() {
+    return runPromiseInstance(Service.use((svc) => svc.diagnostics()))
+  }
+
+  export async function hover(input: { file: string; line: number; character: number }) {
+    return runPromiseInstance(Service.use((svc) => svc.hover(input)))
+  }
+
+  export async function workspaceSymbol(query: string) {
+    return runPromiseInstance(Service.use((svc) => svc.workspaceSymbol(query)))
   }
 
   export async function documentSymbol(uri: string) {
-    const file = fileURLToPath(uri)
-    return run(file, (client) =>
-      client.connection
-        .sendRequest("textDocument/documentSymbol", {
-          textDocument: {
-            uri,
-          },
-        })
-        .catch(() => []),
-    )
-      .then((result) => result.flat() as (LSP.DocumentSymbol | LSP.Symbol)[])
-      .then((result) => result.filter(Boolean))
+    return runPromiseInstance(Service.use((svc) => svc.documentSymbol(uri)))
   }
 
   export async function definition(input: { file: string; line: number; character: number }) {
-    return run(input.file, (client) =>
-      client.connection
-        .sendRequest("textDocument/definition", {
-          textDocument: { uri: pathToFileURL(input.file).href },
-          position: { line: input.line, character: input.character },
-        })
-        .catch(() => null),
-    ).then((result) => result.flat().filter(Boolean))
+    return runPromiseInstance(Service.use((svc) => svc.definition(input)))
   }
 
   export async function references(input: { file: string; line: number; character: number }) {
-    return run(input.file, (client) =>
-      client.connection
-        .sendRequest("textDocument/references", {
-          textDocument: { uri: pathToFileURL(input.file).href },
-          position: { line: input.line, character: input.character },
-          context: { includeDeclaration: true },
-        })
-        .catch(() => []),
-    ).then((result) => result.flat().filter(Boolean))
+    return runPromiseInstance(Service.use((svc) => svc.references(input)))
   }
 
   export async function implementation(input: { file: string; line: number; character: number }) {
-    return run(input.file, (client) =>
-      client.connection
-        .sendRequest("textDocument/implementation", {
-          textDocument: { uri: pathToFileURL(input.file).href },
-          position: { line: input.line, character: input.character },
-        })
-        .catch(() => null),
-    ).then((result) => result.flat().filter(Boolean))
+    return runPromiseInstance(Service.use((svc) => svc.implementation(input)))
   }
 
   export async function prepareCallHierarchy(input: { file: string; line: number; character: number }) {
-    return run(input.file, (client) =>
-      client.connection
-        .sendRequest("textDocument/prepareCallHierarchy", {
-          textDocument: { uri: pathToFileURL(input.file).href },
-          position: { line: input.line, character: input.character },
-        })
-        .catch(() => []),
-    ).then((result) => result.flat().filter(Boolean))
+    return runPromiseInstance(Service.use((svc) => svc.prepareCallHierarchy(input)))
   }
 
   export async function incomingCalls(input: { file: string; line: number; character: number }) {
-    return run(input.file, async (client) => {
-      const items = (await client.connection
-        .sendRequest("textDocument/prepareCallHierarchy", {
-          textDocument: { uri: pathToFileURL(input.file).href },
-          position: { line: input.line, character: input.character },
-        })
-        .catch(() => [])) as any[]
-      if (!items?.length) return []
-      return client.connection.sendRequest("callHierarchy/incomingCalls", { item: items[0] }).catch(() => [])
-    }).then((result) => result.flat().filter(Boolean))
+    return runPromiseInstance(Service.use((svc) => svc.incomingCalls(input)))
   }
 
   export async function outgoingCalls(input: { file: string; line: number; character: number }) {
-    return run(input.file, async (client) => {
-      const items = (await client.connection
-        .sendRequest("textDocument/prepareCallHierarchy", {
-          textDocument: { uri: pathToFileURL(input.file).href },
-          position: { line: input.line, character: input.character },
-        })
-        .catch(() => [])) as any[]
-      if (!items?.length) return []
-      return client.connection.sendRequest("callHierarchy/outgoingCalls", { item: items[0] }).catch(() => [])
-    }).then((result) => result.flat().filter(Boolean))
-  }
-
-  async function runAll<T>(input: (client: LSPClient.Info) => Promise<T>): Promise<T[]> {
-    const clients = await state().then((x) => x.clients)
-    const tasks = clients.map((x) => input(x))
-    return Promise.all(tasks)
-  }
-
-  async function run<T>(file: string, input: (client: LSPClient.Info) => Promise<T>): Promise<T[]> {
-    const clients = await getClients(file)
-    const tasks = clients.map((x) => input(x))
-    return Promise.all(tasks)
+    return runPromiseInstance(Service.use((svc) => svc.outgoingCalls(input)))
   }
 
   export namespace Diagnostic {

packages/opencode/src/plugin/index.ts

@@ -1,206 +1,144 @@
 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 { Effect, Layer, ServiceMap } from "effect"
-import { InstanceContext } from "@/effect/instance-context"
+import { CopilotAuthPlugin } from "./copilot"
+import { gitlabAuthPlugin as GitlabAuthPlugin } from "opencode-gitlab-auth"
 
 export namespace Plugin {
   const log = Log.create({ service: "plugin" })
 
-  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>
-  }
+  // Built-in plugins that are directly imported (not installed from npm)
+  const INTERNAL_PLUGINS: PluginInstance[] = [CodexAuthPlugin, CopilotAuthPlugin, GitlabAuthPlugin]
 
-  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Plugin") {}
+  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")}`,
+          }
+        : 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.$,
+    }
 
-  export const layer = Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const instance = yield* InstanceContext
-      const hooks: Hooks[] = []
-      let task: Promise<void> | undefined
+    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 })
+      })
+      if (init) hooks.push(init)
+    }
 
-      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),
+    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(),
           })
-          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.$,
-          }
-
-          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(),
-                  }),
-                )
-              })
+          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))
           }
         })
-      })
-
-      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
-        })
-      })
-
-      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)
-          }
-        })
-        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,
-              })
-            }
+        .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 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)
-  }
+    return {
+      hooks,
+      input,
+    }
+  })
 
   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> {
-    return run(Service.use((svc) => svc.trigger(name, input, 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
   }
 
-  export async function list(): Promise<Hooks[]> {
-    return run(Service.use((svc) => svc.list()))
+  export async function list() {
+    return state().then((x) => x.hooks)
   }
 
   export async function init() {
-    return run(Service.use((svc) => svc.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,
+        })
+      }
+    })
   }
 }

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

@@ -1,4 +1,4 @@
-import type { AuthOuathResult, Hooks } from "@opencode-ai/plugin"
+import type { AuthOuathResult } from "@opencode-ai/plugin"
 import { NamedError } from "@opencode-ai/util/error"
 import * as Auth from "@/auth/effect"
 import { ProviderID } from "./schema"
@@ -6,8 +6,6 @@ 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")]),
@@ -107,26 +105,20 @@ export namespace ProviderAuth {
     Service,
     Effect.gen(function* () {
       const auth = yield* Auth.Auth.Service
-      let hooks: Record<ProviderID, Hook> | undefined
+      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,
+          ),
+        )
+      })
       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 => ({
@@ -160,7 +152,6 @@ 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
 
@@ -187,7 +178,6 @@ 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/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: Record<string, unknown> } }
+type BusUpdate = { directory?: string; payload: { type: string; properties: WatcherEvent } }
 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
-    const props = evt.payload.properties as WatcherEvent
-    if (!check(props)) return
-    hit(props)
+    if (!check(evt.payload.properties)) return
+    hit(evt.payload.properties)
   }
 
-  GlobalBus.on("event", on)
-
-  return () => {
+  function cleanup() {
     if (done) return
     done = true
     GlobalBus.off("event", on)
   }
+
+  GlobalBus.on("event", on)
+  return cleanup
 }
 
 function wait(directory: string, check: (evt: WatcherEvent) => boolean) {