@markjaquith/agency 2.28.1 → 2.30.0

package/src/services/RepositoryService.test.ts

@@ -16,6 +16,40 @@ const runGit = async (args: string[]) => {
 	}
 }
 
+const portableRemote = (name: string) =>
+	`https://example.com/agency-tests/${name}.git`
+
+const setPortableOrigin = (path: string, name: string) =>
+	runGit(["-C", path, "remote", "add", "origin", portableRemote(name)])
+
+const startGitDaemon = async (basePath: string) => {
+	const port = 20000 + Math.floor(Math.random() * 20000)
+	const process = Bun.spawn(
+		[
+			"git",
+			"daemon",
+			"--reuseaddr",
+			"--export-all",
+			`--base-path=${basePath}`,
+			"--listen=127.0.0.1",
+			`--port=${port}`,
+			basePath,
+		],
+		{ stdout: "pipe", stderr: "pipe" },
+	)
+	const remote = `git://127.0.0.1:${port}/source.git`
+	for (let attempt = 0; attempt < 40; attempt++) {
+		const probe = Bun.spawn(["git", "ls-remote", remote], {
+			stdout: "ignore",
+			stderr: "ignore",
+		})
+		if ((await probe.exited) === 0) return { process, remote }
+		await Bun.sleep(25)
+	}
+	process.kill()
+	throw new Error("Git daemon did not start")
+}
+
 const write = async (root: string, path: string, content: string) => {
 	const fullPath = join(root, path)
 	await mkdir(dirname(fullPath), { recursive: true })
@@ -37,10 +71,11 @@ describe("RepositoryService", () => {
 	test("adds a bare repository from a remote", async () => {
 		const source = join(root, "source.git")
 		await runGit(["init", "--bare", "--initial-branch=main", source])
+		await setPortableOrigin(source, "agency")
 
 		const destination = await runTestEffect(
 			RepositoryService.pipe(
-				Effect.flatMap((service) => service.add("agency", source, root)),
+				Effect.flatMap((service) => service.add("agency", "source.git", root)),
 			),
 		)
 
@@ -55,8 +90,10 @@ describe("RepositoryService", () => {
 				alias: "agency",
 				path: destination,
 				kind: "bare",
-				remote: source,
+				remote: portableRemote("agency"),
+				declaredRemote: portableRemote("agency"),
 				target: null,
+				states: ["declared", "materialized"],
 			},
 		])
 	})
@@ -65,6 +102,7 @@ describe("RepositoryService", () => {
 		const target = join(root, "linked-repository")
 		await mkdir(target, { recursive: true })
 		await runGit(["init", "--initial-branch=main", target])
+		await setPortableOrigin(target, "effect")
 
 		const destination = await runTestEffect(
 			RepositoryService.pipe(
@@ -79,14 +117,17 @@ describe("RepositoryService", () => {
 			alias: "effect",
 			path: destination,
 			kind: "symlink",
-			remote: null,
+			remote: portableRemote("effect"),
+			declaredRemote: portableRemote("effect"),
 			target,
+			states: ["declared", "linked"],
 		})
 	})
 
 	test("rejects invalid and duplicate aliases", async () => {
 		const source = join(root, "source.git")
 		await runGit(["init", "--bare", "--initial-branch=main", source])
+		await setPortableOrigin(source, "duplicate")
 
 		await expect(
 			runTestEffect(
@@ -110,10 +151,96 @@ describe("RepositoryService", () => {
 		).rejects.toThrow("already exists")
 	})
 
+	test("leaves no declaration or materialization when cloning fails", async () => {
+		await expect(
+			runTestEffect(
+				RepositoryService.pipe(
+					Effect.flatMap((service) =>
+						service.add("failed", "git://127.0.0.1:1/missing.git", root),
+					),
+				),
+			),
+		).rejects.toThrow("Failed to clone repository")
+		expect(await Bun.file(join(root, "agency.json")).json()).toEqual({
+			version: 2,
+		})
+		expect(await Bun.file(join(root, "repos/failed")).exists()).toBe(false)
+	})
+
+	test("rolls back a repository move when config installation fails", async () => {
+		const source = join(root, "source.git")
+		await runGit(["init", "--bare", "--initial-branch=main", source])
+		await setPortableOrigin(source, "rollback")
+		await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) => service.add("old", source, root)),
+			),
+		)
+		const configBefore = await Bun.file(join(root, "agency.json")).text()
+		const originalWrite = Bun.write
+		;(Bun as { write: typeof Bun.write }).write = ((
+			destination: unknown,
+			data: unknown,
+		) =>
+			String(destination).includes(".agency-transaction-")
+				? Promise.reject(new Error("injected config write failure"))
+				: originalWrite(
+						destination as never,
+						data as never,
+					)) as typeof Bun.write
+
+		try {
+			await expect(
+				runTestEffect(
+					RepositoryService.pipe(
+						Effect.flatMap((service) => service.rename("old", "new", root)),
+					),
+				),
+			).rejects.toThrow("completed changes were rolled back")
+		} finally {
+			;(Bun as { write: typeof Bun.write }).write = originalWrite
+		}
+
+		expect(await Bun.file(join(root, "repos/old/HEAD")).exists()).toBe(true)
+		expect(await Bun.file(join(root, "repos/new/HEAD")).exists()).toBe(false)
+		expect(await Bun.file(join(root, "agency.json")).text()).toBe(configBefore)
+		expect(
+			(await Array.fromAsync(new Bun.Glob(".agency-*").scan(root))).length,
+		).toBe(0)
+	})
+
+	test("reports a file collision as invalid setup state", async () => {
+		await Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({
+				version: 2,
+				repositories: {
+					blocked: { remote: portableRemote("blocked") },
+				},
+			}),
+		)
+		await mkdir(join(root, "repos"), { recursive: true })
+		await Bun.write(join(root, "repos/blocked"), "not a repository")
+
+		const setup = await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) => service.setup({ cwd: root })),
+			),
+		)
+
+		expect(setup.actions).toEqual([])
+		expect(setup.repositories[0]?.states).toEqual(["declared", "invalid"])
+		expect(setup.unresolved[0]).toMatchObject({
+			alias: "blocked",
+			state: "invalid",
+		})
+	})
+
 	test("shows, fetches, updates, and verifies a repository", async () => {
 		const source = join(root, "source")
-		const replacement = join(root, "replacement.git")
+		const replacement = portableRemote("replacement")
 		await runGit(["init", "--initial-branch=main", source])
+		await setPortableOrigin(source, "source")
 		await Bun.write(join(source, "README.md"), "# Source\n")
 		await runGit(["-C", source, "add", "README.md"])
 		await runGit([
@@ -127,12 +254,18 @@ describe("RepositoryService", () => {
 			"-m",
 			"Initial commit",
 		])
-		await runGit(["init", "--bare", "--initial-branch=main", replacement])
 		await runTestEffect(
 			RepositoryService.pipe(
 				Effect.flatMap((service) => service.add("agency", source, root)),
 			),
 		)
+		await runGit([
+			"-C",
+			join(root, "repos/agency"),
+			"config",
+			`url.${source}.insteadOf`,
+			portableRemote("source"),
+		])
 
 		const result = await runTestEffect(
 			RepositoryService.pipe(
@@ -149,6 +282,7 @@ describe("RepositoryService", () => {
 		)
 
 		expect(result.shown.remote).toBe(source)
+		expect(result.shown.declaredRemote).toBe(portableRemote("source"))
 		expect(result.updated.remote).toBe(replacement)
 		expect(result.verified.valid).toBe(true)
 		expect(result.verified.issues).toEqual([])
@@ -157,6 +291,7 @@ describe("RepositoryService", () => {
 	test("renames and removes an unused repository", async () => {
 		const source = join(root, "source.git")
 		await runGit(["init", "--bare", "--initial-branch=main", source])
+		await setPortableOrigin(source, "rename")
 		await runTestEffect(
 			RepositoryService.pipe(
 				Effect.flatMap((service) => service.add("old", source, root)),
@@ -183,6 +318,7 @@ describe("RepositoryService", () => {
 		const target = join(root, "linked-repository")
 		await mkdir(target, { recursive: true })
 		await runGit(["init", "--initial-branch=main", target])
+		await setPortableOrigin(target, "linked")
 		await runTestEffect(
 			RepositoryService.pipe(
 				Effect.flatMap((service) => service.link("linked", target, root)),
@@ -199,11 +335,79 @@ describe("RepositoryService", () => {
 		expect(await Bun.file(join(root, "repos/linked/.git/HEAD")).exists()).toBe(
 			false,
 		)
+		const declared = await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) => service.show("linked", root)),
+			),
+		)
+		expect(declared.states).toEqual(["declared", "missing"])
+	})
+
+	test("refuses to unlink an alias with active references", async () => {
+		const target = join(root, "referenced-link")
+		await mkdir(target, { recursive: true })
+		await runGit(["init", "--initial-branch=main", target])
+		await setPortableOrigin(target, "referenced-link")
+		await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) => service.link("linked", target, root)),
+			),
+		)
+		await write(
+			root,
+			"tasks/active/TASK.md",
+			`---
+ticketUrl: null
+repo: linked
+branch: task/active-link
+base: main
+pr: null
+---
+`,
+		)
+
+		await expect(
+			runTestEffect(
+				RepositoryService.pipe(
+					Effect.flatMap((service) => service.unlink("linked", root)),
+				),
+			),
+		).rejects.toThrow("active reference execution-unit:task/active")
+		expect(await Bun.file(join(root, "repos/linked/.git/HEAD")).exists()).toBe(
+			true,
+		)
+	})
+
+	test("replaces an unused managed clone with a linked checkout", async () => {
+		const source = join(root, "source.git")
+		const target = join(root, "local-checkout")
+		await runGit(["init", "--bare", "--initial-branch=main", source])
+		await setPortableOrigin(source, "replace")
+		await mkdir(target, { recursive: true })
+		await runGit(["init", "--initial-branch=main", target])
+
+		const linked = await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) =>
+					Effect.gen(function* () {
+						yield* service.add("agency", source, root)
+						yield* service.link("agency", target, root)
+						return yield* service.show("agency", root)
+					}),
+				),
+			),
+		)
+
+		expect(linked.kind).toBe("symlink")
+		expect(linked.target).toBe(target)
+		expect(linked.declaredRemote).toBe(portableRemote("replace"))
+		expect(linked.states).toEqual(["declared", "linked", "remote-drifted"])
 	})
 
 	test("reports active references and refuses unsafe removal", async () => {
 		const source = join(root, "source.git")
 		await runGit(["init", "--bare", "--initial-branch=main", source])
+		await setPortableOrigin(source, "referenced")
 		await runTestEffect(
 			RepositoryService.pipe(
 				Effect.flatMap((service) => service.add("agency", source, root)),
@@ -231,4 +435,94 @@ pr: null
 		).rejects.toThrow("active reference execution-unit:task/active")
 		expect(await Bun.file(join(root, "repos/agency/HEAD")).exists()).toBe(true)
 	})
+
+	test("plans and applies missing portable repository setup", async () => {
+		const source = join(root, "source.git")
+		await runGit(["init", "--bare", "--initial-branch=main", source])
+		const daemon = await startGitDaemon(root)
+		try {
+			await Bun.write(
+				join(root, "agency.json"),
+				JSON.stringify({
+					version: 2,
+					repositories: { agency: { remote: daemon.remote } },
+				}),
+			)
+
+			const result = await runTestEffect(
+				RepositoryService.pipe(
+					Effect.flatMap((service) =>
+						Effect.gen(function* () {
+							const planned = yield* service.setup({ cwd: root })
+							const absent = !(yield* Effect.promise(() =>
+								Bun.file(join(root, "repos/agency/HEAD")).exists(),
+							))
+							const applied = yield* service.setup({ cwd: root, apply: true })
+							return { planned, absent, applied }
+						}),
+					),
+				),
+			)
+
+			expect(result.planned.mode).toBe("dry-run")
+			expect(result.planned.actions[0]).toMatchObject({
+				kind: "materialize",
+				status: "planned",
+			})
+			expect(result.absent).toBe(true)
+			expect(result.applied.actions[0]?.status).toBe("applied")
+			expect(result.applied.repositories[0]?.states).toEqual([
+				"declared",
+				"materialized",
+			])
+			expect(await Bun.file(join(root, "repos/agency/HEAD")).exists()).toBe(
+				true,
+			)
+		} finally {
+			daemon.process.kill()
+			await daemon.process.exited
+		}
+	})
+
+	test("adopts legacy materializations and reports remote drift", async () => {
+		const legacy = join(root, "repos/legacy")
+		await mkdir(legacy, { recursive: true })
+		await runGit(["init", "--initial-branch=main", legacy])
+		await setPortableOrigin(legacy, "legacy")
+
+		const result = await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) =>
+					Effect.gen(function* () {
+						const planned = yield* service.setup({ cwd: root })
+						const applied = yield* service.setup({ cwd: root, apply: true })
+						yield* Effect.promise(() =>
+							runGit([
+								"-C",
+								legacy,
+								"remote",
+								"set-url",
+								"origin",
+								"https://example.com/agency-tests/changed.git",
+							]),
+						)
+						const drifted = yield* service.show("legacy", root)
+						const setup = yield* service.setup({ cwd: root })
+						return { planned, applied, drifted, setup }
+					}),
+				),
+			),
+		)
+
+		expect(result.planned.actions[0]?.kind).toBe("adopt")
+		expect(result.applied.repositories[0]?.states).toEqual([
+			"declared",
+			"materialized",
+		])
+		expect(result.drifted.states).toContain("remote-drifted")
+		expect(result.setup.unresolved[0]).toMatchObject({
+			alias: "legacy",
+			state: "remote-drifted",
+		})
+	})
 })