resolve merge conflicts

packages/opencode/test/project/instance.test.ts

@@ -0,0 +1,273 @@
+import { afterEach, describe, expect } from "bun:test"
+import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
+import { Effect, Fiber, Layer } from "effect"
+import { InstanceRef } from "../../src/effect/instance-ref"
+import { registerDisposer } from "../../src/effect/instance-registry"
+import { Instance } from "../../src/project/instance"
+import { InstanceStore } from "../../src/project/instance-store"
+import { disposeAllInstances, tmpdirScoped } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+const it = testEffect(Layer.mergeAll(InstanceStore.defaultLayer, CrossSpawnSpawner.defaultLayer))
+
+afterEach(async () => {
+  await disposeAllInstances()
+})
+
+describe("InstanceStore", () => {
+  it.live("loads instance context without installing ALS for the caller", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdirScoped({ git: true })
+      const store = yield* InstanceStore.Service
+      const ctx = yield* store.load({ directory: dir })
+
+      expect(ctx.directory).toBe(dir)
+      expect(ctx.worktree).toBe(dir)
+      expect(() => Instance.current).toThrow()
+    }),
+  )
+
+  it.live("runs load init with InstanceRef provided", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdirScoped({ git: true })
+      const store = yield* InstanceStore.Service
+      let initializedDirectory: string | undefined
+
+      yield* store.load({
+        directory: dir,
+        init: Effect.gen(function* () {
+          initializedDirectory = (yield* InstanceRef)?.directory
+        }),
+      })
+
+      expect(initializedDirectory).toBe(dir)
+      expect(() => Instance.current).toThrow()
+    }),
+  )
+
+  it.live("caches loaded instance context by directory", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdirScoped({ git: true })
+      const store = yield* InstanceStore.Service
+      let initialized = 0
+
+      const first = yield* store.load({
+        directory: dir,
+        init: Effect.sync(() => {
+          initialized++
+        }),
+      })
+      const second = yield* store.load({
+        directory: dir,
+        init: Effect.sync(() => {
+          initialized++
+        }),
+      })
+
+      expect(second).toBe(first)
+      expect(initialized).toBe(1)
+    }),
+  )
+
+  it.live("dedupes concurrent loads while init is in flight", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdirScoped({ git: true })
+      const store = yield* InstanceStore.Service
+      const started = Promise.withResolvers<void>()
+      const release = Promise.withResolvers<void>()
+      let initialized = 0
+
+      const first = yield* store
+        .load({
+          directory: dir,
+          init: Effect.promise(async () => {
+            initialized++
+            started.resolve()
+            await release.promise
+          }),
+        })
+        .pipe(Effect.forkScoped)
+
+      yield* Effect.promise(() => started.promise)
+
+      const second = yield* store
+        .load({
+          directory: dir,
+          init: Effect.sync(() => {
+            initialized++
+          }),
+        })
+        .pipe(Effect.forkScoped)
+
+      expect(initialized).toBe(1)
+      release.resolve()
+
+      const [firstCtx, secondCtx] = yield* Effect.all([Fiber.join(first), Fiber.join(second)])
+      expect(secondCtx).toBe(firstCtx)
+      expect(initialized).toBe(1)
+    }),
+  )
+
+  it.live("removes failed loads from the cache", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdirScoped({ git: true })
+      const store = yield* InstanceStore.Service
+      let attempts = 0
+
+      const failed = yield* store
+        .load({
+          directory: dir,
+          init: Effect.sync(() => {
+            attempts++
+            throw new Error("init failed")
+          }),
+        })
+        .pipe(
+          Effect.as(false),
+          Effect.catchCause(() => Effect.succeed(true)),
+        )
+
+      expect(failed).toBe(true)
+
+      const ctx = yield* store.load({
+        directory: dir,
+        init: Effect.sync(() => {
+          attempts++
+        }),
+      })
+
+      expect(ctx.directory).toBe(dir)
+      expect(attempts).toBe(2)
+    }),
+  )
+
+  it.live("reload replaces the cached context", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdirScoped({ git: true })
+      const store = yield* InstanceStore.Service
+
+      const first = yield* store.load({ directory: dir })
+      const second = yield* store.reload({ directory: dir })
+      const cached = yield* store.load({ directory: dir })
+
+      expect(second).not.toBe(first)
+      expect(cached).toBe(second)
+    }),
+  )
+
+  it.live("stale dispose does not delete an in-flight reload", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdirScoped({ git: true })
+      const store = yield* InstanceStore.Service
+      const reloading = Promise.withResolvers<void>()
+      const releaseReload = Promise.withResolvers<void>()
+      const disposed: Array<string> = []
+      const off = registerDisposer(async (directory) => {
+        disposed.push(directory)
+      })
+      yield* Effect.addFinalizer(() => Effect.sync(off))
+
+      const first = yield* store.load({ directory: dir })
+      const reload = yield* store
+        .reload({
+          directory: dir,
+          init: Effect.promise(async () => {
+            reloading.resolve()
+            await releaseReload.promise
+          }),
+        })
+        .pipe(Effect.forkScoped)
+
+      yield* Effect.promise(() => reloading.promise)
+      const staleDispose = yield* store.dispose(first).pipe(Effect.forkScoped)
+      releaseReload.resolve()
+
+      const second = yield* Fiber.join(reload)
+      yield* Fiber.join(staleDispose)
+
+      expect(disposed).toEqual([dir])
+      expect(yield* store.load({ directory: dir })).toBe(second)
+    }),
+  )
+
+  it.live("dedupes concurrent disposeAll calls", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdirScoped({ git: true })
+      const store = yield* InstanceStore.Service
+      const disposing = Promise.withResolvers<void>()
+      const releaseDispose = Promise.withResolvers<void>()
+      const disposed: Array<string> = []
+      const off = registerDisposer(async (directory) => {
+        disposed.push(directory)
+        disposing.resolve()
+        await releaseDispose.promise
+      })
+      yield* Effect.addFinalizer(() => Effect.sync(off))
+
+      yield* store.load({ directory: dir })
+      const first = yield* store.disposeAll().pipe(Effect.forkScoped)
+      yield* Effect.promise(() => disposing.promise)
+      const second = yield* store.disposeAll().pipe(Effect.forkScoped)
+
+      expect(disposed).toEqual([dir])
+      releaseDispose.resolve()
+      yield* Effect.all([Fiber.join(first), Fiber.join(second)])
+      expect(disposed).toEqual([dir])
+    }),
+  )
+
+  it.live("re-arms disposeAll after completion", () =>
+    Effect.gen(function* () {
+      const dir1 = yield* tmpdirScoped({ git: true })
+      const dir2 = yield* tmpdirScoped({ git: true })
+      const store = yield* InstanceStore.Service
+      const disposed: Array<string> = []
+      const off = registerDisposer(async (directory) => {
+        disposed.push(directory)
+      })
+      yield* Effect.addFinalizer(() => Effect.sync(off))
+
+      yield* store.load({ directory: dir1 })
+      yield* store.disposeAll()
+      expect(disposed).toEqual([dir1])
+
+      yield* store.load({ directory: dir2 })
+      yield* store.disposeAll()
+      expect(disposed).toEqual([dir1, dir2])
+    }),
+  )
+
+  it.live("keeps Instance.provide as the legacy ALS wrapper", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdirScoped({ git: true })
+
+      const directory = yield* Effect.promise(() =>
+        Instance.provide({
+          directory: dir,
+          fn: () => Instance.directory,
+        }),
+      )
+
+      expect(directory).toBe(dir)
+      expect(() => Instance.current).toThrow()
+    }),
+  )
+
+  it.live("does not install legacy ALS around Effect init", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdirScoped()
+
+      const directory = yield* Effect.promise(() =>
+        Instance.provide({
+          directory: dir,
+          init: Effect.sync(() => {
+            expect(() => Instance.current).toThrow()
+          }),
+          fn: () => Instance.directory,
+        }),
+      )
+
+      expect(directory).toBe(dir)
+    }),
+  )
+})

