@serverkgg/bridge 0.0.7 → 0.0.9

package/src/runtime/bridgeFiles.test.ts

@@ -1,9 +1,12 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
+import { deflateRawSync } from "node:zlib";
 import type { BridgeFiles } from "../context";
-import type { BridgeEgress } from "./bridgeEgress";
+import { BridgeDownloadError } from "../core";
+import { type BridgeEgress, BridgeEgressCallError } from "./bridgeEgress";
 import { createBridgeFiles } from "./bridgeFiles";
+import type { BridgeLeveledLogger } from "./bridgeLog";
 
 const LOCAL_SIGNATURE = 0x04_03_4b_50;
 
@@ -11,6 +14,26 @@ const CENTRAL_SIGNATURE = 0x02_01_4b_50;
 
 const EOCD_SIGNATURE = 0x06_05_4b_50;
 
+const ZIP64_LOCATOR_SIGNATURE = 0x07_06_4b_50;
+
+const ZIP64_EOCD_SIGNATURE = 0x06_06_4b_50;
+
+const ZIP64_EXTRA_ID = 0x00_01;
+
+const ZIP64_EXTRA_LENGTH = 28;
+
+const ZIP64_EOCD_LENGTH = 56;
+
+const ZIP64_LOCATOR_LENGTH = 20;
+
+const COUNT_SENTINEL = 0xff_ff;
+
+const SIZE_SENTINEL = 0xff_ff_ff_ff;
+
+const STORED = 0;
+
+const DEFLATED = 8;
+
 const FILE_ATTRIBUTES = 0x81_a4_00_00;
 
 const SYMLINK_ATTRIBUTES = 0xa1_ff_00_00;
@@ -19,9 +42,15 @@ interface ArchiveEntry {
 	name: string;
 	content: string;
 	symlink?: boolean;
+	compressed?: Buffer;
 }
 
