From 10597e10f233bb7ae1306a441e5770880cb2976a Mon Sep 17 00:00:00 2001 From: gensokyo-dev Date: Sat, 21 Nov 2026 17:53:55 +0000 Subject: [PATCH] fix(desktop): keep every state-reader close failure in the cleanup composite The desktop state-reader close collects up to three failures (artifact scope, SQLite service, and the export worker retry), but composed only the first two with analysisErrorWithCleanupFailure and bound the rest by hand. The third failure's reason never reached the caller. Fold the failures through analysisErrorWithCleanupDependencies so each keeps its reason and owner; two failures produce the same composite as before. Refs #11859 Co-Authored-By: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com> --- .../baselines/cleanup-dependency-binding.json | 1 - src/cli/desktopCaptureCommands.ts | 11 +- .../desktopStateReaderCleanup.test.ts | 191 ++++++++++++++++++ 3 files changed, 195 insertions(+), 8 deletions(-) create mode 100644 tests/process-global/desktopStateReaderCleanup.test.ts 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); +});