openAgent

1import fs from "fs/promises"
2import path from "path"
3import { describe, expect } from "bun:test"
4import { Deferred, Effect, Exit, 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 { PermissionV2 } from "@opencode-ai/core/permission"
12import { AbsolutePath } from "@opencode-ai/core/schema"
13import { SessionV2 } from "@opencode-ai/core/session"
14import { ToolRegistry } from "@opencode-ai/core/tool/registry"
15import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
16import { ApplyPatchTool } from "@opencode-ai/core/tool/apply-patch"
17import { location } from "./fixture/location"
18import { tmpdir } from "./fixture/tmpdir"
19import { testEffect } from "./lib/effect"
20import { toolIdentity, executeTool, settleTool, toolDefinitions } from "./lib/tool"
21 
22const sessionID = SessionV2.ID.make("ses_apply_patch_tool_test")
23const assertions: PermissionV2.AssertInput[] = []
24let denyAction: string | undefined
25let failRemoveTarget: string | undefined
26let readsBeforeEditApproval = 0
27let editApproved = false
28let blockRemoveTarget: string | undefined
29let removeStarted: Deferred.Deferred<void> | undefined
30let releaseRemove: Deferred.Deferred<void> | undefined
31let afterEditApproval = (): Effect.Effect<void> => Effect.void
32 
33const permission = Layer.succeed(
34  PermissionV2.Service,
35  PermissionV2.Service.of({
36    assert: (input) =>
37      Effect.sync(() => {
38        assertions.push(input)
39        if (input.action === "edit") editApproved = true
40      }).pipe(
41        Effect.andThen(input.action === "edit" ? Effect.suspend(afterEditApproval) : Effect.void),
42        Effect.andThen(
43          input.action === denyAction ? Effect.fail(new PermissionV2.BlockedError({ rules: [] })) : Effect.void,
44        ),
45      ),
46    ask: () => Effect.die("unused"),
47    reply: () => Effect.die("unused"),
48    get: () => Effect.die("unused"),
49    forSession: () => Effect.die("unused"),
50    list: () => Effect.die("unused"),
51  }),
52)
53 
54const reset = () => {
55  assertions.length = 0
56  denyAction = undefined
57  failRemoveTarget = undefined
58  readsBeforeEditApproval = 0
59  editApproved = false
60  blockRemoveTarget = undefined
61  removeStarted = undefined
62  releaseRemove = undefined
63  afterEditApproval = () => Effect.void
64}
65 
66const filesystem = Layer.effect(
67  FSUtil.Service,
68  Effect.gen(function* () {
69    const fs = yield* FSUtil.Service
70    return FSUtil.Service.of({
71      ...fs,
72      readFile: (target) =>
73        Effect.sync(() => {
74          if (!editApproved) readsBeforeEditApproval++
75        }).pipe(Effect.andThen(fs.readFile(target))),
76      remove: (target, options) => {
77        if (failRemoveTarget && path.basename(target) === failRemoveTarget) return Effect.die("forced remove failure")
78        if (blockRemoveTarget && path.basename(target) === blockRemoveTarget && removeStarted && releaseRemove)
79          return Deferred.succeed(removeStarted, undefined).pipe(
80            Effect.andThen(Deferred.await(releaseRemove)),
81            Effect.andThen(fs.remove(target, options)),
82          )
83        return fs.remove(target, options)
84      },
85    })
86  }),
87).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
88 
89const withTool = <A, E, R>(directory: string, body: (registry: ToolRegistry.Interface) => Effect.Effect<A, E, R>) => {
90  const activeLocation = Layer.succeed(
91    Location.Service,
92    Location.Service.of(location({ directory: AbsolutePath.make(directory) })),
93  )
94  return Effect.gen(function* () {
95    return yield* body(yield* ToolRegistry.Service)
96  }).pipe(
97    Effect.provide(
98      AppNodeBuilder.build(
99        LayerNode.group([
100          ToolRegistry.node,
101          ToolRegistry.toolsNode,
102          LocationMutation.node,
103          FileMutation.node,
104          ApplyPatchTool.node,
105        ]),
106        [
107          [FSUtil.node, filesystem],
108          [Location.node, activeLocation],
109          [PermissionV2.node, permission],
110          [ToolOutputStore.node, ToolOutputStore.nodeWithoutConfig],
111        ],
112      ),
113    ),
114  )
115}
116 
117const call = (patchText: string, id = "call-apply-patch") => ({
118  sessionID,
119  ...toolIdentity,
120  call: { type: "tool-call" as const, id, name: "apply_patch", input: { patchText } },
121})
122 
123const exists = (target: string) =>
124  Effect.promise(() =>
125    fs.stat(target).then(
126      () => true,
127      () => false,
128    ),
129  )
130const it = testEffect(Layer.empty)
131 
132describe("ApplyPatchTool", () => {
133  it.live("registers and sequentially applies add, update, and delete hunks", () =>
134    Effect.acquireUseRelease(
135      Effect.promise(() => tmpdir()),
136      (tmp) => {
137        reset()
138        const update = path.join(tmp.path, "update.txt")
139        const remove = path.join(tmp.path, "remove.txt")
140        return Effect.promise(() =>
141          Promise.all([fs.writeFile(update, "before\n"), fs.writeFile(remove, "remove\n")]),
142        ).pipe(
143          Effect.andThen(
144            withTool(tmp.path, (registry) =>
145              Effect.gen(function* () {
146                expect((yield* toolDefinitions(registry)).map((tool) => tool.name)).toEqual(["apply_patch"])
147                const settled = yield* settleTool(
148                  registry,
149                  call(
150                    "*** Begin Patch\n*** Add File: nested/new.txt\n+created\n*** Update File: update.txt\n@@\n-before\n+after\n*** Delete File: remove.txt\n*** End Patch",
151                  ),
152                )
153                expect(settled.result).toEqual({
154                  type: "text",
155                  value: "Applied patch sequentially:\nA nested/new.txt\nM update.txt\nD remove.txt",
156                })
157                expect(settled.output?.structured).toMatchObject({
158                  applied: [
159                    { type: "add", resource: "nested/new.txt" },
160                    { type: "update", resource: "update.txt" },
161                    { type: "delete", resource: "remove.txt" },
162                  ],
163                  files: [
164                    {
165                      file: "nested/new.txt",
166                      status: "added",
167                      additions: 1,
168                      deletions: 0,
169                      patch: expect.stringContaining("+created"),
170                    },
171                    {
172                      file: "update.txt",
173                      status: "modified",
174                      additions: 1,
175                      deletions: 1,
176                      patch: expect.stringContaining("-before\n+after"),
177                    },
178                    {
179                      file: "remove.txt",
180                      status: "deleted",
181                      additions: 0,
182                      deletions: 1,
183                      patch: expect.stringContaining("-remove"),
184                    },
185                  ],
186                })
187                expect(assertions).toMatchObject([
188                  { sessionID, action: "edit", resources: ["nested/new.txt", "update.txt", "remove.txt"], save: ["*"] },
189                ])
190                expect(readsBeforeEditApproval).toBe(0)
191                expect(yield* Effect.promise(() => fs.readFile(path.join(tmp.path, "nested/new.txt"), "utf8"))).toBe(
192                  "created\n",
193                )
194                expect(yield* Effect.promise(() => fs.readFile(update, "utf8"))).toBe("after\n")
195                expect(yield* exists(remove)).toBe(false)
196              }),
197            ),
198          ),
199        )
200      },
201      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
202    ),
203  )
204 
205  it.live("rejects moves before applying any hunk", () =>
206    Effect.acquireUseRelease(
207      Effect.promise(() => tmpdir()),
208      (tmp) => {
209        reset()
210        const source = path.join(tmp.path, "old.txt")
211        return Effect.promise(() => fs.writeFile(source, "before\n")).pipe(
212          Effect.andThen(
213            withTool(tmp.path, (registry) =>
214              Effect.gen(function* () {
215                expect(
216                  yield* executeTool(
217                    registry,
218                    call(
219                      "*** Begin Patch\n*** Add File: created.txt\n+created\n*** Update File: old.txt\n*** Move to: moved.txt\n@@\n-before\n+after\n*** End Patch",
220                    ),
221                  ),
222                ).toEqual({ type: "error", value: "apply_patch moves are not supported yet" })
223                expect(yield* exists(path.join(tmp.path, "created.txt"))).toBe(false)
224                expect(assertions).toEqual([])
225              }),
226            ),
227          ),
228        )
229      },
230      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
231    ),
232  )
233 
234  it.live("approves an external directory and the batch before reading external update content", () =>
235    Effect.acquireUseRelease(
236      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
237      ([active, outside]) => {
238        reset()
239        const target = path.join(outside.path, "external.txt")
240        return Effect.promise(() => fs.writeFile(target, "before\n")).pipe(
241          Effect.andThen(
242            withTool(active.path, (registry) =>
243              Effect.gen(function* () {
244                expect(
245                  yield* executeTool(
246                    registry,
247                    call(`*** Begin Patch\n*** Update File: ${target}\n@@\n-before\n+after\n*** End Patch`),
248                  ),
249                ).toMatchObject({ type: "text" })
250                expect(assertions.map((input) => input.action)).toEqual(["external_directory", "edit"])
251                expect(readsBeforeEditApproval).toBe(0)
252                expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("after\n")
253              }),
254            ),
255          ),
256        )
257      },
258      ([active, outside]) =>
259        Effect.promise(() =>
260          Promise.all([active[Symbol.asyncDispose](), outside[Symbol.asyncDispose]()]).then(() => undefined),
261        ),
262    ),
263  )
264 
265  it.live("approves one external directory scope for multiple files under the same parent", () =>
266    Effect.acquireUseRelease(
267      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
268      ([active, outside]) => {
269        reset()
270        const first = path.join(outside.path, "first.txt")
271        const second = path.join(outside.path, "second.txt")
272        return Effect.promise(() =>
273          Promise.all([fs.writeFile(first, "before\n"), fs.writeFile(second, "before\n")]),
274        ).pipe(
275          Effect.andThen(
276            withTool(active.path, (registry) =>
277              Effect.gen(function* () {
278                expect(
279                  yield* executeTool(
280                    registry,
281                    call(
282                      `*** Begin Patch\n*** Update File: ${first}\n@@\n-before\n+after\n*** Update File: ${second}\n@@\n-before\n+after\n*** End Patch`,
283                    ),
284                  ),
285                ).toMatchObject({ type: "text" })
286                expect(assertions.map((input) => input.action)).toEqual(["external_directory", "edit"])
287                expect(assertions[0]?.resources).toEqual([
288                  path.join(yield* Effect.promise(() => fs.realpath(outside.path)), "*").replaceAll("\\", "/"),
289                ])
290              }),
291            ),
292          ),
293        )
294      },
295      ([active, outside]) =>
296        Effect.promise(() =>
297          Promise.all([active[Symbol.asyncDispose](), outside[Symbol.asyncDispose]()]).then(() => undefined),
298        ),
299    ),
300  )
301 
302  it.live("rejects invalid later update before applying an earlier add", () =>
303    Effect.acquireUseRelease(
304      Effect.promise(() => tmpdir()),
305      (tmp) => {
306        reset()
307        return withTool(tmp.path, (registry) =>
308          Effect.gen(function* () {
309            expect(
310              yield* executeTool(
311                registry,
312                call(
313                  "*** Begin Patch\n*** Add File: created.txt\n+created\n*** Update File: missing.txt\n@@\n-before\n+after\n*** End Patch",
314                ),
315              ),
316            ).toEqual({ type: "error", value: "Unable to apply patch at missing.txt" })
317            expect(yield* exists(path.join(tmp.path, "created.txt"))).toBe(false)
318          }),
319        )
320      },
321      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
322    ),
323  )
324 
325  it.live("rejects add hunks targeting an existing file without replacing it", () =>
326    Effect.acquireUseRelease(
327      Effect.promise(() => tmpdir()),
328      (tmp) => {
329        reset()
330        const target = path.join(tmp.path, "existing.txt")
331        return Effect.promise(() => fs.writeFile(target, "sentinel\n")).pipe(
332          Effect.andThen(
333            withTool(tmp.path, (registry) =>
334              Effect.gen(function* () {
335                expect(
336                  yield* executeTool(
337                    registry,
338                    call("*** Begin Patch\n*** Add File: existing.txt\n+replacement\n*** End Patch"),
339                  ),
340                ).toEqual({ type: "error", value: "Unable to apply patch at existing.txt" })
341                expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("sentinel\n")
342              }),
343            ),
344          ),
345        )
346      },
347      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
348    ),
349  )
350 
351  it.live("rejects an add target that appears during permission approval", () =>
352    Effect.acquireUseRelease(
353      Effect.promise(() => tmpdir()),
354      (tmp) => {
355        reset()
356        const target = path.join(tmp.path, "appeared.txt")
357        afterEditApproval = () => Effect.promise(() => fs.writeFile(target, "winner\n")).pipe(Effect.orDie)
358        return withTool(tmp.path, (registry) =>
359          Effect.gen(function* () {
360            expect(
361              yield* executeTool(
362                registry,
363                call("*** Begin Patch\n*** Add File: appeared.txt\n+replacement\n*** End Patch"),
364              ),
365            ).toEqual({ type: "error", value: "Unable to apply patch at appeared.txt" })
366            expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("winner\n")
367          }),
368        )
369      },
370      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
371    ),
372  )
373 
374  it.live("preserves a later commit defect after earlier sequential applications", () =>
375    Effect.acquireUseRelease(
376      Effect.promise(() => tmpdir()),
377      (tmp) => {
378        reset()
379        const first = path.join(tmp.path, "first.txt")
380        const second = path.join(tmp.path, "second.txt")
381        failRemoveTarget = path.basename(second)
382        return Effect.promise(() => Promise.all([fs.writeFile(first, "first"), fs.writeFile(second, "second")])).pipe(
383          Effect.andThen(
384            withTool(tmp.path, (registry) =>
385              Effect.gen(function* () {
386                expect(
387                  Exit.isFailure(
388                    yield* executeTool(
389                      registry,
390                      call("*** Begin Patch\n*** Delete File: first.txt\n*** Delete File: second.txt\n*** End Patch"),
391                    ).pipe(Effect.exit),
392                  ),
393                ).toBe(true)
394                expect(yield* exists(first)).toBe(false)
395                expect(yield* exists(second)).toBe(true)
396              }),
397            ),
398          ),
399        )
400      },
401      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
402    ),
403  )
404 
405  it.live("finishes the sequential commit phase when interrupted after the first mutation", () =>
406    Effect.acquireUseRelease(
407      Effect.promise(() => tmpdir()),
408      (tmp) => {
409        reset()
410        const first = path.join(tmp.path, "first.txt")
411        const second = path.join(tmp.path, "second.txt")
412        blockRemoveTarget = path.basename(second)
413        return Effect.gen(function* () {
414          removeStarted = yield* Deferred.make<void>()
415          releaseRemove = yield* Deferred.make<void>()
416          yield* Effect.promise(() => Promise.all([fs.writeFile(first, "first"), fs.writeFile(second, "second")]))
417          yield* withTool(tmp.path, (registry) =>
418            Effect.gen(function* () {
419              const run = yield* executeTool(
420                registry,
421                call("*** Begin Patch\n*** Delete File: first.txt\n*** Delete File: second.txt\n*** End Patch"),
422              ).pipe(Effect.forkChild)
423              yield* Deferred.await(removeStarted!)
424              const interrupt = yield* Fiber.interrupt(run).pipe(Effect.forkChild)
425              yield* Deferred.succeed(releaseRemove!, undefined)
426              yield* Fiber.join(interrupt)
427              expect(yield* exists(first)).toBe(false)
428              expect(yield* exists(second)).toBe(false)
429            }),
430          )
431        })
432      },
433      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
434    ),
435  )
436})
437