-const buildZip = (entries: ArchiveEntry[]) => {
+interface ArchiveOptions {
+	zip64?: boolean;
+}
+
+const buildZip = (entries: ArchiveEntry[], archiveOptions: ArchiveOptions = {}) => {
+	const zip64 = archiveOptions.zip64 === true;
 	const locals: Buffer[] = [];
 	const centrals: Buffer[] = [];
 
@@ -29,28 +58,43 @@ const buildZip = (entries: ArchiveEntry[]) => {
 
 	for (const entry of entries) {
 		const name = Buffer.from(entry.name, "utf8");
-		const data = Buffer.from(entry.content, "utf8");
+		const plain = Buffer.from(entry.content, "utf8");
+		const data = entry.compressed ?? plain;
+		const method = entry.compressed === undefined ? STORED : DEFLATED;
 
 		const local = Buffer.alloc(30);
 
 		local.writeUInt32LE(LOCAL_SIGNATURE, 0);
 		local.writeUInt16LE(20, 4);
+		local.writeUInt16LE(method, 8);
 		local.writeUInt32LE(data.length, 18);
-		local.writeUInt32LE(data.length, 22);
+		local.writeUInt32LE(plain.length, 22);
 		local.writeUInt16LE(name.length, 26);
 
+		const extra = Buffer.alloc(zip64 ? ZIP64_EXTRA_LENGTH : 0);
+
+		if (zip64) {
+			extra.writeUInt16LE(ZIP64_EXTRA_ID, 0);
+			extra.writeUInt16LE(ZIP64_EXTRA_LENGTH - 4, 2);
+			extra.writeBigUInt64LE(BigInt(plain.length), 4);
+			extra.writeBigUInt64LE(BigInt(data.length), 12);
+			extra.writeBigUInt64LE(BigInt(offset), 20);
+		}
+
 		const central = Buffer.alloc(46);
 
 		central.writeUInt32LE(CENTRAL_SIGNATURE, 0);
 		central.writeUInt16LE(20, 6);
-		central.writeUInt32LE(data.length, 20);
-		central.writeUInt32LE(data.length, 24);
+		central.writeUInt16LE(method, 10);
+		central.writeUInt32LE(zip64 ? SIZE_SENTINEL : data.length, 20);
+		central.writeUInt32LE(zip64 ? SIZE_SENTINEL : plain.length, 24);
 		central.writeUInt16LE(name.length, 28);
+		central.writeUInt16LE(extra.length, 30);
 		central.writeUInt32LE(entry.symlink === true ? SYMLINK_ATTRIBUTES : FILE_ATTRIBUTES, 38);
-		central.writeUInt32LE(offset, 42);
+		central.writeUInt32LE(zip64 ? SIZE_SENTINEL : offset, 42);
 
 		locals.push(local, name, data);
-		centrals.push(central, name);
+		centrals.push(central, name, extra);
 
 		offset += 30 + name.length + data.length;
 	}
@@ -60,14 +104,41 @@ const buildZip = (entries: ArchiveEntry[]) => {
 	const end = Buffer.alloc(22);
 
 	end.writeUInt32LE(EOCD_SIGNATURE, 0);
-	end.writeUInt16LE(entries.length, 8);
-	end.writeUInt16LE(entries.length, 10);
-	end.writeUInt32LE(directory.length, 12);
-	end.writeUInt32LE(body.length, 16);
+	end.writeUInt16LE(zip64 ? COUNT_SENTINEL : entries.length, 8);
+	end.writeUInt16LE(zip64 ? COUNT_SENTINEL : entries.length, 10);
+	end.writeUInt32LE(zip64 ? SIZE_SENTINEL : directory.length, 12);
+	end.writeUInt32LE(zip64 ? SIZE_SENTINEL : body.length, 16);
+
+	if (!zip64) {
+		return Buffer.concat([
+			body,
+			directory,
+			end,
+		]);
+	}
+
+	const record = Buffer.alloc(ZIP64_EOCD_LENGTH);
+
+	record.writeUInt32LE(ZIP64_EOCD_SIGNATURE, 0);
+	record.writeBigUInt64LE(BigInt(ZIP64_EOCD_LENGTH - 12), 4);
+	record.writeUInt16LE(45, 12);
+	record.writeUInt16LE(45, 14);
+	record.writeBigUInt64LE(BigInt(entries.length), 24);
+	record.writeBigUInt64LE(BigInt(entries.length), 32);
+	record.writeBigUInt64LE(BigInt(directory.length), 40);
+	record.writeBigUInt64LE(BigInt(body.length), 48);
+
+	const locator = Buffer.alloc(ZIP64_LOCATOR_LENGTH);
+
+	locator.writeUInt32LE(ZIP64_LOCATOR_SIGNATURE, 0);
+	locator.writeBigUInt64LE(BigInt(body.length + directory.length), 8);
+	locator.writeUInt32LE(1, 16);
 
 	return Buffer.concat([
 		body,
 		directory,
+		record,
+		locator,
 		end,
 	]);
 };
@@ -82,12 +153,17 @@ const egress: BridgeEgress = {
 	},
 };
 
+const silent: BridgeLeveledLogger = Object.assign(() => undefined, {
+	warn: () => undefined,
+	error: () => undefined,
+});
+
 describe("extract", () => {
 	let root = "";
 	let files: BridgeFiles;
 
-	const archive = async (entries: ArchiveEntry[]) => {
-		await Bun.write(`${root}/pack.zip`, buildZip(entries));
+	const archive = async (entries: ArchiveEntry[], archiveOptions: ArchiveOptions = {}) => {
+		await Bun.write(`${root}/pack.zip`, buildZip(entries, archiveOptions));
 
 		return "pack.zip";
 	};
@@ -104,7 +180,7 @@ describe("extract", () => {
 			uid: 0,
 			gid: 0,
 			egress,
-			onLog: () => undefined,
+			onLog: silent,
 		});
 	});
 
@@ -331,4 +407,538 @@ describe("extract", () => {
 			}),
 		).rejects.toThrow("contained no matching files");
 	});
