import { appendFile, mkdir, readFile, stat, symlink, unlink, writeFile, } from "node:fs/promises"; import { createHash } from "node:crypto"; import { join } from "node:path"; import { expect, it, vi } from "vitest"; import { createTestTempDirectory } from "../../../tests/fixtures/temporaryDirectory.js"; import { renameOpenParent } from "../../../tests/fixtures/renameOpenParent.js"; import { buildGodotPck } from "../../../tests/fixtures/godotPck.js"; import { ArtifactResourceScope } from "../../resources/ArtifactResourceScope.js"; import { GodotPckArtifactReader } from "../GodotPckArtifactReader.js"; import { NodeSeaArtifactReader } from "../NodeSeaArtifactReader.js"; import { PyInstallerArtifactReader } from "../PyInstallerArtifactReader.js"; import { cArchiveExecutable } from "../pyinstaller/CArchive.fixture.js"; import { nodeSeaElf } from "../nodeSea/NodeSea.fixture.js"; import * as cArchive from "../pyinstaller/CArchiveLayout.js"; import * as nodeSea from "../nodeSea/NodeSeaBlob.js"; import * as godot from "../GodotPckLocation.js"; import { extractArtifact } from "./ArtifactExtraction.js"; const cases = [ { format: "pyinstaller" as const, inputFormat: "pe" as const, reader: PyInstallerArtifactReader as { prototype: { close(): Promise }; }, bytes: () => cArchiveExecutable({ carrier: "pe", layout: "2.1", pythonVersion: 314, members: [ { name: String.raw`pkg\payload.txt`, typeCode: "x", payload: Buffer.from("fixture"), compress: false, }, ], }), member: "pkg/payload.txt", observe: () => vi.spyOn(cArchive, "observePyInstallerCookie"), }, { format: "node-sea" as const, inputFormat: "elf" as const, reader: NodeSeaArtifactReader as { prototype: { close(): Promise } }, bytes: () => nodeSeaElf({ codePath: "payload.js", main: "fixture" }), member: "payload.js", observe: () => vi.spyOn(nodeSea, "decodeNodeSeaBlob"), }, { format: "godot-pck" as const, inputFormat: "godot-pck" as const, reader: GodotPckArtifactReader as { prototype: { close(): Promise } }, bytes: () => buildGodotPck(3, [{ path: "payload.txt", data: "fixture" }]), member: "payload.txt", observe: () => vi.spyOn(godot, "locateGodotPck"), }, ]; it.each(cases)( "extracts $format using the inventory admission once", async ({ format, inputFormat, reader, bytes, member, observe }) => { const directory = await createTestTempDirectory("rea-embedded-extraction-"); const path = join(directory, "source"); const output = join(directory, "out"); const carrier = bytes(); await writeFile(path, carrier); const scope = new ArtifactResourceScope(); const observation = observe(); const close = vi.spyOn(reader.prototype, "close"); const release = vi.spyOn(scope, "release"); try { const result = await extractArtifact({ inputPath: path, inputFormat, outputRoot: output, environment: {}, integrityPolicy: "fail", resourceScope: scope, expectedRootSha256: createHash("sha256").update(carrier).digest("hex"), selectedPath: path, }); expect(result.manifest.root_format).toBe(format); expect(await readFile(join(output, member), "utf8")).toBe("fixture"); expect(observation).toHaveBeenCalledTimes(1); expect(close).toHaveBeenCalledTimes(2); const rootRelease = release.mock.calls.findIndex( ([owner]) => owner.kind === "file-handle" && owner.resource === `root artifact descriptor for ${path}`, ); expect(rootRelease).toBeGreaterThanOrEqual(0); expect( release.mock.calls .slice(0, rootRelease) .filter(([owner]) => owner.kind === "reader"), ).toHaveLength(2); expect(scope.hasPending).toBe(false); } finally { try { await scope.close(); } finally { observation.mockRestore(); close.mockRestore(); release.mockRestore(); } } }, ); it.each(cases)( "rejects changed $format bytes before materializing admitted facts", async ({ inputFormat, reader, bytes }) => { const directory = await createTestTempDirectory( "rea-embedded-extraction-stale-", ); const path = join(directory, "source"); const output = join(directory, "out"); await writeFile(path, bytes()); const scope = new ArtifactResourceScope(); const original = reader.prototype.close; let closes = 0; const close = vi .spyOn(reader.prototype, "close") .mockImplementation(async function (this: { close(): Promise }) { await original.call(this); if (++closes === 1) await appendFile(path, "changed"); }); try { await expect( extractArtifact({ inputPath: path, inputFormat, outputRoot: output, environment: {}, integrityPolicy: "fail", resourceScope: scope, }), ).rejects.toMatchObject({ reason: "integrity" }); await expect(stat(output)).rejects.toMatchObject({ code: "ENOENT" }); expect(scope.hasPending).toBe(false); } finally { try { await scope.close(); } finally { close.mockRestore(); } } }, ); it.each( cases.flatMap((fixture) => [ { ...fixture, mode: "mixed" as const }, ...(fixture.format === "godot-pck" ? [{ ...fixture, mode: "cancel" as const }] : []), ]), )( "retains $format finalization semantics during $mode", async ({ inputFormat, reader, bytes, mode }) => { const directory = await createTestTempDirectory( "rea-embedded-extraction-cleanup-", ); const path = join(directory, "source"); const output = join(directory, "out"); await writeFile(path, bytes()); const scope = new ArtifactResourceScope(); const controller = new AbortController(); const failure = new Error("root close denied"); const originalReaderClose = reader.prototype.close; let readerAttempts = 0; const readerClose = vi .spyOn(reader.prototype, "close") .mockImplementation(async function (this: { close(): Promise }) { if (++readerAttempts === 2 && mode === "mixed") throw new Error("reader close denied"); await originalReaderClose.call(this); }); const originalRelease = scope.release.bind(scope); let rootAttempts = 0; let rootClose: { mockRestore(): void } | undefined; const release = vi .spyOn(scope, "release") .mockImplementation(async (owner) => { if ( owner.kind === "file-handle" && owner.resource === `root artifact descriptor for ${path}` ) { const originalClose = owner.handle.close.bind(owner.handle); rootClose = vi .spyOn(owner.handle, "close") .mockImplementation(async () => { rootAttempts++; expect(readerAttempts).toBeGreaterThanOrEqual(2); if (rootAttempts === 1) { if (mode === "cancel") controller.abort(failure); else throw failure; } await originalClose(); }); } return originalRelease(owner); }); try { const execution = extractArtifact( { inputPath: path, inputFormat, outputRoot: output, environment: {}, integrityPolicy: "fail", resourceScope: scope, }, controller.signal, ); if (mode === "cancel") await expect(execution).rejects.toMatchObject({ reason: "cancelled", cause: failure, }); else await expect(execution).rejects.toMatchObject({ cleanup: { resources: expect.arrayContaining([ `root artifact descriptor for ${path}`, ]), }, }); await expect(stat(output)).rejects.toMatchObject({ code: "ENOENT" }); if (mode === "mixed") expect(scope.cleanupResources).toEqual([ `artifact reader for ${path}`, `root artifact descriptor for ${path}`, ]); else expect(scope.cleanupResources).toEqual([]); await scope.close(); expect(rootAttempts).toBe(mode === "cancel" ? 1 : 2); expect(readerAttempts).toBe(mode === "mixed" ? 3 : 2); expect(scope.hasPending).toBe(false); } finally { await scope.close().catch(() => undefined); rootClose?.mockRestore(); release.mockRestore(); readerClose.mockRestore(); } }, ); it.each(cases)( "rejects a retargeted selected path before publishing $format extraction", async ({ inputFormat, reader, bytes }) => { const directory = await createTestTempDirectory( "rea-embedded-extraction-selection-", ); const path = join(directory, "source"); const selectedPath = join(directory, "selected"); const replacement = join(directory, "replacement"); const output = join(directory, "out"); const carrier = bytes(); await writeFile(path, carrier); await writeFile(replacement, carrier); await symlink(path, selectedPath); const scope = new ArtifactResourceScope(); const originalClose = reader.prototype.close; let closes = 0; const close = vi .spyOn(reader.prototype, "close") .mockImplementation(async function (this: { close(): Promise }) { await originalClose.call(this); if (++closes === 2) { await unlink(selectedPath); await symlink(replacement, selectedPath); } }); try { await expect( extractArtifact({ inputPath: path, selectedPath, expectedRootSha256: createHash("sha256") .update(carrier) .digest("hex"), inputFormat, outputRoot: output, environment: {}, integrityPolicy: "fail", resourceScope: scope, }), ).rejects.toMatchObject({ reason: "integrity" }); await expect(stat(output)).rejects.toMatchObject({ code: "ENOENT" }); expect(closes).toBe(2); expect(scope.hasPending).toBe(false); } finally { try { await scope.close(); } finally { close.mockRestore(); } } }, ); it.each( cases.flatMap((item) => [ { ...item, simulateWindowsRefusal: false }, { ...item, simulateWindowsRefusal: true }, ]), )( "handles attempted replacement at the admitted $format pathname (simulated refusal: $simulateWindowsRefusal)", async ({ inputFormat, reader, bytes, simulateWindowsRefusal }) => { const directory = await createTestTempDirectory( "rea-embedded-extraction-replacement-", ); const selectedDirectory = join(directory, "selected"); await mkdir(selectedDirectory); const path = join(selectedDirectory, "source"); const output = join(directory, "out"); const originalBytes = bytes(); await writeFile(path, originalBytes); const scope = new ArtifactResourceScope(); const originalClose = reader.prototype.close; let closes = 0; let deniedRename: unknown; const close = vi .spyOn(reader.prototype, "close") .mockImplementation(async function (this: { close(): Promise }) { await originalClose.call(this); if (++closes === 1) { // Moving the parent leaves the admitted regular file's metadata intact. const swap = await renameOpenParent( selectedDirectory, join(directory, "admitted"), simulateWindowsRefusal ? { platform: "win32", rename: async () => { throw Object.assign(new Error("injected EPERM"), { code: "EPERM", }); }, } : {}, ); if (swap.kind === "blocked") { deniedRename = swap.cause; throw swap.cause; } await mkdir(selectedDirectory); await writeFile(path, Buffer.from("replacement")); } }); try { const failure = await extractArtifact({ inputPath: path, inputFormat, outputRoot: output, environment: {}, integrityPolicy: "fail", resourceScope: scope, }).then( () => undefined, (cause: unknown) => cause, ); if (deniedRename === undefined) expect(failure).toMatchObject({ reason: "integrity" }); else expect(failure).toMatchObject({ reason: "io", message: expect.stringContaining("EPERM"), }); await expect(stat(output)).rejects.toMatchObject({ code: "ENOENT" }); expect(closes).toBe(1); if (deniedRename !== undefined) { expect((await readFile(path)).equals(originalBytes)).toBe(true); expect(scope.hasPending).toBe(true); await scope.close(); } expect(scope.hasPending).toBe(false); } finally { try { await scope.close(); } finally { close.mockRestore(); } } }, );