openAgent

1import { expect } from "bun:test"
2import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
3import { LayerNode } from "@opencode-ai/core/effect/layer-node"
4import { $ } from "bun"
5import { Context, Deferred, Duration, Effect, Exit, Fiber, Layer } from "effect"
6import { InstanceState } from "@/effect/instance-state"
7import {
8  disposeAllInstancesEffect,
9  provideInstanceEffect,
10  reloadInstance,
11  testInstanceStoreLayer,
12  tmpdirScoped,
13} from "../fixture/fixture"
14import { testEffect } from "../lib/effect"
15 
16const it = testEffect(Layer.mergeAll(LayerNode.compile(CrossSpawnSpawner.node), testInstanceStoreLayer))
17 
18const access = <A, E>(state: InstanceState.InstanceState<A, E>, dir: string) =>
19  InstanceState.get(state).pipe(provideInstanceEffect(dir))
20 
21const tmpdirGitScoped = Effect.gen(function* () {
22  const dir = yield* tmpdirScoped({ git: true })
23  yield* Effect.promise(() => $`git commit --allow-empty --amend -m ${`root commit ${dir}`}`.cwd(dir).quiet())
24  return dir
25})
26 
27it.live("InstanceState caches values per directory", () =>
28  Effect.gen(function* () {
29    const dir = yield* tmpdirScoped()
30    let n = 0
31    const state = yield* InstanceState.make(() => Effect.sync(() => ({ n: ++n })))
32 
33    const a = yield* access(state, dir)
34    const b = yield* access(state, dir)
35 
36    expect(a).toBe(b)
37    expect(n).toBe(1)
38  }),
39)
40 
41it.live("InstanceState isolates directories", () =>
42  Effect.gen(function* () {
43    const one = yield* tmpdirScoped()
44    const two = yield* tmpdirScoped()
45    let n = 0
46    const state = yield* InstanceState.make((dir) => Effect.sync(() => ({ dir, n: ++n })))
47 
48    const a = yield* access(state, one)
49    const b = yield* access(state, two)
50    const c = yield* access(state, one)
51 
52    expect(a).toBe(c)
53    expect(a).not.toBe(b)
54    expect(n).toBe(2)
55  }),
56)
57 
58it.live("InstanceState invalidates on reload", () =>
59  Effect.gen(function* () {
60    const dir = yield* tmpdirScoped()
61    const seen: string[] = []
62    let n = 0
63    const state = yield* InstanceState.make(() =>
64      Effect.acquireRelease(
65        Effect.sync(() => ({ n: ++n })),
66        (value) =>
67          Effect.sync(() => {
68            seen.push(String(value.n))
69          }),
70      ),
71    )
72 
73    const a = yield* access(state, dir)
74    yield* reloadInstance({ directory: dir })
75    const b = yield* access(state, dir)
76 
77    expect(a).not.toBe(b)
78    expect(seen).toEqual(["1"])
79  }),
80)
81 
82it.live("InstanceState invalidates on disposeAll", () =>
83  Effect.gen(function* () {
84    const one = yield* tmpdirScoped()
85    const two = yield* tmpdirScoped()
86    const seen: string[] = []
87    const state = yield* InstanceState.make((ctx) =>
88      Effect.acquireRelease(
89        Effect.sync(() => ({ dir: ctx.directory })),
90        (value) =>
91          Effect.sync(() => {
92            seen.push(value.dir)
93          }),
94      ),
95    )
96 
97    yield* access(state, one)
98    yield* access(state, two)
99    yield* disposeAllInstancesEffect
100 
101    expect(seen.sort()).toEqual([one, two].sort())
102  }),
103)
104 
105it.live("InstanceState.get reads the current directory lazily", () =>
106  Effect.gen(function* () {
107    const one = yield* tmpdirScoped()
108    const two = yield* tmpdirScoped()
109 
110    interface Api {
111      readonly get: () => Effect.Effect<string>
112    }
113 
114    class Test extends Context.Service<Test, Api>()("@test/InstanceStateLazy") {
115      static readonly layer = Layer.effect(
116        Test,
117        Effect.gen(function* () {
118          const state = yield* InstanceState.make((ctx) => Effect.sync(() => ctx.directory))
119          const get = InstanceState.get(state)
120 
121          return Test.of({
122            get: Effect.fn("Test.get")(function* () {
123              return yield* get
124            }),
125          })
126        }),
127      )
128    }
129 
130    yield* Effect.gen(function* () {
131      const a = yield* Test.use((svc) => svc.get()).pipe(provideInstanceEffect(one))
132      const b = yield* Test.use((svc) => svc.get()).pipe(provideInstanceEffect(two))
133 
134      expect(a).toBe(one)
135      expect(b).toBe(two)
136    }).pipe(Effect.provide(Test.layer))
137  }),
138)
139 
140it.live("InstanceState preserves directory across async boundaries", () =>
141  Effect.gen(function* () {
142    const one = yield* tmpdirGitScoped
143    const two = yield* tmpdirGitScoped
144    const three = yield* tmpdirGitScoped
145 
146    interface Api {
147      readonly get: () => Effect.Effect<{ directory: string; worktree: string; project: string }>
148    }
149 
150    class Test extends Context.Service<Test, Api>()("@test/InstanceStateAsync") {
151      static readonly layer = Layer.effect(
152        Test,
153        Effect.gen(function* () {
154          const state = yield* InstanceState.make((ctx) =>
155            Effect.sync(() => ({
156              directory: ctx.directory,
157              worktree: ctx.worktree,
158              project: ctx.project.id,
159            })),
160          )
161 
162          return Test.of({
163            get: Effect.fn("Test.get")(function* () {
164              yield* Effect.sleep(Duration.millis(1))
165              yield* Effect.sleep(Duration.millis(1))
166              for (let i = 0; i < 100; i++) {
167                yield* Effect.yieldNow
168              }
169              for (let i = 0; i < 100; i++) {
170                yield* Effect.promise(() => Promise.resolve())
171              }
172              yield* Effect.sleep(Duration.millis(2))
173              yield* Effect.sleep(Duration.millis(1))
174              return yield* InstanceState.get(state)
175            }),
176          })
177        }),
178      )
179    }
180 
181    yield* Effect.gen(function* () {
182      const [a, b, c] = yield* Effect.all(
183        [one, two, three].map((dir) => Test.use((svc) => svc.get()).pipe(provideInstanceEffect(dir))),
184        { concurrency: "unbounded" },
185      )
186 
187      expect(a).toEqual({ directory: one, worktree: one, project: a.project })
188      expect(b).toEqual({ directory: two, worktree: two, project: b.project })
189      expect(c).toEqual({ directory: three, worktree: three, project: c.project })
190      expect(a.project).not.toBe(b.project)
191      expect(a.project).not.toBe(c.project)
192      expect(b.project).not.toBe(c.project)
193    }).pipe(Effect.provide(Test.layer))
194  }),
195)
196 
197it.live("InstanceState survives high-contention concurrent access", () =>
198  Effect.gen(function* () {
199    const dirs = yield* Effect.all(
200      Array.from({ length: 20 }, () => tmpdirScoped()),
201      { concurrency: "unbounded" },
202    )
203 
204    interface Api {
205      readonly get: () => Effect.Effect<string>
206    }
207 
208    class Test extends Context.Service<Test, Api>()("@test/HighContention") {
209      static readonly layer = Layer.effect(
210        Test,
211        Effect.gen(function* () {
212          const state = yield* InstanceState.make((ctx) => Effect.sync(() => ctx.directory))
213 
214          return Test.of({
215            get: Effect.fn("Test.get")(function* () {
216              for (let i = 0; i < 10; i++) {
217                yield* Effect.sleep(Duration.millis(Math.random() * 3))
218                yield* Effect.yieldNow
219                yield* Effect.promise(() => Promise.resolve())
220              }
221              return yield* InstanceState.get(state)
222            }),
223          })
224        }),
225      )
226    }
227 
228    yield* Effect.gen(function* () {
229      const results = yield* Effect.all(
230        dirs.map((dir) => Test.use((svc) => svc.get()).pipe(provideInstanceEffect(dir))),
231        { concurrency: "unbounded" },
232      )
233 
234      expect(results).toEqual(dirs)
235    }).pipe(Effect.provide(Test.layer))
236  }),
237)
238 
239it.live("InstanceState correct after interleaved init and dispose", () =>
240  Effect.gen(function* () {
241    const one = yield* tmpdirScoped()
242    const two = yield* tmpdirScoped()
243 
244    interface Api {
245      readonly get: () => Effect.Effect<string>
246    }
247 
248    class Test extends Context.Service<Test, Api>()("@test/InterleavedDispose") {
249      static readonly layer = Layer.effect(
250        Test,
251        Effect.gen(function* () {
252          const state = yield* InstanceState.make((ctx) =>
253            Effect.gen(function* () {
254              yield* Effect.sleep(Duration.millis(5))
255              return ctx.directory
256            }),
257          )
258 
259          return Test.of({
260            get: Effect.fn("Test.get")(function* () {
261              return yield* InstanceState.get(state)
262            }),
263          })
264        }),
265      )
266    }
267 
268    yield* Effect.gen(function* () {
269      const a = yield* Test.use((svc) => svc.get()).pipe(provideInstanceEffect(one))
270      expect(a).toBe(one)
271 
272      const [, b] = yield* Effect.all(
273        [reloadInstance({ directory: one }), Test.use((svc) => svc.get()).pipe(provideInstanceEffect(two))],
274        { concurrency: "unbounded" },
275      )
276      expect(b).toBe(two)
277 
278      const c = yield* Test.use((svc) => svc.get()).pipe(provideInstanceEffect(one))
279      expect(c).toBe(one)
280    }).pipe(Effect.provide(Test.layer))
281  }),
282)
283 
284it.live("InstanceState mutation in one directory does not leak to another", () =>
285  Effect.gen(function* () {
286    const one = yield* tmpdirScoped()
287    const two = yield* tmpdirScoped()
288    const state = yield* InstanceState.make(() => Effect.sync(() => ({ count: 0 })))
289 
290    const s1 = yield* access(state, one)
291    s1.count = 42
292 
293    const s2 = yield* access(state, two)
294    expect(s2.count).toBe(0)
295 
296    const s1again = yield* access(state, one)
297    expect(s1again.count).toBe(42)
298    expect(s1again).toBe(s1)
299  }),
300)
301 
302it.live("InstanceState dedupes concurrent lookups", () =>
303  Effect.gen(function* () {
304    const dir = yield* tmpdirScoped()
305    let n = 0
306    const state = yield* InstanceState.make(() =>
307      Effect.gen(function* () {
308        n += 1
309        yield* Effect.sleep(Duration.millis(10))
310        return { n }
311      }),
312    )
313 
314    const [a, b] = yield* Effect.all([access(state, dir), access(state, dir)], { concurrency: "unbounded" })
315    expect(a).toBe(b)
316    expect(n).toBe(1)
317  }),
318)
319 
320it.live("InstanceState survives deferred resume from the same instance context", () =>
321  Effect.gen(function* () {
322    const dir = yield* tmpdirScoped({ git: true })
323 
324    interface Api {
325      readonly get: (gate: Deferred.Deferred<void>) => Effect.Effect<string>
326    }
327 
328    class Test extends Context.Service<Test, Api>()("@test/DeferredResume") {
329      static readonly layer = Layer.effect(
330        Test,
331        Effect.gen(function* () {
332          const state = yield* InstanceState.make((ctx) => Effect.sync(() => ctx.directory))
333 
334          return Test.of({
335            get: Effect.fn("Test.get")(function* (gate: Deferred.Deferred<void>) {
336              yield* Deferred.await(gate)
337              return yield* InstanceState.get(state)
338            }),
339          })
340        }),
341      )
342    }
343 
344    yield* Effect.gen(function* () {
345      const gate = yield* Deferred.make<void>()
346      const fiber = yield* Test.use((svc) => svc.get(gate)).pipe(provideInstanceEffect(dir), Effect.forkScoped)
347 
348      yield* Deferred.succeed(gate, undefined).pipe(provideInstanceEffect(dir))
349      const exit = yield* Fiber.await(fiber)
350 
351      expect(Exit.isSuccess(exit)).toBe(true)
352      if (Exit.isSuccess(exit)) expect(exit.value).toBe(dir)
353    }).pipe(Effect.provide(Test.layer))
354  }),
355)
356 
357it.live("InstanceState survives deferred resume outside ALS when InstanceRef is set", () =>
358  Effect.gen(function* () {
359    const dir = yield* tmpdirScoped({ git: true })
360 
361    interface Api {
362      readonly get: (gate: Deferred.Deferred<void>) => Effect.Effect<string>
363    }
364 
365    class Test extends Context.Service<Test, Api>()("@test/DeferredResumeOutside") {
366      static readonly layer = Layer.effect(
367        Test,
368        Effect.gen(function* () {
369          const state = yield* InstanceState.make((ctx) => Effect.sync(() => ctx.directory))
370 
371          return Test.of({
372            get: Effect.fn("Test.get")(function* (gate: Deferred.Deferred<void>) {
373              yield* Deferred.await(gate)
374              return yield* InstanceState.get(state)
375            }),
376          })
377        }),
378      )
379    }
380 
381    yield* Effect.gen(function* () {
382      const gate = yield* Deferred.make<void>()
383      const fiber = yield* Test.use((svc) => svc.get(gate)).pipe(provideInstanceEffect(dir), Effect.forkScoped)
384 
385      yield* Deferred.succeed(gate, undefined)
386      const exit = yield* Fiber.await(fiber)
387 
388      expect(Exit.isSuccess(exit)).toBe(true)
389      if (Exit.isSuccess(exit)) expect(exit.value).toBe(dir)
390    }).pipe(Effect.provide(Test.layer))
391  }),
392)
393