feat(studio): add nitro cleanup tool for fake and broken bundles

src/lib/services/nitro-cleanup.test.ts

@@ -0,0 +1,195 @@
+// @vitest-environment node
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+type AnyFn = (...args: any[]) => any;
+
+const {
+	executeFn,
+	readdirFn,
+	readFileFn,
+	statFn,
+	unlinkFn,
+	existsFn,
+	parseNitroBundle,
+	getTargetsFn,
+} = vi.hoisted(() => ({
+	executeFn: vi.fn<AnyFn>(async () => [
+		[
+			{ item_name: "chair", public_name: "Chair" },
+			{ item_name: "broken_thing", public_name: "Broken Thing" },
+			{ item_name: "xmas_*1", public_name: "Xmas" },
+		],
+		[],
+	]),
+	readdirFn: vi.fn<AnyFn>(),
+	readFileFn: vi.fn<AnyFn>(),
+	statFn: vi.fn<AnyFn>(),
+	unlinkFn: vi.fn<AnyFn>(async () => {}),
+	existsFn: vi.fn<AnyFn>(() => false),
+	parseNitroBundle: vi.fn<AnyFn>(),
+	getTargetsFn: vi.fn<AnyFn>(async () => ({
+		nitroDir: "/assets/nitro",
+		swfDir: "/assets/swf",
+		iconDir: "/assets/icons",
+		mirrorDirs: [],
+	})),
+}));
+
+vi.mock("@/lib/db", () => ({ db: { execute: executeFn } }));
+vi.mock("@/lib/services/furni-asset-dirs", () => ({
+	getFurniAssetWriteTargets: getTargetsFn,
+}));
+vi.mock("@/lib/services/swf/nitro-builder", () => ({ parseNitroBundle }));
+vi.mock("node:fs", async (orig) => {
+	const real = (await orig()) as typeof import("node:fs");
+	return {
+		...real,
+		promises: {
+			...real.promises,
+			readdir: readdirFn as AnyFn,
+			readFile: readFileFn as AnyFn,
+			stat: statFn as AnyFn,
+			unlink: unlinkFn as AnyFn,
+		},
+		existsSync: existsFn,
+	};
+});
+
+import {
+	deleteNitroCleanupFiles,
+	scanFakeBrokenNitros,
+} from "@/lib/services/nitro-cleanup";
+
+beforeEach(() => {
+	vi.clearAllMocks();
+	readdirFn.mockReset();
+	readFileFn.mockReset();
+	parseNitroBundle.mockReset();
+	existsFn.mockReset();
+	getTargetsFn.mockReset();
+	getTargetsFn.mockResolvedValue({
+		nitroDir: "/assets/nitro",
+		swfDir: "/assets/swf",
+		iconDir: "/assets/icons",
+		mirrorDirs: [],
+	});
+});
+
+describe("scanFakeBrokenNitros", () => {
+	it("classifies fake (no matching item) and broken (unparseable) bundles", async () => {
+		readdirFn.mockResolvedValue([
+			"chair.nitro",
+			"fake_stuff.nitro",
+			"broken_thing.nitro",
+			"xmas_.nitro",
+		]);
+		readFileFn.mockImplementation(async (filePath: string) =>
+			Buffer.from(filePath.includes("broken") ? "broken-data" : "nitro-data"),
+		);
+		statFn.mockImplementation(async () => ({ size: 512 }));
+		parseNitroBundle.mockImplementation((buffer: Buffer) => {
+			if (buffer.toString("utf-8").startsWith("broken")) {
+				throw new Error("Not a valid .nitro bundle");
+			}
+			return {
+				json: {},
+				jsonFileName: "visualization.json",
+				png: Buffer.alloc(0),
+				pngFileName: "texture.png",
+			};
+		});
+
+		const result = await scanFakeBrokenNitros();
+
+		expect(result.total).toBe(4);
+		expect(result.fake.map((e) => e.fileName)).toEqual(["fake_stuff.nitro"]);
+		expect(result.broken.map((e) => e.fileName)).toEqual([
+			"broken_thing.nitro",
+		]);
+		expect(result.broken[0].error).toBe("Not a valid .nitro bundle");
+	});
+
+	it("resolves star classnames to their base nitro stem", async () => {
+		readdirFn.mockResolvedValue(["xmas_.nitro"]);
+		readFileFn.mockResolvedValue(Buffer.from("nitro-data"));
+		statFn.mockImplementation(async () => ({ size: 16 }));
+		parseNitroBundle.mockReturnValue({
+			json: {},
+			jsonFileName: "visualization.json",
+			png: Buffer.alloc(0),
+			pngFileName: "texture.png",
+		});
+
+		const result = await scanFakeBrokenNitros();
+
+		expect(result.fake).toEqual([]);
+		expect(result.broken).toEqual([]);
+		expect(result.total).toBe(1);
+	});
+
+	it("marks an unparseable bundle whose item is also missing as fake", async () => {
+		readdirFn.mockResolvedValue(["ghost.nitro"]);
+		statFn.mockImplementation(async () => ({ size: 8 }));
+
+		const result = await scanFakeBrokenNitros();
+
+		expect(result.fake[0].fileName).toBe("ghost.nitro");
+		expect(result.broken).toEqual([]);
+	});
+});
+
+describe("deleteNitroCleanupFiles", () => {
+	beforeEach(() => {
+		getTargetsFn.mockResolvedValue({
+			nitroDir: "/a/nitro",
+			swfDir: "/a/swf",
+			iconDir: "/a/icons",
+			mirrorDirs: [
+				{ nitroDir: "/b/nitro", swfDir: "/b/swf", iconDir: "/b/icons" },
+			],
+		});
+		existsFn.mockImplementation((filePath: string) =>
+			filePath.includes("chair"),
+		);
+	});
+
+	it("removes each file from every directory where it exists", async () => {
+		const result = await deleteNitroCleanupFiles([
+			"chair.nitro",
+			"missing.nitro",
+		]);
+
+		expect(result.deleted).toBe(1);
+		expect(result.copiesRemoved).toBe(2);
+		expect(unlinkFn).toHaveBeenCalledTimes(2);
+		expect(unlinkFn).toHaveBeenCalledWith("/a/nitro/chair.nitro");
+		expect(unlinkFn).toHaveBeenCalledWith("/b/nitro/chair.nitro");
+		expect(result.errors).toEqual([]);
+		const chair = result.files.find((f) => f.fileName === "chair.nitro");
+		expect(chair?.deleted).toBe(true);
+		expect(chair?.remaining).toEqual([]);
+	});
+
+	it("keeps a file in remaining dirs when an unlink fails", async () => {
+		unlinkFn.mockImplementation(async (filePath: string) => {
+			if (filePath.startsWith("/b/")) throw new Error("locked");
+		});
+
+		const result = await deleteNitroCleanupFiles(["chair.nitro"]);
+
+		expect(result.deleted).toBe(0);
+		expect(result.copiesRemoved).toBe(1);
+		expect(result.errors.some((e) => e.includes("locked"))).toBe(true);
+		const chair = result.files.find((f) => f.fileName === "chair.nitro");
+		expect(chair?.deleted).toBe(false);
+		expect(chair?.remaining).toEqual(["/b/nitro"]);
+	});
+
+	it("rejects unsafe file names", async () => {
+		const result = await deleteNitroCleanupFiles(["../evil.nitro"]);
+
+		expect(result.deleted).toBe(0);
+		expect(result.errors[0]).toContain("Invalid nitro file name");
+		expect(unlinkFn).not.toHaveBeenCalled();
+	});
+});