openAgent

1import { describe, expect } from "bun:test"
2import { $ } from "bun"
3import fs from "fs/promises"
4import path from "path"
5import { eq } from "drizzle-orm"
6import { Effect, Fiber, Stream } from "effect"
7import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
8import { LayerNode } from "@opencode-ai/core/effect/layer-node"
9import { AbsolutePath } from "@opencode-ai/core/schema"
10import { Git } from "@opencode-ai/core/git"
11import { Database } from "@opencode-ai/core/database/database"
12import { EventV2 } from "@opencode-ai/core/event"
13import { Project } from "@opencode-ai/core/project"
14import { ProjectDirectoryTable, ProjectTable } from "@opencode-ai/core/project/sql"
15import { ProjectCopy } from "@opencode-ai/core/project/copy"
16import { ProjectDirectories } from "@opencode-ai/core/project/directories"
17import { tmpdir } from "./fixture/tmpdir"
18import { testEffect } from "./lib/effect"
19 
20const it = testEffect(
21  AppNodeBuilder.build(LayerNode.group([ProjectCopy.node, Database.node, EventV2.node, ProjectDirectories.node])),
22)
23 
24function abs(input: string) {
25  return AbsolutePath.make(input)
26}
27 
28const gitWorktree = ProjectCopy.StrategyID.make("git_worktree")
29 
30async function initRepo(directory: string) {
31  await $`git init`.cwd(directory).quiet()
32  await $`git config core.fsmonitor false`.cwd(directory).quiet()
33  await $`git config commit.gpgsign false`.cwd(directory).quiet()
34  await $`git config user.email test@opencode.test`.cwd(directory).quiet()
35  await $`git config user.name Test`.cwd(directory).quiet()
36  await $`git commit --allow-empty -m root`.cwd(directory).quiet()
37}
38 
39function setup() {
40  return Effect.gen(function* () {
41    const root = yield* Effect.acquireRelease(
42      Effect.promise(() => tmpdir()),
43      (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
44    )
45    yield* Effect.promise(() => initRepo(root.path))
46    const sourceDirectory = abs(yield* Effect.promise(() => fs.realpath(root.path)))
47    const projectID = Project.ID.make("copy-project")
48    const { db } = yield* Database.Service
49    yield* db
50      .insert(ProjectTable)
51      .values({ id: projectID, worktree: sourceDirectory, sandboxes: [], time_created: 1, time_updated: 1 })
52      .run()
53      .pipe(Effect.orDie)
54    yield* db
55      .insert(ProjectDirectoryTable)
56      .values({ project_id: projectID, directory: sourceDirectory })
57      .run()
58      .pipe(Effect.orDie)
59    return { root, sourceDirectory, projectID, db }
60  })
61}
62 
63function stored(projectID: Project.ID) {
64  return Database.Service.use(({ db }) =>
65    db
66      .select({ directory: ProjectDirectoryTable.directory, strategy: ProjectDirectoryTable.strategy })
67      .from(ProjectDirectoryTable)
68      .where(eq(ProjectDirectoryTable.project_id, projectID))
69      .all()
70      .pipe(
71        Effect.orDie,
72        Effect.map((rows) => rows.toSorted((a, b) => a.directory.localeCompare(b.directory))),
73      ),
74  )
75}
76 
77describe("ProjectCopy", () => {
78  it.effect("accepts arbitrary non-empty strategy ids", () =>
79    Effect.sync(() => {
80      expect(String(ProjectCopy.StrategyID.make("acme/snapshot"))).toBe("acme/snapshot")
81      expect(() => ProjectCopy.StrategyID.make("  acme/snapshot  ")).toThrow()
82      expect(() => ProjectCopy.StrategyID.make("   ")).toThrow()
83    }),
84  )
85 
86  it.effect("rejects duplicate strategies and reports unavailable ids", () =>
87    Effect.gen(function* () {
88      const input = yield* setup()
89      const copy = yield* ProjectCopy.Service
90      const strategy: ProjectCopy.Strategy = {
91        id: ProjectCopy.StrategyID.make("test/duplicate"),
92        create: () => Effect.die("unused"),
93        remove: () => Effect.die("unused"),
94        list: () => Effect.succeed([]),
95      }
96 
97      yield* copy.register(strategy)
98      expect(yield* copy.register(strategy).pipe(Effect.flip)).toBeInstanceOf(ProjectCopy.DuplicateStrategyError)
99 
100      const unavailable = ProjectCopy.StrategyID.make("acme/missing")
101      const error = yield* copy
102        .create({
103          projectID: input.projectID,
104          strategy: unavailable,
105          sourceDirectory: input.sourceDirectory,
106          directory: abs(`${input.root.path}-missing-strategy`),
107          name: "copy",
108        })
109        .pipe(Effect.flip)
110      expect(error).toBeInstanceOf(ProjectCopy.StrategyUnavailableError)
111      if (error instanceof ProjectCopy.StrategyUnavailableError) expect(error.strategy).toBe(unavailable)
112    }),
113  )
114 
115  it.live("creates and removes a git worktree directory", () =>
116    Effect.gen(function* () {
117      const input = yield* setup()
118      const copy = yield* ProjectCopy.Service
119      const events = yield* EventV2.Service
120      const temp = yield* Effect.promise(() => fs.realpath(path.dirname(input.root.path)))
121      const parent = abs(path.join(temp, path.basename(input.root.path) + "-copy-created"))
122      const target = abs(path.join(parent, "copy"))
123      yield* Effect.addFinalizer(() =>
124        Effect.promise(() => fs.rm(parent, { recursive: true, force: true })).pipe(Effect.ignore),
125      )
126      const fiber = yield* events
127        .subscribe(ProjectCopy.Event.Updated)
128        .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
129      yield* Effect.yieldNow
130 
131      const created = yield* copy.create({
132        projectID: input.projectID,
133        strategy: gitWorktree,
134        sourceDirectory: input.sourceDirectory,
135        directory: parent,
136        name: "copy",
137      })
138      expect(created.directory).toBe(target)
139      expect(yield* stored(input.projectID)).toEqual(
140        [
141          { directory: input.sourceDirectory, strategy: null },
142          { directory: created.directory, strategy: "git_worktree" },
143        ].toSorted((a, b) => a.directory.localeCompare(b.directory)),
144      )
145      expect(Array.from(yield* Fiber.join(fiber))[0]?.data).toEqual({ projectID: input.projectID })
146 
147      yield* copy.remove({ projectID: input.projectID, directory: created.directory, force: false })
148 
149      expect(yield* stored(input.projectID)).toEqual([{ directory: input.sourceDirectory, strategy: null }])
150      expect(yield* Effect.promise(() => Bun.file(target).exists())).toBe(false)
151    }),
152  )
153 
154  it.live("requires force to remove a dirty git worktree", () =>
155    Effect.gen(function* () {
156      const input = yield* setup()
157      const copy = yield* ProjectCopy.Service
158      const temp = yield* Effect.promise(() => fs.realpath(path.dirname(input.root.path)))
159      const parent = abs(path.join(temp, path.basename(input.root.path) + "-copy-dirty"))
160      yield* Effect.addFinalizer(() =>
161        Effect.promise(() => fs.rm(parent, { recursive: true, force: true })).pipe(Effect.ignore),
162      )
163      const created = yield* copy.create({
164        projectID: input.projectID,
165        strategy: gitWorktree,
166        sourceDirectory: input.sourceDirectory,
167        directory: parent,
168        name: "copy",
169      })
170      yield* Effect.promise(() => Bun.write(path.join(created.directory, "dirty.txt"), "dirty"))
171 
172      const error = yield* copy
173        .remove({ projectID: input.projectID, directory: created.directory, force: false })
174        .pipe(Effect.flip)
175 
176      expect(error).toBeInstanceOf(Git.WorktreeError)
177      if (error instanceof Git.WorktreeError) {
178        expect(error.operation).toBe("remove")
179        expect(error.forceRequired).toBe(true)
180      }
181      expect(yield* stored(input.projectID)).toContainEqual({ directory: created.directory, strategy: "git_worktree" })
182      expect(yield* Effect.promise(() => Bun.file(path.join(created.directory, "dirty.txt")).exists())).toBe(true)
183 
184      yield* copy.remove({ projectID: input.projectID, directory: created.directory, force: true })
185      expect(yield* Effect.promise(() => Bun.file(created.directory).exists())).toBe(false)
186    }),
187  )
188 
189  it.live("preserves copies whose stored strategy is unavailable", () =>
190    Effect.gen(function* () {
191      const input = yield* setup()
192      const copy = yield* ProjectCopy.Service
193      const unavailable = abs(`${input.root.path}-copy-unavailable`)
194      yield* Effect.promise(() => fs.mkdir(unavailable))
195      yield* Effect.addFinalizer(() => Effect.promise(() => fs.rm(unavailable, { recursive: true, force: true })))
196      yield* input.db
197        .insert(ProjectDirectoryTable)
198        .values({ project_id: input.projectID, directory: unavailable, strategy: "acme/missing" })
199        .run()
200        .pipe(Effect.orDie)
201 
202      const error = yield* copy
203        .remove({ projectID: input.projectID, directory: unavailable, force: false })
204        .pipe(Effect.flip)
205 
206      expect(error).toBeInstanceOf(ProjectCopy.StrategyUnavailableError)
207      expect(yield* stored(input.projectID)).toContainEqual({ directory: unavailable, strategy: "acme/missing" })
208    }),
209  )
210 
211  it.live("adds a numeric suffix when a copy directory already exists", () =>
212    Effect.gen(function* () {
213      const input = yield* setup()
214      const copy = yield* ProjectCopy.Service
215      const temp = yield* Effect.promise(() => fs.realpath(path.dirname(input.root.path)))
216      const parent = abs(path.join(temp, path.basename(input.root.path) + "-copy-suffix"))
217      const target = abs(path.join(parent, "copy-3"))
218      yield* Effect.addFinalizer(() =>
219        Effect.promise(() => fs.rm(parent, { recursive: true, force: true })).pipe(Effect.ignore),
220      )
221      yield* Effect.promise(() => fs.mkdir(path.join(parent, "copy"), { recursive: true }))
222      yield* Effect.promise(() => fs.mkdir(path.join(parent, "copy-2")))
223 
224      const created = yield* copy.create({
225        projectID: input.projectID,
226        strategy: gitWorktree,
227        sourceDirectory: input.sourceDirectory,
228        directory: parent,
229        name: "copy",
230      })
231 
232      expect(created.directory).toBe(target)
233      expect(yield* Effect.promise(() => fs.stat(path.join(parent, "copy")).then((item) => item.isDirectory()))).toBe(
234        true,
235      )
236      expect(yield* Effect.promise(() => fs.stat(path.join(parent, "copy-2")).then((item) => item.isDirectory()))).toBe(
237        true,
238      )
239 
240      yield* copy.remove({ projectID: input.projectID, directory: created.directory, force: false })
241    }),
242  )
243 
244  it.live("fails after ten copy directory conflicts", () =>
245    Effect.gen(function* () {
246      const input = yield* setup()
247      const copy = yield* ProjectCopy.Service
248      const temp = yield* Effect.promise(() => fs.realpath(path.dirname(input.root.path)))
249      const parent = abs(path.join(temp, path.basename(input.root.path) + "-copy-conflicts"))
250      yield* Effect.addFinalizer(() =>
251        Effect.promise(() => fs.rm(parent, { recursive: true, force: true })).pipe(Effect.ignore),
252      )
253      yield* Effect.promise(() =>
254        Promise.all(
255          Array.from({ length: 10 }, (_, index) =>
256            fs.mkdir(path.join(parent, index === 0 ? "copy" : `copy-${index + 1}`), { recursive: true }),
257          ),
258        ),
259      )
260 
261      const error = yield* copy
262        .create({
263          projectID: input.projectID,
264          strategy: gitWorktree,
265          sourceDirectory: input.sourceDirectory,
266          directory: parent,
267          name: "copy",
268        })
269        .pipe(Effect.flip)
270 
271      expect(error).toBeInstanceOf(ProjectCopy.DestinationExistsError)
272      if (error instanceof ProjectCopy.DestinationExistsError)
273        expect(error.directory).toBe(abs(path.join(parent, "copy-10")))
274    }),
275  )
276 
277  it.live("does not publish an event when refresh finds no directory changes", () =>
278    Effect.gen(function* () {
279      const input = yield* setup()
280      const copy = yield* ProjectCopy.Service
281      const events = yield* EventV2.Service
282      const event = yield* events.subscribe(ProjectCopy.Event.Updated).pipe(
283        Stream.take(1),
284        Stream.runCollect,
285        Effect.forkScoped,
286        Effect.flatMap((fiber) =>
287          Effect.gen(function* () {
288            yield* Effect.yieldNow
289            yield* copy.refresh({ projectID: input.projectID })
290            return yield* Fiber.join(fiber).pipe(Effect.timeoutOption("50 millis"))
291          }),
292        ),
293      )
294 
295      expect(event._tag).toBe("None")
296    }),
297  )
298 
299  it.live("refresh discovers and prunes an externally managed git worktree", () =>
300    Effect.gen(function* () {
301      const input = yield* setup()
302      const copy = yield* ProjectCopy.Service
303      const events = yield* EventV2.Service
304      const target = abs(`${input.root.path}-copy-external`)
305      yield* Effect.addFinalizer(() =>
306        Effect.promise(() => fs.rm(target, { recursive: true, force: true })).pipe(Effect.ignore),
307      )
308      yield* Effect.promise(() => $`git worktree add --detach ${target} HEAD`.cwd(input.root.path).quiet())
309      yield* input.db
310        .insert(ProjectDirectoryTable)
311        .values({ project_id: input.projectID, directory: target })
312        .run()
313        .pipe(Effect.orDie)
314      const fiber = yield* events
315        .subscribe(ProjectCopy.Event.Updated)
316        .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
317      yield* Effect.yieldNow
318 
319      const discovered = abs(yield* Effect.promise(() => fs.realpath(target)))
320      expect(yield* copy.refresh({ projectID: input.projectID })).toEqual({ updated: [discovered], removed: [] })
321 
322      expect(yield* stored(input.projectID)).toEqual(
323        [
324          { directory: input.sourceDirectory, strategy: null },
325          { directory: discovered, strategy: "git_worktree" },
326        ].toSorted((a, b) => a.directory.localeCompare(b.directory)),
327      )
328      expect(Array.from(yield* Fiber.join(fiber))[0]?.data).toEqual({ projectID: input.projectID })
329 
330      yield* Effect.promise(() => $`git worktree remove --force ${target}`.cwd(input.root.path).quiet())
331      expect(yield* copy.refresh({ projectID: input.projectID })).toEqual({ updated: [], removed: [discovered] })
332      expect(yield* stored(input.projectID)).toEqual([{ directory: input.sourceDirectory, strategy: null }])
333    }),
334  )
335 
336  it.live("refresh ignores stale git worktree registrations", () =>
337    Effect.gen(function* () {
338      const input = yield* setup()
339      const copy = yield* ProjectCopy.Service
340      const stale = abs(`${input.root.path}-copy-stale`)
341      const target = abs(`${input.root.path}-copy-after-stale`)
342      yield* Effect.addFinalizer(() =>
343        Effect.promise(() => fs.rm(target, { recursive: true, force: true })).pipe(Effect.ignore),
344      )
345      yield* Effect.promise(() => $`git worktree add --detach ${stale} HEAD`.cwd(input.root.path).quiet())
346      yield* Effect.promise(() => fs.rm(stale, { recursive: true, force: true }))
347      yield* Effect.promise(() => $`git worktree add --detach ${target} HEAD`.cwd(input.root.path).quiet())
348 
349      yield* copy.refresh({ projectID: input.projectID })
350 
351      const discovered = abs(yield* Effect.promise(() => fs.realpath(target)))
352      expect(yield* stored(input.projectID)).toEqual(
353        [
354          { directory: input.sourceDirectory, strategy: null },
355          { directory: discovered, strategy: "git_worktree" },
356        ].toSorted((a, b) => a.directory.localeCompare(b.directory)),
357      )
358    }),
359  )
360 
361  it.live("refresh ignores existing directories that are no longer git checkouts", () =>
362    Effect.gen(function* () {
363      const input = yield* setup()
364      yield* Effect.promise(() => fs.rm(path.join(input.sourceDirectory, ".git"), { recursive: true }))
365      const copy = yield* ProjectCopy.Service
366 
367      yield* copy.refresh({ projectID: input.projectID })
368 
369      expect(yield* stored(input.projectID)).toEqual([{ directory: input.sourceDirectory, strategy: null }])
370    }),
371  )
372 
373  it.live("refresh with no roots is a no-op", () =>
374    Effect.gen(function* () {
375      const copy = yield* ProjectCopy.Service
376 
377      expect(yield* copy.refresh({ projectID: Project.ID.make("missing-project") })).toEqual({
378        updated: [],
379        removed: [],
380      })
381    }),
382  )
383 
384  it.live("refresh removes missing ordinary checkouts", () =>
385    Effect.gen(function* () {
386      const input = yield* setup()
387      const missing = abs(`${input.root.path}-missing-checkout`)
388      yield* input.db
389        .insert(ProjectDirectoryTable)
390        .values({ project_id: input.projectID, directory: missing })
391        .run()
392        .pipe(Effect.orDie)
393      const copy = yield* ProjectCopy.Service
394 
395      expect(yield* copy.refresh({ projectID: input.projectID })).toEqual({ updated: [], removed: [missing] })
396 
397      expect(yield* stored(input.projectID)).not.toContainEqual({ directory: missing, strategy: null })
398    }),
399  )
400})
401