From eb97da33881e3d1472d97a7d788ee35944fb6b07 Mon Sep 17 00:00:00 2001 From: morluto <76467478+morluto@users.noreply.github.com> Date: Mon, 12 Oct 2026 05:05:13 +0800 Subject: [PATCH] fix(artifacts): retain ASAR resources through cleanup failures Give snapshot capture, header admission, packed members, and container streams one file-handle owner. Serialize adoption with reader shutdown, retain failed closes for retry, and remove snapshots only after descriptor cleanup succeeds. Cover unread members, pending opens, zero-byte members, and paired format/cleanup failures. Keep intentionally unrecoverable test fixtures hygienic and strengthen managed identity and process cleanup-authority expectations. Validation: full npm run check; 99 targeted tests and temporary-directory hygiene; exact discovery of 877 test files. No real vendor-provider verification was performed. --- src/artifacts/AsarArtifactReader.ts | 348 ++++++++++++------ src/artifacts/AsarHeader.ts | 3 +- .../ManagedNativeBoundaryInspector.test.ts | 8 +- .../filesystem/asarInventoryFreshness.test.ts | 16 +- .../filesystem/asarReaderCleanup.test.ts | 266 +++++++++++++ .../asarStreamingAllocation.test.ts | 223 ++++++----- .../boundary/process/providerProcess.test.ts | 28 +- 7 files changed, 670 insertions(+), 222 deletions(-) create mode 100644 tests/boundary/filesystem/asarReaderCleanup.test.ts diff --git a/src/artifacts/AsarArtifactReader.ts b/src/artifacts/AsarArtifactReader.ts index 3e0f69a5b..b7a235f4b 100644 --- a/src/artifacts/AsarArtifactReader.ts +++ b/src/artifacts/AsarArtifactReader.ts @@ -1,10 +1,4 @@ -import { - constants, - createReadStream, - createWriteStream, - type ReadStream, - type Stats, -} from "node:fs"; +import { constants, createWriteStream, type Stats } from "node:fs"; import { lstat, mkdtemp, @@ -46,51 +40,40 @@ export class AsarArtifactReader implements ArtifactReader { #archiveSize: number | undefined; #headerSize: number | undefined; readonly #entries = new Map(); - readonly #unpackedHandles = new Map< - UnpackedFileHandle, - { - readonly path: string; - readonly owner: OwnedFileHandle; - } - >(); + readonly #ownedHandles = new Map(); #snapshot: { readonly path: string; readonly sha256: string } | undefined; #snapshotRoot: string | undefined; #snapshotOperation: Promise = Promise.resolve(); constructor( private readonly path: string, - private readonly openUnpackedFile: OpenAsarUnpackedFile = open, - private readonly removeSnapshot: (path: string) => Promise = (path) => - rm(path, { recursive: true, force: true }), + private readonly options: AsarArtifactReaderOptions = {}, ) {} async *entries(signal?: AbortSignal): AsyncIterable { let paths: readonly AsarListedPath[]; try { await this.prepareContainer(undefined, signal); - const snapshotPath = this.#snapshotPath(); - this.#resetArchiveState(); - this.#entries.clear(); - const headerHandle = await open( - snapshotPath, - constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK, - ); - try { - const admitted = await admitAsarHeader(headerHandle); + paths = await this.#withSnapshotOperation(async () => { + const snapshotPath = this.#snapshotPath(); + this.#resetArchiveState(); + this.#entries.clear(); + const admitted = await this.#admitHeader(snapshotPath); this.#archiveSize = admitted.archiveBytes; this.#headerSize = admitted.headerBytes; - } finally { - await headerHandle.close(); - } - abortIfNeeded(signal); - paths = orderAsarListing(listPackage(snapshotPath, { isPack: false })); - const archiveMetadata = await lstat(snapshotPath); - if (!archiveMetadata.isFile() || archiveMetadata.isSymbolicLink()) - throw new ArtifactReaderFailure( - "format", - "ASAR container is not a regular file", + abortIfNeeded(signal); + const ordered = orderAsarListing( + listPackage(snapshotPath, { isPack: false }), ); - this.#archiveSize = archiveMetadata.size; + const archiveMetadata = await lstat(snapshotPath); + if (!archiveMetadata.isFile() || archiveMetadata.isSymbolicLink()) + throw new ArtifactReaderFailure( + "format", + "ASAR container is not a regular file", + ); + this.#archiveSize = archiveMetadata.size; + return ordered; + }, signal); } catch (cause: unknown) { throw asarFailure(this.path, "inventory", cause); } @@ -142,7 +125,47 @@ export class AsarArtifactReader implements ArtifactReader { } } + async #admitHeader(snapshotPath: string) { + const headerHandle = await this.#openOwned( + snapshotPath, + constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK, + ); + let admission: + | { + readonly ok: true; + readonly value: Awaited>; + } + | { readonly ok: false; readonly cause: unknown }; + try { + admission = { ok: true, value: await admitAsarHeader(headerHandle) }; + } catch (cause: unknown) { + admission = { ok: false, cause }; + } + try { + await this.#closeOwnedHandle(headerHandle); + } catch (cleanupCause: unknown) { + if (!admission.ok) + throw ArtifactReaderFailure.withCleanup( + admission.cause, + ArtifactReaderFailure.cleanupObservation(cleanupCause, snapshotPath), + ); + throw cleanupCause; + } + if (!admission.ok) throw admission.cause; + return admission.value; + } + async open(entry: ArtifactEntry, signal?: AbortSignal): Promise { + return this.#withSnapshotOperation( + () => this.#openEntry(entry, signal), + signal, + ); + } + + async #openEntry( + entry: ArtifactEntry, + signal?: AbortSignal, + ): Promise { abortIfNeeded(signal); const state = this.#entries.get(entry.adapterKey); if (state === undefined && entry.kind !== "file") @@ -160,10 +183,16 @@ export class AsarArtifactReader implements ArtifactReader { "integrity", `ASAR entry metadata changed since inventory: ${state.entry.path}`, ); - const { metadata } = state; - const producedEntry = state.entry; - if (producedEntry.unpacked) - return this.#openUnpackedStream(producedEntry, signal); + if (state.entry.unpacked) + return this.#openUnpackedStream(state.entry, signal); + return this.#openPackedStream(state, signal); + } + + async #openPackedStream( + state: AsarEntryState, + signal?: AbortSignal, + ): Promise { + const { metadata, entry: producedEntry } = state; const archiveSize = this.#archiveSize; const headerSize = this.#headerSize; const offset = @@ -187,10 +216,11 @@ export class AsarArtifactReader implements ArtifactReader { "format", `ASAR entry range is outside its container: ${producedEntry.path}`, ); - let handle: FileHandle | undefined; + const snapshotPath = this.#snapshotPath(); + let handle: SharedAsarFileHandle | undefined; try { - const openedHandle = await open( - this.#snapshotPath(), + const openedHandle = await this.#openOwned( + snapshotPath, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK, ); handle = openedHandle; @@ -202,25 +232,48 @@ export class AsarArtifactReader implements ArtifactReader { `ASAR container changed before read: ${producedEntry.path}`, ); if (metadata.size === 0) { - await closeAsarHandle(() => openedHandle.close(), signal); handle = undefined; + await closeAsarHandle( + () => this.#closeOwnedHandle(openedHandle), + signal, + ); return Readable.from([]); } - const source = openedHandle.createReadStream({ + const source = this.#ownedReadStream(openedHandle, { start, end: start + metadata.size - 1, - autoClose: true, + signal, }); - return readValidatedAsarEntry( + handle = undefined; + const output = readValidatedAsarEntry( source, metadata.size, producedEntry.path, this.path, signal, ); + this.#setOwnedOutput(openedHandle, output); + return output; } catch (cause: unknown) { - await handle?.close().catch(() => undefined); - throw asarFailure(this.path, `read ${producedEntry.path}`, cause); + const failure = asarFailure( + this.path, + `read ${producedEntry.path}`, + cause, + ); + if (handle !== undefined) { + try { + await this.#closeOwnedHandle(handle); + } catch (cleanupCause: unknown) { + throw ArtifactReaderFailure.withCleanup( + failure, + ArtifactReaderFailure.cleanupObservation( + cleanupCause, + snapshotPath, + ), + ); + } + } + throw failure; } } @@ -246,49 +299,37 @@ export class AsarArtifactReader implements ArtifactReader { } /** Read the same captured container that supplies headers and packed members. */ - async openContainer(signal?: AbortSignal): Promise { + async openContainer(signal?: AbortSignal): Promise { await this.prepareContainer(undefined, signal); - return createReadStream( - this.#snapshotPath(), - signal === undefined ? {} : { signal }, - ); + return this.#withSnapshotOperation(async () => { + abortIfNeeded(signal); + const snapshotPath = this.#snapshotPath(); + const handle = await this.#openOwned( + snapshotPath, + constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK, + ); + return this.#ownedReadStream(handle, { signal }); + }, signal); } async close(): Promise { - await this.#withSnapshotOperation(async () => { - let cleanupFailure: ArtifactReaderFailure | undefined; - for (const [handle, { path }] of this.#unpackedHandles) { - try { - await this.#closeUnpackedHandle(handle); - } catch (cause: unknown) { - cleanupFailure = ArtifactReaderFailure.withCleanup( - cleanupFailure ?? cause, - ArtifactReaderFailure.cleanupObservation(cause, path), - ); - } - } - try { - await this.#closeSnapshot(); - } catch (cause: unknown) { - cleanupFailure = ArtifactReaderFailure.withCleanup( - cleanupFailure ?? cause, - ArtifactReaderFailure.cleanupObservation(cause, this.path), - ); - } - if (cleanupFailure !== undefined) throw cleanupFailure; - }); + await this.#withSnapshotOperation(() => this.#closeSnapshot()); } async #captureSnapshot(signal?: AbortSignal): Promise { + let inputHandle: SharedAsarFileHandle | undefined; try { this.#snapshotRoot = await mkdtemp(join(tmpdir(), "rea-asar-snapshot-")); const snapshotPath = join(this.#snapshotRoot, "container.asar"); const hash = createHash("sha256"); - const handle = await open( + inputHandle = await this.#openOwned( this.path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK, ); - const source = handle.createReadStream(); + const source = this.#ownedReadStream(inputHandle, { + signal, + releaseOnClose: false, + }); const digesting = new Transform({ transform(chunk: Buffer, _encoding, callback) { hash.update(chunk); @@ -301,34 +342,50 @@ export class AsarArtifactReader implements ArtifactReader { createWriteStream(snapshotPath, { flags: "wx", mode: 0o600 }), signal === undefined ? {} : { signal }, ); + const completedInput = inputHandle; + inputHandle = undefined; + await this.#closeOwnedHandle(completedInput); this.#snapshot = { path: snapshotPath, sha256: hash.digest("hex") }; } catch (cause: unknown) { - const primary = + let failure = signal?.aborted === true ? new ArtifactReaderFailure("cancelled", "ASAR operation cancelled", { cause, }) : asarFailure(this.path, "snapshot", cause); + if (inputHandle !== undefined) { + const failedInput = inputHandle; + inputHandle = undefined; + try { + await this.#closeOwnedHandle(failedInput); + } catch (cleanupCause: unknown) { + failure = ArtifactReaderFailure.withCleanup( + failure, + ArtifactReaderFailure.cleanupObservation(cleanupCause, this.path), + ); + } + } try { - await this.#closeSnapshot(); + if (this.#ownedHandles.size === 0) await this.#closeSnapshot(); } catch (cleanupCause: unknown) { throw ArtifactReaderFailure.withCleanup( - primary, + failure, ArtifactReaderFailure.cleanupObservation( cleanupCause, this.#snapshotRoot ?? this.path, ), ); } - throw primary; + throw failure; } } async #closeSnapshot(): Promise { + await this.#closeOwnedHandles(); const root = this.#snapshotRoot; if (root !== undefined) { try { - await this.removeSnapshot(root); + await (this.options.removeSnapshot ?? defaultRemoveSnapshot)(root); if (this.#snapshotRoot === root) this.#snapshotRoot = undefined; } catch (cause: unknown) { throw ArtifactReaderFailure.withCleanup(cause, { @@ -386,7 +443,7 @@ export class AsarArtifactReader implements ArtifactReader { signal?: AbortSignal, ): Promise { const unpackedRoot = `${this.path}.unpacked`; - let handle: UnpackedFileHandle | undefined; + let handle: SharedAsarFileHandle | undefined; try { const rootMetadata = await lstat(unpackedRoot); if (!rootMetadata.isDirectory() || rootMetadata.isSymbolicLink()) @@ -413,15 +470,12 @@ export class AsarArtifactReader implements ArtifactReader { "path", `ASAR unpacked entry is not a regular file: ${entry.path}`, ); - handle = await this.openUnpackedFile( + handle = await (this.options.openUnpackedFile ?? open)( canonical, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK, ); const openedHandle = handle; - this.#unpackedHandles.set(openedHandle, { - path: canonical, - owner: new OwnedFileHandle(openedHandle), - }); + this.#adoptHandle(openedHandle, canonical); const openedMetadata = await openedHandle.stat(); if ( !openedMetadata.isFile() || @@ -441,30 +495,28 @@ export class AsarArtifactReader implements ArtifactReader { ); } abortIfNeeded(signal); - const source = readFileHandleChunks(openedHandle, { - start: 0, - }); - source.once("close", () => { - void this.#closeUnpackedHandle(openedHandle).catch(() => undefined); - }); - return readValidatedAsarEntry( + const source = this.#ownedReadStream(openedHandle, { start: 0 }); + handle = undefined; + const output = readValidatedAsarEntry( source, undefined, entry.path, this.path, signal, ); + this.#setOwnedOutput(openedHandle, output); + return output; } catch (cause: unknown) { let failure = asarUnpackedEntryFailure(this.path, entry, cause); - if (handle !== undefined && this.#unpackedHandles.has(handle)) { + if (handle !== undefined && this.#ownedHandles.has(handle)) { try { - await this.#closeUnpackedHandle(handle); + await this.#closeOwnedHandle(handle); } catch (cleanupCause: unknown) { failure = ArtifactReaderFailure.withCleanup( failure, ArtifactReaderFailure.cleanupObservation( cleanupCause, - this.#unpackedHandles.get(handle)?.path ?? entry.path, + this.#ownedHandles.get(handle)?.path ?? entry.path, ), ); } @@ -473,11 +525,76 @@ export class AsarArtifactReader implements ArtifactReader { } } - async #closeUnpackedHandle(handle: UnpackedFileHandle): Promise { - const owned = this.#unpackedHandles.get(handle); + async #closeOwnedHandle(handle: SharedAsarFileHandle): Promise { + const owned = this.#ownedHandles.get(handle); if (owned === undefined) return; - await owned.owner.close(); - this.#unpackedHandles.delete(handle); + owned.output?.destroy(); + owned.source?.destroy(); + try { + await owned.owner.close(); + } catch (cause: unknown) { + throw ArtifactReaderFailure.withCleanup( + cause, + ArtifactReaderFailure.cleanupObservation(cause, owned.path), + ); + } + this.#ownedHandles.delete(handle); + } + + async #closeOwnedHandles(): Promise { + let failure: ArtifactReaderFailure | undefined; + for (const [handle, owned] of this.#ownedHandles) { + try { + await this.#closeOwnedHandle(handle); + } catch (cause: unknown) { + failure = ArtifactReaderFailure.withCleanup( + failure ?? cause, + ArtifactReaderFailure.cleanupObservation(cause, owned.path), + ); + } + } + if (failure !== undefined) throw failure; + } + + async #openOwned(path: string, flags: number): Promise { + const handle = await (this.options.openFile ?? open)(path, flags); + this.#adoptHandle(handle, path); + return handle; + } + + #adoptHandle(handle: SharedAsarFileHandle, path: string): void { + this.#ownedHandles.set(handle, { + path, + owner: new OwnedFileHandle(handle), + }); + } + + #ownedReadStream( + handle: SharedAsarFileHandle, + options: { + readonly start?: number; + readonly end?: number; + readonly signal?: AbortSignal | undefined; + readonly releaseOnClose?: boolean; + }, + ): Readable { + const { releaseOnClose, ...readOptions } = options; + const source = readFileHandleChunks(handle, readOptions); + const owned = this.#ownedHandles.get(handle); + if (owned === undefined) + throw new ArtifactReaderFailure("integrity", "ASAR handle has no owner"); + owned.source = source; + owned.output = source; + if (releaseOnClose !== false) + source.once("close", () => { + void this.#closeOwnedHandle(handle).catch(() => undefined); + }); + return source; + } + + #setOwnedOutput(handle: SharedAsarFileHandle, output: Readable): void { + const owned = this.#ownedHandles.get(handle); + if (owned !== undefined) owned.output = output; } #resetArchiveState(): void { @@ -491,16 +608,27 @@ type AsarEntryState = { readonly metadata: AsarFileMetadata; readonly entry: ArtifactEntry; }; -type UnpackedFileHandle = { - readonly fd: number; +type SharedAsarFileHandle = Pick & { stat(): Promise; - close(): Promise; - read: FileHandle["read"]; }; -type OpenAsarUnpackedFile = ( +type OpenAsarFile = ( path: string, flags: number, -) => Promise; +) => Promise; +type OwnedAsarHandle = { + readonly path: string; + readonly owner: OwnedFileHandle; + source?: Readable; + output?: Readable; +}; +type AsarArtifactReaderOptions = { + readonly openFile?: OpenAsarFile; + readonly openUnpackedFile?: OpenAsarFile; + readonly removeSnapshot?: (path: string) => Promise; +}; + +const defaultRemoveSnapshot = (path: string): Promise => + rm(path, { recursive: true, force: true }); const asarUnpackedEntryFailure = ( archivePath: string, diff --git a/src/artifacts/AsarHeader.ts b/src/artifacts/AsarHeader.ts index 7c17f1cc7..216b05329 100644 --- a/src/artifacts/AsarHeader.ts +++ b/src/artifacts/AsarHeader.ts @@ -1,3 +1,4 @@ +import type { Stats } from "node:fs"; import type { FileHandle } from "node:fs/promises"; import { ArtifactReaderFailure } from "./ArtifactReader.js"; @@ -7,7 +8,7 @@ export const MAX_ASAR_HEADER_BYTES = 16 * 1024 * 1024; /** Admit both Chromium pickle extents before an upstream decoder allocates them. */ export const admitAsarHeader = async ( - handle: FileHandle, + handle: Pick & { stat(): Promise }, ): Promise<{ readonly archiveBytes: number; readonly headerBytes: number; diff --git a/src/dotnet/ManagedNativeBoundaryInspector.test.ts b/src/dotnet/ManagedNativeBoundaryInspector.test.ts index 3e33925ff..18ea8d988 100644 --- a/src/dotnet/ManagedNativeBoundaryInspector.test.ts +++ b/src/dotnet/ManagedNativeBoundaryInspector.test.ts @@ -280,7 +280,11 @@ describe("managed native boundary inspection", () => { describe("independent managed metadata facets", () => { it("preserves identity, members, and imports when embedded resources are malformed", () => { - const bytes = buildManagedPeFixture({ pinvoke: {}, readyToRun: true }); + const bytes = buildManagedPeFixture({ + mvid: Buffer.from("3aebc60edc4a544b1f458b4ed40b33b1", "hex"), + pinvoke: {}, + readyToRun: true, + }); bytes.writeUInt32LE(0x7fff_0000, 0x0200 + 24); const target = managedPeFixtureTarget(bytes); const artifact = inspectManagedArtifactBytes(bytes, target); @@ -288,7 +292,7 @@ describe("independent managed metadata facets", () => { const native = inspectManagedNativeBoundariesBytes(bytes, target); for (const result of [artifact, members, native]) { - expect(result.module?.mvid).toBeTruthy(); + expect(result.module?.mvid).toBe("0ec6eb3a-4adc-4b54-1f45-8b4ed40b33b1"); expect(result.metadata.status).toBe("partial"); expect(result.coverage).toMatchObject({ state: "partial", diff --git a/tests/boundary/filesystem/asarInventoryFreshness.test.ts b/tests/boundary/filesystem/asarInventoryFreshness.test.ts index 24d778bfc..4b83676ca 100644 --- a/tests/boundary/filesystem/asarInventoryFreshness.test.ts +++ b/tests/boundary/filesystem/asarInventoryFreshness.test.ts @@ -182,15 +182,13 @@ describe("ASAR snapshot operation ownership", () => { const removalStartedPromise = new Promise((resolve) => { removalStarted = resolve; }); - const reader = new AsarArtifactReader( - fixture.archive, - undefined, - async (path) => { + const reader = new AsarArtifactReader(fixture.archive, { + removeSnapshot: async (path) => { removalStarted?.(); await removalGate; await rm(path, { recursive: true, force: true }); }, - ); + }); let prepared = false; const preparing = reader.prepareContainer().then(() => { prepared = true; @@ -302,15 +300,13 @@ describe("ASAR captured-byte identity", () => { it("retains a completed inventory and snapshot ownership when cleanup fails", async () => { const fixture = await archiveFixture(); const attempts: string[] = []; - const reader = new AsarArtifactReader( - fixture.archive, - undefined, - async (path) => { + const reader = new AsarArtifactReader(fixture.archive, { + removeSnapshot: async (path) => { attempts.push(path); if (attempts.length === 1) throw new Error("snapshot removal denied"); await rm(path, { recursive: true, force: true }); }, - ); + }); const resourceScope = new ArtifactResourceScope(); onTestFinished(() => resourceScope.close()); try { diff --git a/tests/boundary/filesystem/asarReaderCleanup.test.ts b/tests/boundary/filesystem/asarReaderCleanup.test.ts new file mode 100644 index 000000000..073ee1c7d --- /dev/null +++ b/tests/boundary/filesystem/asarReaderCleanup.test.ts @@ -0,0 +1,266 @@ +import { fstatSync } from "node:fs"; +import { + lstat, + mkdir, + open as openFile, + type FileHandle, + writeFile, +} from "node:fs/promises"; +import { dirname, join } from "node:path"; + +import { createPackage } from "@electron/asar"; +import { describe, expect, it } from "vitest"; + +import { AsarArtifactReader } from "../../../src/artifacts/AsarArtifactReader.js"; +import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js"; + +const CONTENT = "module.exports = 'owned';\n"; + +const createArchive = async (content = CONTENT) => { + const root = await createTestTempDirectory("rea-asar-reader-cleanup-"); + const source = join(root, "source"); + const archive = join(root, "fixture.asar"); + await mkdir(source); + await writeFile(join(source, "main.js"), content); + await createPackage(source, archive); + return { archive }; +}; + +type OpenedHandle = { readonly path: string; readonly fd: number }; +type ReaderHooks = { + readonly beforeAdoption?: (path: string, handle: FileHandle) => Promise; + readonly close?: (handle: FileHandle) => Promise; +}; + +const createTrackedReader = (archive: string, hooks: ReaderHooks = {}) => { + const opened: OpenedHandle[] = []; + const reader = new AsarArtifactReader(archive, { + openFile: async (path, flags) => { + const handle = await openFile(path, flags); + opened.push({ path, fd: handle.fd }); + await hooks.beforeAdoption?.(path, handle); + return { + get fd() { + return handle.fd; + }, + stat: () => handle.stat(), + read: handle.read.bind(handle), + close: () => hooks.close?.(handle) ?? handle.close(), + }; + }, + }); + return { reader, opened }; +}; + +const packedMember = async (reader: AsarArtifactReader) => { + for await (const entry of reader.entries()) + if (entry.path === "main.js") return entry; + throw new Error("Expected packed ASAR member"); +}; + +const latestHandle = (opened: readonly OpenedHandle[]): OpenedHandle => { + const handle = opened.at(-1); + if (handle === undefined) + throw new Error("Expected a descriptor for the packed member"); + return handle; +}; + +const openPackedMember = async ( + reader: AsarArtifactReader, + opened: readonly OpenedHandle[], +) => { + const output = await reader.open(await packedMember(reader)); + const handle = latestHandle(opened); + return { output, handle, root: dirname(handle.path) }; +}; + +const expectDescriptorOpen = (fd: number): void => { + expect(fstatSync(fd).isFile()).toBe(true); +}; + +const expectDescriptorClosed = (fd: number): void => { + expect(() => fstatSync(fd)).toThrow(); +}; + +const expectSnapshotRemoved = async ( + fd: number, + root: string, +): Promise => { + expectDescriptorClosed(fd); + await expect(lstat(root)).rejects.toMatchObject({ code: "ENOENT" }); +}; + +describe("ASAR reader cleanup", () => { + it("reaps an unread packed member and its snapshot when the reader closes", async () => { + const { archive } = await createArchive(); + const { reader, opened } = createTrackedReader(archive); + + try { + const { + output, + handle: memberHandle, + root, + } = await openPackedMember(reader, opened); + expect(memberHandle.path).toContain("rea-asar-snapshot-"); + expectDescriptorOpen(memberHandle.fd); + expect(output.destroyed).toBe(false); + + await reader.close(); + + await expectSnapshotRemoved(memberHandle.fd, root); + } finally { + await reader.close(); + } + }); + + it("retains the snapshot and facts after a failed close, then retries cleanup", async () => { + const { archive } = await createArchive(); + let failNextClose = false; + const closeFailure = Object.assign(new Error("injected close failure"), { + code: "EIO", + errno: -5, + syscall: "close", + }); + const { reader, opened } = createTrackedReader(archive, { + close: async (handle) => { + if (failNextClose) { + failNextClose = false; + throw closeFailure; + } + await handle.close(); + }, + }); + + try { + const { handle: memberHandle, root } = await openPackedMember( + reader, + opened, + ); + failNextClose = true; + + await expect(reader.close()).rejects.toMatchObject({ + cleanup: { resources: [memberHandle.path] }, + }); + expectDescriptorOpen(memberHandle.fd); + expect((await lstat(root)).isDirectory()).toBe(true); + expect(await packedMember(reader)).toMatchObject({ path: "main.js" }); + + await reader.close(); + + await expectSnapshotRemoved(memberHandle.fd, root); + } finally { + await reader.close(); + } + }); + + it("closes a member handle adopted while reader shutdown is queued", async () => { + const { archive } = await createArchive(); + let pauseMemberOpen = false; + let memberOpenReached!: () => void; + let releaseMemberOpen!: () => void; + const memberOpenStarted = new Promise((resolve) => { + memberOpenReached = resolve; + }); + const memberOpenGate = new Promise((resolve) => { + releaseMemberOpen = resolve; + }); + const { reader, opened } = createTrackedReader(archive, { + beforeAdoption: async (path) => { + if (pauseMemberOpen && path.includes("rea-asar-snapshot-")) { + pauseMemberOpen = false; + memberOpenReached(); + await memberOpenGate; + } + }, + }); + + try { + const entry = await packedMember(reader); + pauseMemberOpen = true; + const opening = reader.open(entry); + await memberOpenStarted; + const closing = reader.close(); + releaseMemberOpen(); + const output = await opening; + const memberHandle = latestHandle(opened); + const root = dirname(memberHandle.path); + + await closing; + + expect(output.destroyed).toBe(true); + await expectSnapshotRemoved(memberHandle.fd, root); + } finally { + releaseMemberOpen(); + await reader.close(); + } + }); +}); + +describe("ASAR preparation cleanup", () => { + it("retains a zero-byte member handle when its first close fails", async () => { + const { archive } = await createArchive(""); + let failNextClose = false; + const { reader, opened } = createTrackedReader(archive, { + close: async (handle) => { + if (failNextClose) { + failNextClose = false; + throw new Error("empty member close denied"); + } + await handle.close(); + }, + }); + try { + const entry = await packedMember(reader); + failNextClose = true; + await expect(reader.open(entry)).rejects.toMatchObject({ + cleanup: { + reason: "empty member close denied", + resources: [expect.any(String)], + }, + }); + const handle = latestHandle(opened); + expectDescriptorOpen(handle.fd); + expect((await lstat(dirname(handle.path))).isDirectory()).toBe(true); + await reader.close(); + await expectSnapshotRemoved(handle.fd, dirname(handle.path)); + } finally { + await reader.close(); + } + }); + + it("preserves a malformed header failure when closing its handle also fails", async () => { + const { archive } = await createArchive(); + await writeFile(archive, Buffer.alloc(16)); + let failHeaderClose = false; + const closeFailure = new Error("header close denied"); + const { reader, opened } = createTrackedReader(archive, { + beforeAdoption: async (path) => { + if (path !== archive) failHeaderClose = true; + }, + close: async (handle) => { + if (failHeaderClose) { + failHeaderClose = false; + throw closeFailure; + } + await handle.close(); + }, + }); + try { + await expect(packedMember(reader)).rejects.toMatchObject({ + reason: "format", + message: "Truncated or invalid ASAR size pickle", + cleanup: { + reason: closeFailure.message, + resources: [expect.any(String)], + }, + }); + const handle = latestHandle(opened); + expectDescriptorOpen(handle.fd); + expect((await lstat(dirname(handle.path))).isDirectory()).toBe(true); + await reader.close(); + await expectSnapshotRemoved(handle.fd, dirname(handle.path)); + } finally { + await reader.close(); + } + }); +}); diff --git a/tests/boundary/filesystem/asarStreamingAllocation.test.ts b/tests/boundary/filesystem/asarStreamingAllocation.test.ts index 0b740d484..e8c46bd8c 100644 --- a/tests/boundary/filesystem/asarStreamingAllocation.test.ts +++ b/tests/boundary/filesystem/asarStreamingAllocation.test.ts @@ -9,11 +9,11 @@ import { writeFile, truncate, } from "node:fs/promises"; -import { join } from "node:path"; +import { dirname, join } from "node:path"; import { Readable } from "node:stream"; import { buffer } from "node:stream/consumers"; import { createPackageWithOptions } from "@electron/asar"; -import { describe, expect, it } from "vitest"; +import { describe, expect, it, onTestFinished } from "vitest"; import { scanArtifactInventory } from "../../fixtures/artifactInventory.js"; import { AsarArtifactReader } from "../../../src/artifacts/AsarArtifactReader.js"; import { @@ -105,7 +105,13 @@ describe("ASAR entry streaming", () => { await writeFile(join(source, "small.js"), "module.exports = 1;\n"); await createPackageWithOptions(source, archive, {}); - const reader = new AsarArtifactReader(archive); + let snapshotPath: string | undefined; + const reader = new AsarArtifactReader(archive, { + openFile: async (path, flags) => { + if (path !== archive) snapshotPath = path; + return openFile(path, flags); + }, + }); try { const entries = []; @@ -115,9 +121,11 @@ describe("ASAR entry streaming", () => { const entry = entries.find(({ path }) => path === "small.js"); if (entry === undefined) throw new Error("Expected packed ASAR member"); const snapshot = await reader.openContainer(); - const identity = await lstat(snapshot.path); + if (snapshotPath === undefined) + throw new Error("Expected snapshot acquisition"); + const identity = await lstat(snapshotPath); await buffer(snapshot); - const probe = await openFile(snapshot.path, "r"); + const probe = await openFile(snapshotPath, "r"); expect(await matchingDescriptorCount(identity)).toBeGreaterThan(0); await probe.close(); expect(await matchingDescriptorCount(identity)).toBe(0); @@ -145,7 +153,13 @@ describe("ASAR entry streaming", () => { await writeFile(join(source, "small.js"), "module.exports = 1;\n"); await createPackageWithOptions(source, archive, {}); - const reader = new AsarArtifactReader(archive); + let snapshotPath: string | undefined; + const reader = new AsarArtifactReader(archive, { + openFile: async (path, flags) => { + if (path !== archive) snapshotPath = path; + return openFile(path, flags); + }, + }); try { const entries = []; @@ -153,7 +167,9 @@ describe("ASAR entry streaming", () => { const entry = entries.find(({ path }) => path === "small.js"); if (entry === undefined) throw new Error("Expected packed ASAR member"); const snapshot = await reader.openContainer(); - const identity = await lstat(snapshot.path); + if (snapshotPath === undefined) + throw new Error("Expected snapshot acquisition"); + const identity = await lstat(snapshotPath); await buffer(snapshot); const controller = new AbortController(); const opening = reader.open(entry, controller.signal); @@ -340,23 +356,25 @@ describe("ASAR read failures", () => { syscall: "close", }); let closeCount = 0; - const reader = new AsarArtifactReader(archive, async (path, flags) => { - const handle = await openFile(path, flags); - expect(await matchingDescriptorCount(identity)).toBeGreaterThan(0); - return { - get fd() { - return handle.fd; - }, - async stat() { - throw ioError; - }, - async close() { - closeCount += 1; - if (closeCount === 1) throw closeError; - await handle.close(); - }, - read: handle.read.bind(handle), - }; + const reader = new AsarArtifactReader(archive, { + openUnpackedFile: async (path, flags) => { + const handle = await openFile(path, flags); + expect(await matchingDescriptorCount(identity)).toBeGreaterThan(0); + return { + get fd() { + return handle.fd; + }, + async stat() { + throw ioError; + }, + async close() { + closeCount += 1; + if (closeCount === 1) throw closeError; + await handle.close(); + }, + read: handle.read.bind(handle), + }; + }, }); try { @@ -396,24 +414,37 @@ it.skipIf(process.platform === "win32")( }); const closeFailure = new Error("native close outcome unavailable"); let closeCount = 0; - const reader = new AsarArtifactReader(archive, async (path, flags) => { - const handle = await openFile(path, flags); - return { - get fd() { - return handle.fd; - }, - async stat() { - throw statFailure; - }, - async close() { - closeCount += 1; - // Model Node's invalidated-descriptor rejection without leaking a - // native descriptor in the test process. - await handle.close(); - throw closeFailure; - }, - read: handle.read.bind(handle), - }; + let snapshotRoot: string | undefined; + const reader = new AsarArtifactReader(archive, { + openFile: async (path, flags) => { + if (path !== archive && snapshotRoot === undefined) { + const root = dirname(path); + snapshotRoot = root; + // This fixture deliberately reports an unrecoverable close outcome. + // Remove its retained snapshot only after testing reader ownership. + onTestFinished(() => rm(root, { recursive: true, force: true })); + } + return openFile(path, flags); + }, + openUnpackedFile: async (path, flags) => { + const handle = await openFile(path, flags); + return { + get fd() { + return handle.fd; + }, + async stat() { + throw statFailure; + }, + async close() { + closeCount += 1; + // Model Node's invalidated-descriptor rejection without leaking a + // native descriptor in the test process. + await handle.close(); + throw closeFailure; + }, + read: handle.read.bind(handle), + }; + }, }); const entry = await unpackedMember(reader); await expect(reader.open(entry)).rejects.toMatchObject({ @@ -430,6 +461,8 @@ it.skipIf(process.platform === "win32")( }); expect(closeCount).toBe(1); await waitForNoMatchingDescriptor(identity); + if (snapshotRoot === undefined) throw new Error("Expected ASAR snapshot"); + expect((await lstat(snapshotRoot)).isDirectory()).toBe(true); }, ); @@ -439,24 +472,26 @@ it.skipIf(process.platform === "win32")( const { archive, unpackedPath, identity } = await createUnpackedFixture(); const controller = new AbortController(); let closeCount = 0; - const reader = new AsarArtifactReader(archive, async (path, flags) => { - const handle = await openFile(path, flags); - return { - get fd() { - return handle.fd; - }, - async stat() { - const observed = await handle.stat(); - controller.abort(); - return observed; - }, - async close() { - closeCount += 1; - if (closeCount === 1) throw new Error("first close failed"); - await handle.close(); - }, - read: handle.read.bind(handle), - }; + const reader = new AsarArtifactReader(archive, { + openUnpackedFile: async (path, flags) => { + const handle = await openFile(path, flags); + return { + get fd() { + return handle.fd; + }, + async stat() { + const observed = await handle.stat(); + controller.abort(); + return observed; + }, + async close() { + closeCount += 1; + if (closeCount === 1) throw new Error("first close failed"); + await handle.close(); + }, + read: handle.read.bind(handle), + }; + }, }); try { @@ -484,25 +519,27 @@ it.skipIf(process.platform === "win32")( const { archive, unpackedPath, identity } = await createUnpackedFixture(); const closeError = new Error("first close failed"); let closeCount = 0; - const reader = new AsarArtifactReader(archive, async (path, flags) => { - const handle = await openFile(path, flags); - return { - get fd() { - return handle.fd; - }, - async stat() { - const observed = await handle.stat(); - return Object.assign(Object.create(observed), { - ino: observed.ino + 1, - }); - }, - async close() { - closeCount += 1; - if (closeCount === 1) throw closeError; - await handle.close(); - }, - read: handle.read.bind(handle), - }; + const reader = new AsarArtifactReader(archive, { + openUnpackedFile: async (path, flags) => { + const handle = await openFile(path, flags); + return { + get fd() { + return handle.fd; + }, + async stat() { + const observed = await handle.stat(); + return Object.assign(Object.create(observed), { + ino: observed.ino + 1, + }); + }, + async close() { + closeCount += 1; + if (closeCount === 1) throw closeError; + await handle.close(); + }, + read: handle.read.bind(handle), + }; + }, }); try { @@ -527,16 +564,15 @@ it.skipIf(process.platform === "win32")( ); it.skipIf(process.platform === "win32")( - "retains unpacked handles and snapshots across combined cleanup failures", + "retains unpacked handles before retrying snapshot cleanup failures", async () => { const { archive, unpackedPath, identity } = await createUnpackedFixture(); const closeError = new Error("unpacked close denied"); const snapshotError = new Error("snapshot removal denied"); let closeCount = 0; const snapshotPaths: string[] = []; - const reader = new AsarArtifactReader( - archive, - async (path, flags) => { + const reader = new AsarArtifactReader(archive, { + openUnpackedFile: async (path, flags) => { const handle = await openFile(path, flags); return { get fd() { @@ -557,12 +593,12 @@ it.skipIf(process.platform === "win32")( read: handle.read.bind(handle), }; }, - async (path) => { + removeSnapshot: async (path) => { snapshotPaths.push(path); if (snapshotPaths.length === 1) throw snapshotError; await rm(path, { recursive: true, force: true }); }, - ); + }); try { const entry = await unpackedMember(reader); @@ -579,19 +615,24 @@ it.skipIf(process.platform === "win32")( ); expect(cleanupFailure).toMatchObject({ cleanup: { - resources: [unpackedPath, expect.any(String)], + resources: [unpackedPath], reason: expect.stringContaining("unpacked close denied"), }, }); + expect(closeCount).toBe(2); + expect(snapshotPaths).toEqual([]); + expect(await matchingDescriptorCount(identity)).toBeGreaterThan(0); + + await expect(reader.close()).rejects.toMatchObject({ + message: snapshotError.message, + cleanup: { resources: [expect.any(String)] }, + }); + expect(closeCount).toBe(3); + await waitForNoMatchingDescriptor(identity); const snapshotRoot = snapshotPaths[0]; if (snapshotRoot === undefined) throw new Error("Expected owned ASAR snapshot root"); expect(snapshotPaths).toEqual([snapshotRoot]); - expect(cleanupFailure).toMatchObject({ - cleanup: { resources: [unpackedPath, snapshotRoot] }, - }); - expect(closeCount).toBe(2); - expect(await matchingDescriptorCount(identity)).toBeGreaterThan(0); expect((await lstat(snapshotRoot)).isDirectory()).toBe(true); await reader.close(); diff --git a/tests/boundary/process/providerProcess.test.ts b/tests/boundary/process/providerProcess.test.ts index b2813ce46..068f6becb 100644 --- a/tests/boundary/process/providerProcess.test.ts +++ b/tests/boundary/process/providerProcess.test.ts @@ -285,12 +285,17 @@ describe("provider process output and cleanup primitives", () => { await stopProviderProcessFixture(child); } }); +}); +describe("provider process cleanup authority", () => { it("honors verified group cleanup instead of direct process signaling", async () => { const child = spawnProviderProcessFixture("stubborn"); - await waitForProviderProcessReady(child); + const signalFromCleanup = child.kill.bind(child); + const directSignal = vi.spyOn(child, "kill"); const cleanup = vi.fn(async () => { - child.kill("SIGKILL"); + // Keep the injected cleanup signal separate from the supervisor's + // direct method, while retaining the child handle's lifetime checks. + signalFromCleanup("SIGKILL"); return { cleaned: true, signaled: true } as const; }); const supervisor = new ProviderProcessSupervisor({ @@ -299,12 +304,19 @@ describe("provider process output and cleanup primitives", () => { cleanup, }); - await expect(supervisor.stop({ killGraceMs: 500 })).resolves.toEqual({ - status: "verified-cleanup", - }); - // Cleanup must be attempted. The exact attempt count is an internal retry - // ladder, so it is deliberately not pinned here. - expect(cleanup).toHaveBeenCalled(); + try { + await waitForProviderProcessReady(child); + await expect(supervisor.stop({ killGraceMs: 500 })).resolves.toEqual({ + status: "verified-cleanup", + }); + // Cleanup must be attempted. The exact attempt count is an internal + // retry ladder, so it is deliberately not pinned here. + expect(cleanup).toHaveBeenCalled(); + expect(directSignal).not.toHaveBeenCalled(); + } finally { + directSignal.mockRestore(); + await stopProviderProcessFixture(child); + } }); it("cleans an owned group even after its launcher leader has exited", async () => {