+
+	test("takes every selected prefix in one pass and strips the one that matched", async () => {
+		const path = await archive([
+			{
+				name: "overrides/mods/alpha.jar",
+				content: "alpha",
+			},
+			{
+				name: "server-overrides/config/beta.json",
+				content: "beta",
+			},
+			{
+				name: "client-overrides/options.txt",
+				content: "client",
+			},
+		]);
+
+		const written = await files.extract(path, "", {
+			tree: true,
+			selects: [
+				"overrides/",
+				"server-overrides/",
+			],
+		});
+
+		expect(written).toEqual([
+			"mods/alpha.jar",
+			"config/beta.json",
+		]);
+
+		expect(await read("mods/alpha.jar")).toBe("alpha");
+		expect(await read("config/beta.json")).toBe("beta");
+	});
+
+	test("takes a single named entry when the select carries no trailing slash", async () => {
+		const path = await archive([
+			{
+				name: "modrinth.index.json",
+				content: "{}",
+			},
+			{
+				name: "overrides/config/beta.json",
+				content: "beta",
+			},
+		]);
+
+		const written = await files.extract(path, "staging", {
+			tree: true,
+			selects: [
+				"modrinth.index.json",
+			],
+		});
+
+		expect(written).toEqual([
+			"staging/modrinth.index.json",
+		]);
+
+		expect(await read("staging/modrinth.index.json")).toBe("{}");
+	});
+
+	test("drops excluded paths after the prefix is stripped", async () => {
+		const path = await archive([
+			{
+				name: "overrides/mods/alpha.jar",
+				content: "alpha",
+			},
+			{
+				name: "overrides/shaderpacks/heavy.zip",
+				content: "shader",
+			},
+			{
+				name: "overrides/saves/world/level.dat",
+				content: "world",
+			},
+		]);
+
+		const written = await files.extract(path, "", {
+			tree: true,
+			selects: [
+				"overrides/",
+			],
+			exclude: [
+				"shaderpacks/**",
+				"saves/**",
+			],
+		});
+
+		expect(written).toEqual([
+			"mods/alpha.jar",
+		]);
+
+		expect(await Bun.file(`${root}/shaderpacks/heavy.zip`).exists()).toBe(false);
+	});
+
+	test("answers with nothing when a select matches nothing", async () => {
+		const path = await archive([
+			{
+				name: "overrides/mods/alpha.jar",
+				content: "alpha",
+			},
+		]);
+
+		const written = await files.extract(path, "staging", {
+			tree: true,
+			selects: [
+				"server-overrides/",
+			],
+		});
+
+		expect(written).toEqual([]);
+	});
+
+	test("inflates a deflated entry", async () => {
+		const path = await archive([
+			{
+				name: "mods/alpha.jar",
+				content: "alpha the deflated",
+				compressed: deflateRawSync(Buffer.from("alpha the deflated", "utf8")),
+			},
+		]);
+
+		const written = await files.extract(path, "mods");
+
+		expect(written).toEqual([
+			"mods/alpha.jar",
+		]);
+
+		expect(await read("mods/alpha.jar")).toBe("alpha the deflated");
+	});
+
+	test("reads a zip64 archive through its locator and extended field", async () => {
+		const path = await archive(
+			[
+				{
+					name: "overrides/mods/alpha.jar",
+					content: "alpha",
+				},
+				{
+					name: "overrides/config/beta.json",
+					content: "beta",
+					compressed: deflateRawSync(Buffer.from("beta", "utf8")),
+				},
+			],
+			{
+				zip64: true,
+			},
+		);
+
+		const written = await files.extract(path, "", {
+			tree: true,
+			select: "overrides/",
+		});
+
+		expect(written).toEqual([
+			"mods/alpha.jar",
+			"config/beta.json",
+		]);
+
+		expect(await read("mods/alpha.jar")).toBe("alpha");
+		expect(await read("config/beta.json")).toBe("beta");
+	});
+
+	test("takes a suffix select from anywhere in the archive", async () => {
+		const path = await archive([
+			{
+				name: "BMC5 Server/mods/alpha.jar",
+				content: "alpha",
+			},
+			{
+				name: "mods/beta.jar",
+				content: "beta",
+			},
+			{
+				name: "config/alpha.jar",
+				content: "config",
+			},
+		]);
+
+		const written = await files.extract(path, "staging", {
+			selects: [
+				"**/mods/alpha.jar",
+				"**/mods/beta.jar",
+			],
+		});
+
+		expect(written).toEqual([
+			"staging/alpha.jar",
+			"staging/beta.jar",
+		]);
+
+		expect(await read("staging/alpha.jar")).toBe("alpha");
+		expect(await read("staging/beta.jar")).toBe("beta");
+	});
+
+	test("keeps the suffix path under the destination in tree mode", async () => {
+		const path = await archive([
+			{
+				name: "BMC5 Server/mods/alpha.jar",
+				content: "alpha",
+			},
+		]);
+
+		const written = await files.extract(path, "staging", {
+			tree: true,
+			selects: [
+				"**/mods/alpha.jar",
+			],
+		});
+
+		expect(written).toEqual([
+			"staging/mods/alpha.jar",
+		]);
+	});
+
+	test("never inflates an entry it did not select", async () => {
+		const entries: ArchiveEntry[] = [
+			{
+				name: "BMC5 Server/mods/alpha.jar",
+				content: "alpha",
+			},
+			{
+				name: "BMC5 Server/mods/broken.jar",
+				content: "a payload no inflater can read",
+				compressed: Buffer.from("this is not deflate data", "utf8"),
+			},
+		];
+
+		const path = await archive(entries);
+
+		const written = await files.extract(path, "staging", {
+			selects: [
+				"**/mods/alpha.jar",
+			],
+		});
+
+		expect(written).toEqual([
+			"staging/alpha.jar",
+		]);
+
+		await expect(
+			files.extract(path, "broken", {
+				selects: [
+					"**/mods/broken.jar",
+				],
+			}),
+		).rejects.toThrow();
+	});
+
+	test("answers with nothing when every match is excluded", async () => {
+		const path = await archive([
+			{
+				name: "overrides/shaderpacks/heavy.zip",
+				content: "shader",
+			},
+		]);
+
+		const written = await files.extract(path, "", {
+			tree: true,
+			selects: [
+				"overrides/",
+			],
+			exclude: [
+				"shaderpacks/**",
+			],
+		});
+
+		expect(written).toEqual([]);
+	});
+});
+
+describe("digest", () => {
+	let root = "";
+	let files: BridgeFiles;
+
+	beforeEach(async () => {
+		root = await mkdtemp(`${tmpdir()}/serverk-bridge-`);
+
+		files = createBridgeFiles({
+			root,
+			uid: 0,
+			gid: 0,
+			egress,
+			onLog: silent,
+		});
+	});
+
+	afterEach(async () => {
+		await rm(root, {
+			force: true,
+			recursive: true,
+		});
+	});
+
+	test("answers with the known vectors for abc", async () => {
+		await Bun.write(`${root}/mods/alpha.jar`, "abc");
+
+		expect(await files.digest("mods/alpha.jar", "sha1")).toBe("a9993e364706816aba3e25717850c26c9cd0d89d");
+
+		expect(await files.digest("mods/alpha.jar", "sha256")).toBe(
+			"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
+		);
+
+		expect(await files.digest("mods/alpha.jar", "sha512")).toBe(
+			"ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f",
+		);
+	});
+
+	test("answers with the known vector for an empty file", async () => {
+		await Bun.write(`${root}/empty.jar`, "");
+
+		expect(await files.digest("empty.jar", "sha1")).toBe("da39a3ee5e6b4b0d3255bfef95601890afd80709");
+	});
+
+	test("hashes a file larger than one read chunk", async () => {
+		const content = "a".repeat(4 * 1024 * 1024 + 17);
+
+		await Bun.write(`${root}/big.bin`, content);
+
+		expect(await files.digest("big.bin", "sha256")).toBe(new Bun.CryptoHasher("sha256").update(content).digest("hex"));
+	});
+
+	test("refuses a path that is not a readable file", async () => {
+		await files.ensure("mods");
+
+		await expect(files.digest("mods", "sha1")).rejects.toThrow("is not a readable file");
+		await expect(files.digest("mods/missing.jar", "sha1")).rejects.toThrow("is not a readable file");
+	});
+
+	test("refuses a path outside the server directory", async () => {
+		await expect(files.digest("../escape.jar", "sha1")).rejects.toThrow("is not allowed");
+	});
+});
+
+describe("download", () => {
+	let root = "";
+	let warnings: string[] = [];
+	let messages: string[] = [];
+
+	const digestOf = (content: string) => {
+		return `sha512:${new Bun.CryptoHasher("sha512").update(content).digest("hex")}`;
+	};
+
+	const serving = (content: string): BridgeEgress => {
+		return {
+			fetch() {
+				throw new Error("the egress channel is not part of this test");
+			},
+
+			async download() {
+				return {
+					status: 200,
+					sizeBytes: Buffer.byteLength(content),
+					fromCache: false,
+					body: (async function* () {
+						yield new Uint8Array(Buffer.from(content));
+					})(),
+				};
+			},
+		};
+	};
+
+	const filesServing = (content: string) => {
+		return createBridgeFiles({
+			root,
+			uid: 0,
+			gid: 0,
+			egress: serving(content),
+			onLog: Object.assign(
+				(message: string) => {
+					messages.push(message);
+				},
+				{
+					warn: (message: string) => {
+						warnings.push(message);
+					},
+					error: () => undefined,
+				},
+			),
+		});
+	};
+
+	beforeEach(async () => {
+		root = await mkdtemp(`${tmpdir()}/serverk-bridge-`);
+		warnings = [];
+		messages = [];
+	});
+
+	afterEach(async () => {
+		await rm(root, {
+			force: true,
+			recursive: true,
+		});
+	});
+
+	test("keeps a file the source undersized when the checksum passes", async () => {
+		const content = "a mod jar the index measured wrong";
+
+		await filesServing(content).download("mods/alpha.jar", "https://cdn.example.com/alpha.jar", {
+			digest: digestOf(content),
+			sizeBytes: Buffer.byteLength(content) - 2,
+		});
+
+		expect(await Bun.file(`${root}/mods/alpha.jar`).text()).toBe(content);
+		expect(warnings).toEqual([
+			"the source declared a different size, the checksum passed so we kept the file",
+		]);
+	});
+
+	test("refuses a file whose checksum does not match, however right its size", async () => {
+		const content = "a mod jar somebody swapped";
+
+		await expect(
+			filesServing(content).download("mods/alpha.jar", "https://cdn.example.com/alpha.jar", {
+				digest: digestOf("what the index promised"),
+				sizeBytes: Buffer.byteLength(content),
+			}),
+		).rejects.toThrow("failed digest verification");
+
+		expect(await Bun.file(`${root}/mods/alpha.jar`).exists()).toBe(false);
+	});
+
+	test("holds an unverified file to its declared size", async () => {
+		const content = "a mod jar with no checksum to trust";
+
+		await expect(
+			filesServing(content).download("mods/alpha.jar", "https://cdn.example.com/alpha.jar", {
+				sizeBytes: Buffer.byteLength(content) - 2,
+			}),
+		).rejects.toThrow("returned more than");
+
+		expect(await Bun.file(`${root}/mods/alpha.jar`).exists()).toBe(false);
+	});
+
+	test("holds an unverified file that stops short of its declared size", async () => {
+		const content = "a mod jar with no checksum to trust";
+
+		await expect(
+			filesServing(content).download("mods/alpha.jar", "https://cdn.example.com/alpha.jar", {
+				sizeBytes: Buffer.byteLength(content) + 2,
+			}),
+		).rejects.toThrow(`returned ${Buffer.byteLength(content)} bytes, expected ${Buffer.byteLength(content) + 2}`);
+	});
+
+	test("carries the upstream status when the egress channel refuses", async () => {
+		const refusing: BridgeEgress = {
+			fetch() {
+				throw new Error("the egress channel is not part of this test");
+			},
+
+			download() {
+				throw new BridgeEgressCallError(429, "cdn.example.com answered 429");
+			},
+		};
+
+		const failing = createBridgeFiles({
+			root,
+			uid: 0,
+			gid: 0,
+			egress: refusing,
+			onLog: silent,
+		});
+
+		let thrown: unknown = null;
+
+		try {
+			await failing.download("mods/alpha.jar", "https://cdn.example.com/alpha.jar");
+		} catch (error) {
+			thrown = error;
+		}
+
+		expect(thrown).toBeInstanceOf(BridgeDownloadError);
+		expect(thrown instanceof BridgeDownloadError ? thrown.status : null).toBe(429);
+	});
+
+	test("narrates a file it downloads unless the caller asks otherwise", async () => {
+		const content = "a server jar worth watching";
+
+		await filesServing(content).download("server.jar", "https://cdn.example.com/server.jar", {
+			digest: digestOf(content),
+			sizeBytes: Buffer.byteLength(content),
+		});
+
+		expect(messages).toEqual([
+			"downloading",
+			"downloaded",
+		]);
+	});
+
+	test("says nothing about a quiet file", async () => {
+		const content = "a mod jar in a batch of hundreds";
+
+		await filesServing(content).download("mods/alpha.jar", "https://cdn.example.com/alpha.jar", {
+			digest: digestOf(content),
+			sizeBytes: Buffer.byteLength(content),
+			quiet: true,
+		});
+
+		expect(await Bun.file(`${root}/mods/alpha.jar`).text()).toBe(content);
+		expect(messages).toEqual([]);
+	});
+
+	test("still warns and still fails on a quiet file", async () => {
+		const content = "a mod jar the index measured wrong";
+
+		await filesServing(content).download("mods/alpha.jar", "https://cdn.example.com/alpha.jar", {
+			digest: digestOf(content),
+			sizeBytes: Buffer.byteLength(content) - 2,
+			quiet: true,
+		});
+
+		await expect(
+			filesServing(content).download("mods/beta.jar", "https://cdn.example.com/beta.jar", {
+				digest: digestOf("what the index promised"),
+				quiet: true,
+			}),
+		).rejects.toThrow("failed digest verification");
+
+		expect(await Bun.file(`${root}/mods/beta.jar`).exists()).toBe(false);
+		expect(warnings).toEqual([
+			"the source declared a different size, the checksum passed so we kept the file",
+		]);
+		expect(messages).toEqual([]);
+	});
+
+	test("keeps no warning when the declared size is right", async () => {
+		const content = "a mod jar the index measured right";
+
+		await filesServing(content).download("mods/alpha.jar", "https://cdn.example.com/alpha.jar", {
+			digest: digestOf(content),
+			sizeBytes: Buffer.byteLength(content),
+		});
+
+		expect(warnings).toEqual([]);
+	});
 });