openAgent

1import fs from "fs/promises"
2import path from "path"
3import { describe, expect } from "bun:test"
4import { Deferred, Effect, Fiber, Layer } from "effect"
5import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
6import { LayerNode } from "@opencode-ai/core/effect/layer-node"
7import { FileMutation } from "@opencode-ai/core/file-mutation"
8import { FSUtil } from "@opencode-ai/core/fs-util"
9import { Location } from "@opencode-ai/core/location"
10import { LocationMutation } from "@opencode-ai/core/location-mutation"
11import { AbsolutePath } from "@opencode-ai/core/schema"
12import { location } from "./fixture/location"
13import { tmpdir } from "./fixture/tmpdir"
14import { it } from "./lib/effect"
15 
16function provide(directory: string, filesystemLayer = LayerNode.compile(FSUtil.node)) {
17  const activeLocation = Layer.succeed(
18    Location.Service,
19    Location.Service.of(location({ directory: AbsolutePath.make(directory) })),
20  )
21  return Effect.provide(
22    AppNodeBuilder.build(LayerNode.group([LocationMutation.node, FileMutation.node]), [
23      [Location.node, activeLocation],
24      [FSUtil.node, filesystemLayer],
25    ]),
26  )
27}
28 
29function withTmp<A, E, R>(f: (directory: string) => Effect.Effect<A, E, R>) {
30  return Effect.acquireRelease(
31    Effect.promise(() => tmpdir()),
32    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
33  ).pipe(Effect.flatMap((tmp) => f(tmp.path)))
34}
35 
36describe("FileMutation", () => {
37  it.live("writes an existing internal file and returns a stable result", () =>
38    withTmp((directory) =>
39      Effect.gen(function* () {
40        const targetPath = path.join(directory, "hello.txt")
41        yield* Effect.promise(() => fs.writeFile(targetPath, "before"))
42        const target = yield* (yield* LocationMutation.Service).resolve({ path: "hello.txt" })
43 
44        expect(yield* (yield* FileMutation.Service).write({ target, content: "after" })).toEqual({
45          operation: "write",
46          target: target.canonical,
47          resource: "hello.txt",
48          existed: true,
49        })
50        expect(yield* Effect.promise(() => fs.readFile(targetPath, "utf8"))).toBe("after")
51      }).pipe(provide(directory)),
52    ),
53  )
54 
55  it.live("writes a prospective internal file and creates parent directories", () =>
56    withTmp((directory) =>
57      Effect.gen(function* () {
58        const target = yield* (yield* LocationMutation.Service).resolve({
59          path: path.join("src", "nested", "hello.txt"),
60        })
61        const result = yield* (yield* FileMutation.Service).write({ target, content: "hello" })
62 
63        expect(result).toEqual({
64          operation: "write",
65          target: target.canonical,
66          resource: "src/nested/hello.txt",
67          existed: false,
68        })
69        expect(yield* Effect.promise(() => fs.readFile(result.target, "utf8"))).toBe("hello")
70      }).pipe(provide(directory)),
71    ),
72  )
73 
74  it.live("preserves exactly one BOM for text writes and normalizes created text", () =>
75    withTmp((directory) =>
76      Effect.gen(function* () {
77        const preservedPath = path.join(directory, "preserved.txt")
78        yield* Effect.promise(() => fs.writeFile(preservedPath, "\uFEFFbefore"))
79        const preserved = yield* (yield* LocationMutation.Service).resolve({ path: "preserved.txt" })
80        const created = yield* (yield* LocationMutation.Service).resolve({ path: "created.txt" })
81        const files = yield* FileMutation.Service
82 
83        yield* files.writeTextPreservingBom({ target: preserved, content: "\uFEFFafter" })
84        yield* files.writeTextPreservingBom({ target: created, content: "\uFEFF\uFEFF\uFEFFcreated" })
85 
86        expect(yield* Effect.promise(() => fs.readFile(preservedPath, "utf8"))).toBe("\uFEFFafter")
87        expect(yield* Effect.promise(() => fs.readFile(created.canonical, "utf8"))).toBe("\uFEFFcreated")
88      }).pipe(provide(directory)),
89    ),
90  )
91 
92  it.live("rejects create when a prospective target appears after resolution", () =>
93    withTmp((directory) =>
94      Effect.gen(function* () {
95        const targetPath = path.join(directory, "appeared.txt")
96        const target = yield* (yield* LocationMutation.Service).resolve({ path: "appeared.txt" })
97        yield* Effect.promise(() => fs.writeFile(targetPath, "winner"))
98 
99        expect(
100          yield* (yield* FileMutation.Service).create({ target, content: "replacement" }).pipe(Effect.flip),
101        ).toMatchObject({
102          _tag: "FileMutation.TargetExistsError",
103        })
104        expect(yield* Effect.promise(() => fs.readFile(targetPath, "utf8"))).toBe("winner")
105      }).pipe(provide(directory)),
106    ),
107  )
108 
109  it.live("creates when an existing target disappears after resolution", () =>
110    withTmp((directory) =>
111      Effect.gen(function* () {
112        const targetPath = path.join(directory, "removed.txt")
113        yield* Effect.promise(() => fs.writeFile(targetPath, "before"))
114        const target = yield* (yield* LocationMutation.Service).resolve({ path: "removed.txt" })
115        yield* Effect.promise(() => fs.rm(targetPath))
116 
117        expect(yield* (yield* FileMutation.Service).create({ target, content: "after" })).toEqual({
118          operation: "write",
119          target: target.canonical,
120          resource: "removed.txt",
121          existed: false,
122        })
123        expect(yield* Effect.promise(() => fs.readFile(targetPath, "utf8"))).toBe("after")
124      }).pipe(provide(directory)),
125    ),
126  )
127 
128  it.live("removes an existing internal file", () =>
129    withTmp((directory) =>
130      Effect.gen(function* () {
131        const targetPath = path.join(directory, "remove.txt")
132        yield* Effect.promise(() => fs.writeFile(targetPath, "remove"))
133        const target = yield* (yield* LocationMutation.Service).resolve({ path: "remove.txt" })
134        const result = yield* (yield* FileMutation.Service).remove({ target })
135 
136        expect(result).toEqual({
137          operation: "remove",
138          target: target.canonical,
139          resource: "remove.txt",
140          existed: true,
141        })
142        expect(
143          yield* Effect.promise(() =>
144            fs.stat(targetPath).then(
145              () => true,
146              () => false,
147            ),
148          ),
149        ).toBe(false)
150      }).pipe(provide(directory)),
151    ),
152  )
153 
154  it.live("writes an explicitly resolved external target", () =>
155    withTmp((directory) =>
156      withTmp((outside) =>
157        Effect.gen(function* () {
158          const targetPath = path.join(outside, "external.txt")
159          const target = yield* (yield* LocationMutation.Service).resolve({ path: targetPath })
160          const result = yield* (yield* FileMutation.Service).write({ target, content: "external" })
161 
162          expect(result).toEqual({
163            operation: "write",
164            target: target.canonical,
165            resource: target.resource,
166            existed: false,
167          })
168          expect(yield* Effect.promise(() => fs.readFile(targetPath, "utf8"))).toBe("external")
169        }).pipe(provide(directory)),
170      ),
171    ),
172  )
173 
174  it.live("removes an explicitly resolved external target", () =>
175    withTmp((directory) =>
176      withTmp((outside) =>
177        Effect.gen(function* () {
178          const targetPath = path.join(outside, "external.txt")
179          yield* Effect.promise(() => fs.writeFile(targetPath, "external"))
180          const target = yield* (yield* LocationMutation.Service).resolve({ path: targetPath })
181          const result = yield* (yield* FileMutation.Service).remove({ target })
182 
183          expect(result).toEqual({
184            operation: "remove",
185            target: target.canonical,
186            resource: target.resource,
187            existed: true,
188          })
189          expect(
190            yield* Effect.promise(() =>
191              fs.stat(targetPath).then(
192                () => true,
193                () => false,
194              ),
195            ),
196          ).toBe(false)
197        }).pipe(provide(directory)),
198      ),
199    ),
200  )
201 
202  it.live("reports a missing target as not removed without checking existence first", () =>
203    withTmp((directory) =>
204      Effect.gen(function* () {
205        const target = yield* (yield* LocationMutation.Service).resolve({ path: "missing.txt" })
206 
207        expect(yield* (yield* FileMutation.Service).remove({ target })).toEqual({
208          operation: "remove",
209          target: target.canonical,
210          resource: "missing.txt",
211          existed: false,
212        })
213      }).pipe(provide(directory)),
214    ),
215  )
216 
217  it.live("serializes concurrent writes to the same canonical target", () =>
218    withTmp((directory) =>
219      Effect.gen(function* () {
220        const targetPath = path.join(directory, "shared.txt")
221        yield* Effect.promise(() => fs.writeFile(targetPath, "initial"))
222        const firstStarted = yield* Deferred.make<void>()
223        const releaseFirst = yield* Deferred.make<void>()
224        const secondStarted = yield* Deferred.make<void>()
225        let writes = 0
226        const filesystem = instrumentWrites((write) =>
227          Effect.gen(function* () {
228            writes++
229            if (writes === 1) {
230              yield* Deferred.succeed(firstStarted, undefined)
231              yield* Deferred.await(releaseFirst)
232            } else {
233              yield* Deferred.succeed(secondStarted, undefined)
234            }
235            yield* write
236          }),
237        )
238 
239        yield* Effect.gen(function* () {
240          const mutation = yield* LocationMutation.Service
241          const files = yield* FileMutation.Service
242          const firstPlan = yield* mutation.resolve({ path: "shared.txt" })
243          const secondPlan = yield* mutation.resolve({ path: "shared.txt" })
244          const first = yield* files.write({ target: firstPlan, content: "first" }).pipe(Effect.forkChild)
245          yield* Deferred.await(firstStarted)
246          const second = yield* files.write({ target: secondPlan, content: "second" }).pipe(Effect.forkChild)
247          yield* Effect.yieldNow
248          expect(yield* Deferred.isDone(secondStarted)).toBe(false)
249 
250          yield* Deferred.succeed(releaseFirst, undefined)
251          yield* Deferred.await(secondStarted)
252          yield* Fiber.join(first)
253          yield* Fiber.join(second)
254          expect(yield* Effect.promise(() => fs.readFile(targetPath, "utf8"))).toBe("second")
255        }).pipe(provide(directory, filesystem))
256      }),
257    ),
258  )
259 
260  it.live("allows only one concurrent conditional write based on the same bytes", () =>
261    withTmp((directory) =>
262      Effect.gen(function* () {
263        const targetPath = path.join(directory, "shared.txt")
264        yield* Effect.promise(() => fs.writeFile(targetPath, "initial"))
265        const firstStarted = yield* Deferred.make<void>()
266        const releaseFirst = yield* Deferred.make<void>()
267        let writes = 0
268        const filesystem = instrumentWrites((write) =>
269          Effect.gen(function* () {
270            writes++
271            if (writes === 1) {
272              yield* Deferred.succeed(firstStarted, undefined)
273              yield* Deferred.await(releaseFirst)
274            }
275            yield* write
276          }),
277        )
278 
279        yield* Effect.gen(function* () {
280          const mutation = yield* LocationMutation.Service
281          const files = yield* FileMutation.Service
282          const target = yield* mutation.resolve({ path: "shared.txt" })
283          const expected = new TextEncoder().encode("initial")
284          const first = yield* files.writeIfUnchanged({ target, expected, content: "first" }).pipe(Effect.forkChild)
285          yield* Deferred.await(firstStarted)
286          const second = yield* files
287            .writeIfUnchanged({ target, expected, content: "second" })
288            .pipe(Effect.flip, Effect.forkChild)
289 
290          yield* Deferred.succeed(releaseFirst, undefined)
291          yield* Fiber.join(first)
292          expect(yield* Fiber.join(second)).toMatchObject({ _tag: "FileMutation.StaleContentError" })
293          expect(yield* Effect.promise(() => fs.readFile(targetPath, "utf8"))).toBe("first")
294          expect(writes).toBe(1)
295        }).pipe(provide(directory, filesystem))
296      }),
297    ),
298  )
299 
300  it.live("rejects a conditional write when target content is already stale", () =>
301    withTmp((directory) =>
302      Effect.gen(function* () {
303        const targetPath = path.join(directory, "stale.txt")
304        yield* Effect.promise(() => fs.writeFile(targetPath, "current"))
305        const target = yield* (yield* LocationMutation.Service).resolve({ path: "stale.txt" })
306 
307        expect(
308          yield* (yield* FileMutation.Service)
309            .writeIfUnchanged({ target, expected: new TextEncoder().encode("older"), content: "replacement" })
310            .pipe(Effect.flip),
311        ).toMatchObject({ _tag: "FileMutation.StaleContentError", path: target.canonical })
312        expect(yield* Effect.promise(() => fs.readFile(targetPath, "utf8"))).toBe("current")
313      }).pipe(provide(directory)),
314    ),
315  )
316 
317  it.live("allows distinct canonical targets to proceed independently", () =>
318    withTmp((directory) =>
319      Effect.gen(function* () {
320        const firstStarted = yield* Deferred.make<void>()
321        const releaseFirst = yield* Deferred.make<void>()
322        const secondFinished = yield* Deferred.make<void>()
323        const secondPath = path.join(directory, "second.txt")
324        let writes = 0
325        const filesystem = instrumentWrites((write) =>
326          ++writes === 1
327            ? Deferred.succeed(firstStarted, undefined).pipe(
328                Effect.andThen(Deferred.await(releaseFirst)),
329                Effect.andThen(write),
330              )
331            : write.pipe(Effect.andThen(Deferred.succeed(secondFinished, undefined))),
332        )
333 
334        yield* Effect.gen(function* () {
335          const mutation = yield* LocationMutation.Service
336          const files = yield* FileMutation.Service
337          const firstPlan = yield* mutation.resolve({ path: "first.txt" })
338          const secondPlan = yield* mutation.resolve({ path: "second.txt" })
339          const first = yield* files.write({ target: firstPlan, content: "first" }).pipe(Effect.forkChild)
340          yield* Deferred.await(firstStarted)
341          const second = yield* files.write({ target: secondPlan, content: "second" }).pipe(Effect.forkChild)
342          yield* Deferred.await(secondFinished)
343          expect(yield* Effect.promise(() => fs.readFile(secondPath, "utf8"))).toBe("second")
344 
345          yield* Deferred.succeed(releaseFirst, undefined)
346          yield* Fiber.join(first)
347          yield* Fiber.join(second)
348        }).pipe(provide(directory, filesystem))
349      }),
350    ),
351  )
352})
353 
354function instrumentWrites(run: <E>(write: Effect.Effect<void, E>, target: string) => Effect.Effect<void, E>) {
355  return Layer.effect(
356    FSUtil.Service,
357    Effect.gen(function* () {
358      const filesystem = yield* FSUtil.Service
359      return FSUtil.Service.of({
360        ...filesystem,
361        writeWithDirs: (target, content, mode) => run(filesystem.writeWithDirs(target, content, mode), target),
362        writeFile: (target, content, options) => run(filesystem.writeFile(target, content, options), target),
363        writeFileString: (target, content, options) =>
364          run(filesystem.writeFileString(target, content, options), target),
365      })
366    }),
367  ).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
368}
369