packages/opencode/test/project/vcs.test.ts

@@ -3,7 +3,7 @@ import { afterEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
 import fs from "fs/promises"
 import path from "path"
-import { tmpdir } from "../fixture/fixture"
+import { disposeAllInstances, tmpdir } from "../fixture/fixture"
 import { AppRuntime } from "../../src/effect/app-runtime"
 import { FileWatcher } from "../../src/file/watcher"
 import { Instance } from "../../src/project/instance"
@@ -85,7 +85,7 @@ function nextBranchUpdate(directory: string, timeout = 10_000) {
 
 describeVcs("Vcs", () => {
   afterEach(async () => {
-    await Instance.disposeAll()
+    await disposeAllInstances()
   })
 
   test("branch() returns current branch name", async () => {
@@ -158,7 +158,7 @@ describeVcs("Vcs", () => {
 
 describe("Vcs diff", () => {
   afterEach(async () => {
-    await Instance.disposeAll()
+    await disposeAllInstances()
   })
 
   test("defaultBranch() falls back to main", async () => {

packages/opencode/test/project/worktree.test.ts

@@ -5,8 +5,9 @@ import path from "path"
 import { Cause, Effect, Exit, Layer } from "effect"
 import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
 import { Instance } from "../../src/project/instance"
+import { InstanceStore } from "../../src/project/instance-store"
 import { Worktree } from "../../src/worktree"
-import { provideInstance, provideTmpdirInstance } from "../fixture/fixture"
+import { disposeAllInstances, provideInstance, provideTmpdirInstance } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"
 
 const it = testEffect(Layer.mergeAll(Worktree.defaultLayer, CrossSpawnSpawner.defaultLayer))
@@ -37,7 +38,7 @@ async function waitReady() {
 }
 
 describe("Worktree", () => {
-  afterEach(() => Instance.disposeAll())
+  afterEach(() => disposeAllInstances())
 
   describe("makeWorktreeInfo", () => {
     it.live("returns info with name, branch, and directory", () =>
@@ -136,7 +137,11 @@ describe("Worktree", () => {
             expect(props.name).toBe(info.name)
             expect(props.branch).toBe(info.branch)
 
-            yield* Effect.promise(() => Instance.dispose()).pipe(provideInstance(info.directory))
+            yield* Effect.promise(() =>
+              InstanceStore.runtime.runPromise((s) =>
+                s.load({ directory: info.directory }).pipe(Effect.flatMap(s.dispose)),
+              ),
+            )
             yield* Effect.promise(() => Bun.sleep(100))
             yield* svc.remove({ directory: info.directory })
           }),
@@ -156,7 +161,11 @@ describe("Worktree", () => {
             expect(info.branch).toBe("opencode/test-workspace")
 
             yield* Effect.promise(() => ready)
-            yield* Effect.promise(() => Instance.dispose()).pipe(provideInstance(info.directory))
+            yield* Effect.promise(() =>
+              InstanceStore.runtime.runPromise((s) =>
+                s.load({ directory: info.directory }).pipe(Effect.flatMap(s.dispose)),
+              ),
+            )
             yield* Effect.promise(() => Bun.sleep(100))
             yield* svc.remove({ directory: info.directory })
           }),