diff --git a/scripts/verify/baselines/cleanup-dependency-binding.json b/scripts/verify/baselines/cleanup-dependency-binding.json index 9376b61224..a2468550dc 100644 --- a/scripts/verify/baselines/cleanup-dependency-binding.json +++ b/scripts/verify/baselines/cleanup-dependency-binding.json @@ -7,7 +7,6 @@ "src/application/frida/FridaInstrumentationService.ts": 2, "src/browser/PlaywrightBrowserScenarioProvider.ts": 1, "src/browser/WebSourceMapFetcher.ts": 2, - "src/cli/desktopCaptureCommands.ts": 1, "src/desktop/ScreenJudgeProcess.ts": 1, "src/domain/explicitSensitiveFailure.ts": 1, "src/evm/EvmoleInterfaceProvider.ts": 3, diff --git a/src/cli/desktopCaptureCommands.ts b/src/cli/desktopCaptureCommands.ts index 74a2cad2a4..5aa9d649fd 100644 --- a/src/cli/desktopCaptureCommands.ts +++ b/src/cli/desktopCaptureCommands.ts @@ -10,7 +10,7 @@ import type { Logger } from "pino"; import { captureDesktopApplication } from "../application/desktop/DesktopApplicationCapture.js"; import type { DesktopStateReaders } from "../application/desktop/DesktopApplicationState.js"; import { AnalysisError } from "../domain/analysisErrorBase.js"; -import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js"; +import { analysisErrorWithCleanupDependencies } from "../domain/analysisErrorCleanup.js"; import { ProviderCleanupError } from "../domain/providerCleanupError.js"; import { ArtifactReaderFailure, @@ -256,13 +256,10 @@ const withStateReaders = async ( bindArtifactFileCleanup(cause, failure); return failure; }); - const combined = analysisErrorWithCleanupFailure( - typed[0]!, - typed[1]!, - operation, + // Fold left so every close failure keeps its reason and owner. + throw typed.reduce((primary, cleanup) => + analysisErrorWithCleanupDependencies(primary, cleanup, operation), ); - combined.bindCleanupDependencies(typed); - throw combined; } }, }, diff --git a/tests/process-global/desktopStateReaderCleanup.test.ts b/tests/process-global/desktopStateReaderCleanup.test.ts new file mode 100644 index 0000000000..b6df32cd47 --- /dev/null +++ b/tests/process-global/desktopStateReaderCleanup.test.ts @@ -0,0 +1,191 @@ +import { expect, it, onTestFinished, vi } from "vitest"; +import { createCommandCli } from "../support/cli/commandCli.js"; +import { registerDesktopCaptureCommands } from "../../src/cli/desktopCaptureCommands.js"; +import { AnalysisError } from "../../src/domain/analysisErrorBase.js"; +import { createEvidence } from "../../src/domain/evidence.js"; +import { ProviderCleanupError } from "../../src/domain/providerCleanupError.js"; +import { unknownTarget } from "../../src/domain/targetIdentity.js"; +import { silentLogger } from "../../src/logger.js"; +import { AnalysisCleanupLease } from "../../src/resources/AnalysisCleanupLease.js"; +import type { ArtifactResourceScope } from "../../src/resources/index.js"; + +const fixture = vi.hoisted(() => ({ + lease: undefined as unknown, + sqlite: undefined as unknown, + worker: undefined as unknown, + closed: undefined as unknown, +})); + +// Observe the composite the close callback throws, without changing it. +vi.mock("../../src/cli/finishAnalysisCommand.js", async (importOriginal) => { + const original = + await importOriginal< + typeof import("../../src/cli/finishAnalysisCommand.js") + >(); + return { + ...original, + finishAnalysisCommand: ( + run: Parameters[0], + service: Parameters[1], + ...rest: unknown[] + ) => + (original.finishAnalysisCommand as (...args: unknown[]) => unknown)( + run, + { + close: async () => { + try { + await service.close(); + } catch (cause: unknown) { + fixture.closed = cause; + throw cause; + } + }, + }, + ...rest, + ), + }; +}); + +vi.mock("../../src/composition/sqlite.js", () => ({ + createSqliteDatabaseService: () => ({ + close: async () => { + throw fixture.sqlite; + }, + }), +})); + +vi.mock("../../src/process/OwnedWorkerRuntime.js", () => ({ + OwnedWorkerRuntime: { + retryPending: async () => { + throw fixture.worker; + }, + }, +})); + +// The export retains one lease in the command's real resource scope, so the +// scope's own close fails before the SQLite and worker closes run. +vi.mock("../../src/application/desktop/DesktopApplicationExport.js", () => ({ + exportDesktopApplication: async ( + _input: unknown, + readers: { readonly resources: ArtifactResourceScope }, + ) => { + readers.resources.retain({ + kind: "lease", + resource: "/export-staging", + lease: AnalysisCleanupLease.forCloseOwner( + { + close: async () => { + throw fixture.lease; + }, + }, + "/export-staging", + ), + }); + return createEvidence( + unknownTarget("not-observed"), + { id: "fixture", name: "Desktop export fixture", version: "1" }, + { + operation: "export_desktop_application", + parameters: {}, + result: {}, + confidence: "observed", + }, + ); + }, +})); + +const releasable = ( + providerId: string, + resource: string, + reason: string, + released: () => boolean, +) => { + const failure = new ProviderCleanupError( + providerId, + [resource], + { reason }, + { operation: "export_desktop_application" }, + ); + failure.bindCleanupReleaseClaim({ + get cleanupReleased() { + return released(); + }, + }); + return failure; +}; + +it("keeps every state-reader close failure in the export's cleanup composite", async () => { + const previousExitCode = process.exitCode; + onTestFinished(() => { + process.exitCode = previousExitCode; + }); + const released = { sqlite: false, worker: false }; + fixture.lease = new Error("Export staging remains locked"); + fixture.sqlite = releasable( + "rea-sqlite", + "sqlite-handle", + "SQLite handle remains open", + () => released.sqlite, + ); + fixture.worker = releasable( + "rea-worker", + "export-worker", + "Export worker remains owned", + () => released.worker, + ); + const cli = createCommandCli(); + registerDesktopCaptureCommands(cli, silentLogger, {}); + let stdout = ""; + await cli.serve( + [ + "export-desktop-application", + "/capture-fixture", + "/bundle-fixture", + "--json", + ], + { + env: {}, + stdout: (text) => { + stdout += text; + }, + exit: () => {}, + }, + ); + const output: unknown = JSON.parse(stdout); + expect(output).toMatchObject({ + code: "cleanup_incomplete", + details: { + resources: expect.arrayContaining([ + "/export-staging", + "sqlite-handle", + "export-worker", + ]), + }, + }); + + const reported = JSON.stringify(output); + for (const reason of [ + "Export staging remains locked", + "SQLite handle remains open", + "Export worker remains owned", + ]) + expect(reported).toContain(reason); + + // Each owner still decides its own part of the composite's completion. + const composite = fixture.closed; + if (!(composite instanceof AnalysisError)) + throw new Error("Expected the close composite to be an AnalysisError"); + expect(composite.cleanupResources).toEqual( + expect.arrayContaining([ + "/export-staging", + "sqlite-handle", + "export-worker", + ]), + ); + released.worker = true; + expect(composite.cleanupResources).not.toContain("export-worker"); + released.sqlite = true; + expect(composite.cleanupResources).not.toContain("sqlite-handle"); + // The scope's lease never confirms release. + expect(composite.cleanupIncomplete).toBe(true); +});