Move instance loading into Effect service (#25277)

packages/opencode/src/server/routes/instance/httpapi/handlers/global.ts

@@ -1,7 +1,7 @@
 import { Config } from "@/config/config"
 import { GlobalBus, type GlobalEvent as GlobalBusEvent } from "@/bus/global"
 import { Installation } from "@/installation"
-import { Instance } from "@/project/instance"
+import { InstanceStore } from "@/project/instance-store"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
 import * as Log from "@opencode-ai/core/util/log"
 import { Effect, Queue, Schema } from "effect"
@@ -68,6 +68,7 @@ export const globalHandlers = HttpApiBuilder.group(RootHttpApi, "global", (handl
   Effect.gen(function* () {
     const config = yield* Config.Service
     const installation = yield* Installation.Service
+    const store = yield* InstanceStore.Service
 
     const health = Effect.fn("GlobalHttpApi.health")(function* () {
       return { healthy: true as const, version: InstallationVersion }
@@ -86,7 +87,7 @@ export const globalHandlers = HttpApiBuilder.group(RootHttpApi, "global", (handl
     })
 
     const dispose = Effect.fn("GlobalHttpApi.dispose")(function* () {
-      yield* Effect.promise(() => Instance.disposeAll())
+      yield* store.disposeAll()
       GlobalBus.emit("event", {
         directory: "global",
         payload: { type: "global.disposed", properties: {} },

packages/opencode/src/server/routes/instance/httpapi/lifecycle.ts

@@ -1,13 +1,13 @@
-import type { WorkspaceID } from "@/control-plane/schema"
-import { WorkspaceContext } from "@/control-plane/workspace-context"
-import { WorkspaceRef } from "@/effect/instance-ref"
-import { Instance, type InstanceContext } from "@/project/instance"
+import { EffectBridge } from "@/effect/bridge"
+import type { InstanceContext } from "@/project/instance"
+import { InstanceStore } from "@/project/instance-store"
 import { Effect } from "effect"
 import { HttpEffect, HttpMiddleware, HttpServerRequest } from "effect/unstable/http"
 
 type MarkedInstance = {
   ctx: InstanceContext
-  workspaceID?: WorkspaceID
+  store: InstanceStore.Interface
+  bridge: EffectBridge.Shape
 }
 
 // Disposal is requested by an endpoint handler, but must run from the outer
@@ -17,20 +17,9 @@ const disposeAfterResponse = new WeakMap<object, MarkedInstance>()
 
 const mark = (ctx: InstanceContext) =>
   Effect.gen(function* () {
-    return { ctx, workspaceID: yield* WorkspaceRef }
+    return { ctx, store: yield* InstanceStore.Service, bridge: yield* EffectBridge.make() }
   })
 
-// Instance.dispose/reload still publish events through legacy ALS helpers.
-// Effect request handlers carry these values in services, so bridge them back
-// into the legacy contexts only around the lifecycle operation.
-const restoreMarked = <A>(marked: MarkedInstance, fn: () => A) =>
-  Effect.promise(() =>
-    WorkspaceContext.provide({
-      workspaceID: marked.workspaceID,
-      fn: () => Instance.restore(marked.ctx, fn),
-    }),
-  )
-
 export const markInstanceForDisposal = (ctx: InstanceContext) =>
   Effect.gen(function* () {
     const marked = yield* mark(ctx)
@@ -43,11 +32,11 @@ export const markInstanceForDisposal = (ctx: InstanceContext) =>
     )
   })
 
-export const markInstanceForReload = (ctx: InstanceContext, next: Parameters<typeof Instance.reload>[0]) =>
+export const markInstanceForReload = (ctx: InstanceContext, next: InstanceStore.LoadInput) =>
   Effect.gen(function* () {
     const marked = yield* mark(ctx)
     return yield* HttpEffect.appendPreResponseHandler((_request, response) =>
-      Effect.as(Effect.uninterruptible(restoreMarked(marked, () => Instance.reload(next))), response),
+      Effect.as(Effect.uninterruptible(marked.bridge.run(marked.store.reload(next))), response),
     )
   })
 
@@ -58,6 +47,6 @@ export const disposeMiddleware: HttpMiddleware.HttpMiddleware = (effect) =>
     const marked = disposeAfterResponse.get(request.source)
     if (!marked) return response
     disposeAfterResponse.delete(request.source)
-    yield* Effect.uninterruptible(restoreMarked(marked, () => Instance.dispose()))
+    yield* Effect.uninterruptible(marked.bridge.run(marked.store.dispose(marked.ctx)))
     return response
   })

packages/opencode/src/server/routes/instance/httpapi/middleware/instance-context.ts

@@ -1,9 +1,8 @@
 import { InstanceRef, WorkspaceRef } from "@/effect/instance-ref"
 import { AppRuntime } from "@/effect/app-runtime"
 import { InstanceBootstrap } from "@/project/bootstrap"
-import { Instance } from "@/project/instance"
 import type { InstanceContext } from "@/project/instance"
-import { Filesystem } from "@/util/filesystem"
+import { InstanceStore } from "@/project/instance-store"
 import { Effect, Layer } from "effect"
 import { HttpRouter, HttpServerResponse } from "effect/unstable/http"
 import { HttpApiMiddleware } from "effect/unstable/httpapi"
@@ -24,22 +23,23 @@ function decode(input: string): string {
   }
 }
 
-function makeInstanceContext(directory: string): Effect.Effect<InstanceContext> {
-  return Effect.promise(() =>
-    Instance.provide({
-      directory: Filesystem.resolve(decode(directory)),
-      init: () => AppRuntime.runPromise(InstanceBootstrap),
-      fn: () => Instance.current,
-    }),
-  )
+function makeInstanceContext(
+  store: InstanceStore.Interface,
+  directory: string,
+): Effect.Effect<InstanceContext> {
+  return store.load({
+    directory: decode(directory),
+    init: () => AppRuntime.runPromise(InstanceBootstrap),
+  })
 }
 
 function provideInstanceContext<E>(
   effect: Effect.Effect<HttpServerResponse.HttpServerResponse, E>,
+  store: InstanceStore.Interface,
 ): Effect.Effect<HttpServerResponse.HttpServerResponse, E, WorkspaceRouteContext> {
   return Effect.gen(function* () {
     const route = yield* WorkspaceRouteContext
-    const ctx = yield* makeInstanceContext(route.directory)
+    const ctx = yield* makeInstanceContext(store, route.directory)
     return yield* effect.pipe(
       Effect.provideService(InstanceRef, ctx),
       Effect.provideService(WorkspaceRef, route.workspaceID),
@@ -47,9 +47,17 @@ function provideInstanceContext<E>(
   })
 }
 
-export const instanceContextLayer = Layer.succeed(
+export const instanceContextLayer = Layer.effect(
   InstanceContextMiddleware,
-  InstanceContextMiddleware.of((effect) => provideInstanceContext(effect)),
+  Effect.gen(function* () {
+    const store = yield* InstanceStore.Service
+    return InstanceContextMiddleware.of((effect) => provideInstanceContext(effect, store))
+  }),
 )
 
-export const instanceRouterMiddleware = HttpRouter.middleware()((effect) => provideInstanceContext(effect))
+export const instanceRouterMiddleware = HttpRouter.middleware()(
+  Effect.gen(function* () {
+    const store = yield* InstanceStore.Service
+    return (effect) => provideInstanceContext(effect, store)
+  }),
+)

packages/opencode/src/server/routes/instance/httpapi/server.ts

@@ -17,6 +17,7 @@ import { LSP } from "@/lsp/lsp"
 import { MCP } from "@/mcp"
 import { Permission } from "@/permission"
 import { Installation } from "@/installation"
+import { InstanceStore } from "@/project/instance-store"
 import { Project } from "@/project/project"
 import { ProviderAuth } from "@/provider/auth"
 import { Provider } from "@/provider/provider"
@@ -145,6 +146,7 @@ export function createRoutes(corsOptions?: CorsOptions) {
       Format.defaultLayer,
       LSP.defaultLayer,
       Installation.defaultLayer,
+      InstanceStore.defaultLayer,
       MCP.defaultLayer,
       Permission.defaultLayer,
       Project.defaultLayer,