kohsteal.test.ts

1/**2 * The joint public-steal contract (addendum A2, item 8d): one machine publishes a repo to a bucket,3 * Kepr serves it read-only over HTTP in Koh's own layout, a second `koh3` steals it — and later,4 * once that machine has signed in, offers its work back to the bucket.5 *6 * There is no S3 on a test host, so the bucket is a fake one served here; koh3 is run as the real7 * installed binary (`koh3` on PATH, the same one this suite is pinned to). The account of what the8 * fake bucket accepts is in its own class: signatures are ignored rather than verified, which is9 * the one way this test is easier than the real thing.10 */11import { describe, expect, test } from "bun:test";12import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";13import { tmpdir } from "node:os";14import { join } from "node:path";15import type { Hono } from "hono";16import { openBucket } from "../src/bucket/reader.ts";17import { syncAll } from "../src/bucket/sync.ts";18import { createApp } from "../src/server/app.ts";19import { openKeprDb } from "../src/server/db.ts";20import { Browser, PASSWORD } from "./browser.ts";21import { stripPath } from "./fixture.ts";2223const REPO = "shipped";24const PRIVATE_REPO = "kept";25const BUCKET = "kohbucket";26const ACCESS = "fake-access";27const SECRET = "fake-secret";28/** The command deadline: two koh3 runs talk to a local server, so this is generous. */29const RUN = 60_000;3031/**32 * The fake bucket runs as its own process: the koh3 calls below are synchronous (`koh3` blocks the33 * event loop), so an in-process server would never answer them. `tests/fake-s3.ts` prints its34 * endpoint on stdout.35 */36async function startBucket(): Promise<{ endpoint: string; stop: () => void }> {37	const proc = Bun.spawn(["bun", "run", join(import.meta.dir, "fake-s3.ts")], {38		stdout: "pipe",39		stderr: "inherit",40	});41	const reader = proc.stdout.getReader();42	const first = await reader.read();43	const endpoint =44		new TextDecoder()45			.decode(first.value ?? new Uint8Array())46			.trim()47			.split("\n")[0] ?? "";48	reader.releaseLock();49	expect(endpoint).toStartWith("http://127.0.0.1:");50	return { endpoint, stop: () => proc.kill() };51}5253type Ran = { code: number; out: string; err: string };5455/** The real koh3, with a throwaway HOME so no test ever touches the operator's config. */56async function koh3(57	cwd: string,58	home: string,59	args: string[],60	env: Record<string, string> = {},61): Promise<Ran> {62	const proc = Bun.spawn(["koh3", ...args], {63		cwd,64		env: { PATH: process.env.PATH, HOME: home, NO_COLOR: "1", ...env },65		stdout: "pipe",66		stderr: "pipe",67	});68	const [out, err, code] = await Promise.all([69		new Response(proc.stdout).text(),70		new Response(proc.stderr).text(),71		proc.exited,72	]);73	return { code, out, err };74}7576/** The whole line, every field of every save: what a clone must reproduce exactly. */77async function line(repo: string, home: string): Promise<unknown> {78	return JSON.parse((await koh3(repo, home, ["view", "--json"])).out).saves;79}8081describe.serial("stealing a public repo from Kepr over HTTP", () => {82	test(83		"a clone comes over the wire, stays read-only, and follows its source",84		async () => {85			const root = await mkdtemp(join(tmpdir(), "kepr-steal-"));86			const bucketServer = await startBucket();87			const endpoint = bucketServer.endpoint;88			const keys = { KOH_ACCESS_KEY: ACCESS, KOH_SECRET_KEY: SECRET };89			try {90				// The owner: a small repo in a bucket, offered on every save.91				const ownerHome = join(root, "owner-home");92				const ownerDir = join(root, "owner");93				const repoDir = join(ownerDir, REPO);94				const keptDir = join(ownerDir, PRIVATE_REPO);95				await mkdir(ownerHome, { recursive: true });96				await mkdir(repoDir, { recursive: true });97				await mkdir(keptDir, { recursive: true });98				expect((await koh3(repoDir, ownerHome, ["init"], keys)).code).toBe(0);99				expect(100					(await koh3(repoDir, ownerHome, ["remote", "s3", endpoint, BUCKET, "fr-par"], keys)).code,101				).toBe(0);102				await writeFile(join(repoDir, "README.md"), "# shipped\n\nA repo to steal.\n");103				await writeFile(join(repoDir, "src.v"), "fn main() {}\n");104				expect((await koh3(repoDir, ownerHome, ["save", "first save"])).code).toBe(0);105				await writeFile(join(repoDir, "README.md"), "# shipped\n\nA repo to steal, edited.\n");106				expect((await koh3(repoDir, ownerHome, ["save", "second save"])).code).toBe(0);107				// A second repo, never made public on Kepr: only a signed-in machine may have it.108				expect((await koh3(keptDir, ownerHome, ["init"], keys)).code).toBe(0);109				expect(110					(await koh3(keptDir, ownerHome, ["remote", "s3", endpoint, BUCKET, "fr-par"], keys)).code,111				).toBe(0);112				await writeFile(join(keptDir, "secret.txt"), "kept in the bucket\n");113				expect((await koh3(keptDir, ownerHome, ["save", "a private repo"])).code).toBe(0);114115				// Kepr, reading that bucket: the shipped repo is public, the kept one is not.116				const dataDir = await mkdtemp(join(tmpdir(), "kepr-steal-kepr-"));117				const kepr = openKeprDb(dataDir);118				const bucket = {119					kind: "s3" as const,120					endpoint,121					name: BUCKET,122					region: "fr-par",123					accessKeyId: ACCESS,124					secretAccessKey: SECRET,125				};126				/** Kepr syncs on its own loop in production; here each new save is synced by hand. */127				const sync = () =>128					syncAll({129						bucket: openBucket(bucket),130						kepr,131						mirrorDir: join(dataDir, "mirror"),132						tarballDir: join(dataDir, "tarballs"),133					});134				await sync();135				kepr.query("UPDATE repos SET public = 1 WHERE name = ?").run(REPO);136				let app: Hono;137				const server = Bun.serve({138					port: 0,139					fetch: (request) => app.fetch(request),140				});141				app = createApp(142					{143						domain: `127.0.0.1:${server.port}`,144						dataDir,145						adminPasswordHash: await Bun.password.hash(PASSWORD, "argon2id"),146						bucket: { ...bucket, write: { accessKeyId: ACCESS, secretAccessKey: SECRET } },147					},148					kepr,149				);150				const host = `http://127.0.0.1:${server.port}`;151152				// The second machine: nothing but a HOME and the address it was told.153				const thiefHome = join(root, "thief-home");154				const thiefDir = join(root, "thief");155				await mkdir(thiefHome, { recursive: true });156				await mkdir(thiefDir, { recursive: true });157				const stolen = await koh3(thiefDir, thiefHome, ["steal", `${host}/${REPO}`]);158				expect(stolen.code, stolen.err + stolen.out).toBe(0);159				const clone = join(thiefDir, REPO);160				expect(await readFile(join(clone, "README.md"), "utf8")).toContain("edited");161				expect((await koh3(clone, thiefHome, ["doctor"])).code).toBe(0);162				// Save for save, the clone is the line the owner published.163				expect(await line(clone, thiefHome)).toEqual(await line(repoDir, ownerHome));164				// The source is remembered, and shown above the machine's remote.165				expect((await koh3(clone, thiefHome, ["remote"])).out).toContain(`${host}/${REPO}`);166				// And it cannot be offered: it has no bucket of its own.167				const refused = await koh3(clone, thiefHome, ["offer"]);168				expect(refused.code).toBe(1);169				expect(refused.err + refused.out).toContain("which is read-only");170171				// A later public save arrives on a bare `koh steal`.172				await writeFile(join(repoDir, "README.md"), "# shipped\n\nA third save.\n");173				expect((await koh3(repoDir, ownerHome, ["save", "third save"])).code).toBe(0);174				await sync();175				expect((await koh3(clone, thiefHome, ["steal"])).code).toBe(0);176				expect(await readFile(join(clone, "README.md"), "utf8")).toContain("A third save");177178				// A strip on the source side reaches the mirror, and is honoured: history no longer179				// holds the path, so a fresh clone never sees the file at all. On the machine that180				// already had it the file stays on disk — a strip is not a delete — but it is banned:181				// not unsaved work, and never saved again.182				await stripPath(repoDir, ownerHome, "src.v");183				// The strip wrote `/src.v` into `.kohignore`; the next save carries the rule everywhere.184				expect(await readFile(join(repoDir, ".kohignore"), "utf8")).toContain("/src.v\n");185				expect((await koh3(repoDir, ownerHome, ["save", "ignore the stripped src.v"])).code).toBe(186					0,187				);188				await sync();189				expect((await koh3(clone, thiefHome, ["steal"])).code).toBe(0);190				expect((await koh3(clone, thiefHome, ["doctor"])).code).toBe(0);191				expect(await Bun.file(join(clone, "src.v")).exists()).toBe(true);192				expect((await koh3(clone, thiefHome, ["status"])).out).not.toContain("src.v");193				const fresh = join(root, "thief-again");194				await mkdir(fresh, { recursive: true });195				expect((await koh3(fresh, thiefHome, ["steal", `${host}/${REPO}`])).code).toBe(0);196				expect(await Bun.file(join(fresh, REPO, "src.v")).exists()).toBe(false);197198				// Signing in: a code from the connect page, read the way `koh` reads it.199				// This Kepr's domain is the loopback address it is served on, so the same-origin200				// checks want that origin, not the Browser's default.201				const origin = `https://127.0.0.1:${server.port}`;202				const browser = new Browser(app);203				const signInPage = await browser.get("/sign-in");204				const form = /name="form" value="([^"]+)"/.exec(await signInPage.text())?.[1] ?? "";205				const signed = await browser.request("/sign-in", {206					method: "POST",207					headers: { origin },208					body: new URLSearchParams({ form, password: PASSWORD }),209				});210				expect(signed.status).toBe(303);211				const machine = "thief-machine";212				expect((await browser.get(`/connect?machine=${machine}`)).status).toBe(200);213				const shown = await browser.post("/connect", { machine }, origin);214				const code = /class="mono code">([^<]+)</.exec(await shown.text())?.[1]?.trim() ?? "";215				expect(code).toMatch(/^[A-Z2-9]{4}-[A-Z2-9]{4}$/);216				const signedIn = await koh3(thiefDir, thiefHome, ["remote", host, "--code", code]);217				expect(signedIn.code, signedIn.err + signedIn.out).toBe(0);218219				// A save made before the upgrade is local work and nothing else: it must not write to220				// the bucket, and it must not quietly drop the source on its own.221				await writeFile(join(clone, "local.txt"), "work in progress\n");222				const local = await koh3(clone, thiefHome, ["save", "local only"]);223				expect(local.code, local.err + local.out).toBe(0);224				expect(local.out + local.err).not.toContain("offered");225				expect((await koh3(clone, thiefHome, ["remote"])).out).toContain(`${host}/${REPO}`);226227				// The next offer drops the source: the repo is this machine's own work now; offer is228				// the path the addendum names for the owner case.229				const upgraded = await koh3(clone, thiefHome, ["offer"]);230				expect(upgraded.code, upgraded.err + upgraded.out).toBe(0);231				expect(upgraded.out + upgraded.err).toContain("now syncs with your bucket");232				// The owner can read what that offer published, before anything else is saved: the233				// local save the clone was carrying went up with it.234				expect((await koh3(repoDir, ownerHome, ["revert", "--yes"])).code).toBe(0);235				expect((await koh3(repoDir, ownerHome, ["steal"])).code).toBe(0);236				expect(await readFile(join(repoDir, "local.txt"), "utf8")).toContain("work in progress");237				expect(JSON.parse((await koh3(repoDir, ownerHome, ["view", "--json"])).out).saves).toEqual(238					JSON.parse((await koh3(clone, thiefHome, ["view", "--json"])).out).saves,239				);240				await writeFile(join(clone, "README.md"), "# shipped\n\nThe thief's edit.\n");241				expect((await koh3(clone, thiefHome, ["save", "from the thief"])).code).toBe(0);242				expect((await koh3(repoDir, ownerHome, ["steal"])).code).toBe(0);243				expect(await readFile(join(repoDir, "README.md"), "utf8")).toContain("The thief's edit");244245				// The other clone still rides its source. When both sides changed the same file,246				// offer without a terminal refuses as steal would, and never picks a side itself:247				// the file is named, steal is where to choose, and the source stays.248				const other = join(fresh, REPO);249				await writeFile(join(repoDir, "README.md"), "# shipped\n\nThe owner's edit.\n");250				expect((await koh3(repoDir, ownerHome, ["save", "owner edits the readme"])).code).toBe(0);251				await writeFile(join(other, "README.md"), "# shipped\n\nThe other clone's edit.\n");252				expect((await koh3(other, thiefHome, ["save", "other clone edits"])).code).toBe(0);253				const clashed = await koh3(other, thiefHome, ["offer"]);254				expect(clashed.code).toBe(1);255				expect(clashed.err).toContain(256					'README.md changed on both machines — run "koh steal" to choose, then offer',257				);258				expect(await readFile(join(other, "README.md"), "utf8")).toContain("other clone's edit");259				expect((await koh3(other, thiefHome, ["remote"])).out).toContain(`${host}/${REPO}`);260				// Choosing there upgrades the clone, and says where the version it gave up lives.261				const chosen = await koh3(other, thiefHome, ["steal", "--theirs"]);262				expect(chosen.code, chosen.err + chosen.out).toBe(0);263				expect(chosen.out + chosen.err).toContain("now syncs with your bucket");264				expect(chosen.out + chosen.err).toContain("your README.md is in");265				expect(await readFile(join(other, "README.md"), "utf8")).toContain("The owner's edit");266267				// A repo the public side never serves clones from the bucket once signed in.268				const second = join(root, "thief-two");269				await mkdir(second, { recursive: true });270				const kept = await koh3(second, thiefHome, ["steal", `${host}/${PRIVATE_REPO}`]);271				expect(kept.code, kept.err + kept.out).toBe(0);272				expect(await readFile(join(second, PRIVATE_REPO, "secret.txt"), "utf8")).toContain("kept");273				// And it is a normal repo: the machine's own remote is untouched by any of this.274				expect((await koh3(second, thiefHome, ["remote"])).out).toContain(`s3 ${endpoint}`);275			} finally {276				bucketServer.stop();277			}278		},279		RUN,280	);281});