Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

fix(native): retain signature snapshot cleanup ownership

morlutoebc22d99d622
diff --git a/src/artifacts/ArtifactResourceScope.ts b/src/artifacts/ArtifactResourceScope.ts
index 59fdcba36..7c0bcf2c2 100644
--- a/src/artifacts/ArtifactResourceScope.ts
+++ b/src/artifacts/ArtifactResourceScope.ts
@@ -6,6 +6,7 @@ import type { OwnedStagedOutput } from "../filesystem/OwnedStagedOutput.js";
import type { ArtifactReader } from "./ArtifactReader.js";
import { ArtifactReaderFailure } from "./ArtifactReader.js";
import type { SafeOutputTree } from "./SafeOutputTree.js";
+import type { PrivateRuntimeRoot } from "../process/PrivateRuntimeRoot.js";
/** One artifact resource and its format-specific cleanup owner. */
export type ArtifactResourceOwner =
@@ -38,6 +39,11 @@ export type ArtifactResourceOwner =
readonly kind: "staged-output";
readonly resource: string;
readonly output: OwnedStagedOutput;
+ }
+ | {
+ readonly kind: "private-runtime-root";
+ readonly resource: string;
+ readonly root: Pick<PrivateRuntimeRoot, "path" | "close">;
};
export type ArtifactCleanupAttempt =
@@ -161,5 +167,8 @@ const cleanup = async (owner: ArtifactResourceOwner): Promise<void> => {
return;
case "staged-output":
await owner.output.close();
+ return;
+ case "private-runtime-root":
+ await owner.root.close();
}
};
diff --git a/src/native/NativeMacOSProvider.ts b/src/native/NativeMacOSProvider.ts
index 2ae6a7cb6..1d1c2a36c 100644
--- a/src/native/NativeMacOSProvider.ts
+++ b/src/native/NativeMacOSProvider.ts
@@ -84,16 +84,24 @@ import {
inspectNativeMacho,
} from "./NativeMachoInspection.js";
import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
+import { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
+import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
+import type { PrivateRuntimeRoot } from "../process/PrivateRuntimeRoot.js";
import {
createNativeUiHelperRuntime,
type NativeUiHelperRuntime,
} from "./NativeUiHelperRuntime.js";
+type SignatureRuntimeRootFactory = () => Promise<
+ Pick<PrivateRuntimeRoot, "path" | "close">
+>;
+
/** Read-only semantic provider composed from Xcode command-line utilities. */
export class NativeMacOSProvider implements AnalysisProvider {
readonly #capabilities: readonly CapabilityDescriptor[];
readonly #environment: NodeJS.ProcessEnv;
readonly #tracerFactory: () => NativeCallTracer;
+ readonly #privateRuntimeRootFactory: SignatureRuntimeRootFactory | undefined;
constructor(
environment: Readonly<NodeJS.ProcessEnv>,
@@ -102,10 +110,12 @@ export class NativeMacOSProvider implements AnalysisProvider {
),
platform: NodeJS.Platform = process.platform,
tracerFactory?: () => NativeCallTracer,
+ privateRuntimeRootFactory?: SignatureRuntimeRootFactory,
) {
this.#environment = snapshotEnvironment(environment, platform);
this.#tracerFactory =
tracerFactory ?? (() => new LldbCallTracer(this.#environment));
+ this.#privateRuntimeRootFactory = privateRuntimeRootFactory;
this.#capabilities = nativeMacOSCapabilities(platform);
}
@@ -123,6 +133,7 @@ export class NativeMacOSProvider implements AnalysisProvider {
this.runner,
this.#tracerFactory(),
this.#environment,
+ this.#privateRuntimeRootFactory,
);
}
}
@@ -130,6 +141,7 @@ export class NativeMacOSProvider implements AnalysisProvider {
class NativeMacOSClient implements AnalysisClient {
readonly #pendingNativeUiRuntimes = new Set<NativeUiHelperRuntime>();
readonly #pendingCommands = new Set<Promise<unknown>>();
+ readonly #signatureResources = new ArtifactResourceScope();
#nativeUiTail: Promise<void> = Promise.resolve();
#closed = false;
@@ -138,6 +150,9 @@ class NativeMacOSClient implements AnalysisClient {
private readonly runner: NativeCommandRunner,
private readonly tracer: NativeCallTracer,
private readonly environment: Readonly<NodeJS.ProcessEnv>,
+ private readonly privateRuntimeRootFactory:
+ | SignatureRuntimeRootFactory
+ | undefined,
) {}
async execute(
@@ -270,6 +285,21 @@ class NativeMacOSClient implements AnalysisClient {
const uiCleanupFailures = await this.#serializeNativeUi(() =>
this.#retryNativeUiCleanup(),
);
+ let signatureCleanup: AnalysisError | undefined;
+ try {
+ await this.#signatureResources.close();
+ } catch (cause: unknown) {
+ const observation = ArtifactReaderFailure.cleanupObservation(
+ cause,
+ "signature-snapshot",
+ );
+ signatureCleanup = new ProviderCleanupError(
+ IDENTITY.id,
+ observation.resources,
+ { reason: observation.reason },
+ { operation: "close_binary", cause },
+ );
+ }
const commandCleanup = await this.#retryNativeCommandCleanup();
let result = await this.tracer.close();
const cleanupErrors = [
@@ -277,6 +307,7 @@ class NativeMacOSClient implements AnalysisClient {
? []
: [this.#nativeUiCleanupFailure(uiCleanupFailures, "close_binary")]),
...(commandCleanup === undefined ? [] : [commandCleanup]),
+ ...(signatureCleanup === undefined ? [] : [signatureCleanup]),
];
for (const cleanupError of cleanupErrors)
result = result.ok
@@ -532,8 +563,10 @@ class NativeMacOSClient implements AnalysisClient {
): Promise<Result<NativeObservation, AnalysisError>> {
return withSignatureTarget(
this.target,
+ this.#signatureResources,
(binding) => this.#inspectBoundSignature(binding, signal),
signal,
+ this.privateRuntimeRootFactory,
);
}
diff --git a/src/native/SignatureTargetBinding.test.ts b/src/native/SignatureTargetBinding.test.ts
new file mode 100644
index 000000000..a5d91f253
--- /dev/null
+++ b/src/native/SignatureTargetBinding.test.ts
@@ -0,0 +1,198 @@
+import { createHash } from "node:crypto";
+import { mkdtemp, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, expect, it } from "vitest";
+
+import { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
+import type { BinaryTarget } from "../domain/binaryTargetTypes.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { ok } from "../domain/result.js";
+import type { NativeCommandRunner } from "./CommandRunner.js";
+import type { NativeCallTracer } from "./LldbCallTracer.js";
+import { NativeMacOSProvider } from "./NativeMacOSProvider.js";
+import { withSignatureTarget } from "./SignatureTargetBinding.js";
+
+const roots: string[] = [];
+const targets: string[] = [];
+const unusedRunner: NativeCommandRunner = {
+ async run() {
+ throw new Error("Changed target must be rejected before a command runs");
+ },
+};
+const unusedTracer: NativeCallTracer = {
+ async trace() {
+ throw new Error("Signature inspection must not start a trace");
+ },
+ async close() {
+ return ok(null);
+ },
+};
+
+afterEach(async () => {
+ await Promise.all(
+ [...roots, ...targets].map((path) =>
+ rm(path, { recursive: true, force: true }),
+ ),
+ );
+ roots.length = 0;
+ targets.length = 0;
+});
+
+const createTarget = async (
+ bytes: string,
+ digest = bytes,
+): Promise<BinaryTarget> => {
+ const directory = await mkdtemp(join(tmpdir(), "rea-signature-target-"));
+ targets.push(directory);
+ const path = join(directory, "target.bin");
+ await writeFile(path, bytes);
+ return {
+ path,
+ sha256: createHash("sha256").update(digest).digest("hex"),
+ kind: "executable",
+ format: "mach-o",
+ architecture: "arm64",
+ availableArchitectures: ["arm64"],
+ };
+};
+
+const createRoot = async (failedAttempts = 0) => {
+ const path = await mkdtemp(join(tmpdir(), "rea-signature-root-"));
+ roots.push(path);
+ let attempts = 0;
+ return {
+ path,
+ async close() {
+ if (attempts++ < failedAttempts) {
+ throw new Error("injected root cleanup failure");
+ }
+ await rm(path, { recursive: true, force: true });
+ },
+ };
+};
+
+it("retains a snapshot root after cleanup fails alongside a digest mismatch", async () => {
+ const target = await createTarget("observed", "expected");
+ const resources = new ArtifactResourceScope();
+ const result = await withSignatureTarget(
+ target,
+ resources,
+ async () => ok("unused"),
+ undefined,
+ () => createRoot(1),
+ );
+
+ expect(result.ok).toBe(false);
+ if (result.ok) return;
+ expect(result.error.cleanupIncomplete).toBe(true);
+ expect(result.error.cleanupResources).toEqual(expect.arrayContaining(roots));
+ expect(projectAnalysisError(result.error)).toMatchObject({
+ details: { diagnostics: { primary_error: { code: "artifact_changed" } } },
+ });
+
+ await resources.close();
+ await expect(stat(roots[0]!)).rejects.toMatchObject({ code: "ENOENT" });
+});
+
+it("returns a retained cleanup failure when the next call cannot retry its root", async () => {
+ const target = await createTarget("observed", "expected");
+ const resources = new ArtifactResourceScope();
+ const createFailingRoot = async () => {
+ const path = await mkdtemp(join(tmpdir(), "rea-signature-root-sticky-"));
+ roots.push(path);
+ return {
+ path,
+ close: async () => {
+ throw new Error("still blocked");
+ },
+ };
+ };
+ const first = await withSignatureTarget(
+ target,
+ resources,
+ async () => ok("unused"),
+ undefined,
+ createFailingRoot,
+ );
+ expect(first.ok).toBe(false);
+ const second = await withSignatureTarget(
+ target,
+ resources,
+ async () => ok("must not run"),
+ undefined,
+ createRoot,
+ );
+ expect(second.ok).toBe(false);
+ if (second.ok) return;
+ expect(second.error.cleanupIncomplete).toBe(true);
+ expect(second.error.cleanupResources).toEqual(expect.arrayContaining(roots));
+});
+
+it("retries a retained signature root when the provider client closes", async () => {
+ const target = await createTarget("observed", "expected");
+ const provider = new NativeMacOSProvider(
+ {},
+ unusedRunner,
+ "darwin",
+ () => unusedTracer,
+ () => createRoot(2),
+ );
+ const client = provider.createClient(target);
+ const result = await client.execute("inspect_signature", {});
+
+ expect(result.ok).toBe(false);
+ if (result.ok) return;
+ expect(result.error.cleanupIncomplete).toBe(true);
+ expect(result.error.cleanupResources).toEqual(expect.arrayContaining(roots));
+ const firstClose = await client.close();
+ expect(firstClose).toMatchObject({
+ ok: false,
+ error: { cleanupIncomplete: true, cleanupResources: roots },
+ });
+ expect((await stat(roots[0]!)).isDirectory()).toBe(true);
+ await expect(client.close()).resolves.toMatchObject({
+ ok: true,
+ value: null,
+ });
+ await expect(stat(roots[0]!)).rejects.toMatchObject({ code: "ENOENT" });
+});
+
+it("waits for an in-flight signature binding before provider close", async () => {
+ const target = await createTarget("observed", "expected");
+ let rootFactoryEntered!: () => void;
+ let releaseRootFactory!: () => void;
+ const entered = new Promise<void>(
+ (resolve) => (rootFactoryEntered = resolve),
+ );
+ const gate = new Promise<void>((resolve) => (releaseRootFactory = resolve));
+ const provider = new NativeMacOSProvider(
+ {},
+ unusedRunner,
+ "darwin",
+ () => unusedTracer,
+ async () => {
+ rootFactoryEntered();
+ await gate;
+ return createRoot();
+ },
+ );
+ const client = provider.createClient(target);
+ const operation = client.execute("inspect_signature", {});
+ await entered;
+
+ let closeSettled = false;
+ const closing = client.close().finally(() => {
+ closeSettled = true;
+ });
+ await Promise.resolve();
+ expect(closeSettled).toBe(false);
+ releaseRootFactory();
+ await expect(operation).resolves.toMatchObject({
+ ok: false,
+ error: { _tag: "AnalysisArtifactChangedError" },
+ });
+ await expect(closing).resolves.toMatchObject({ ok: true, value: null });
+ expect(closeSettled).toBe(true);
+ await expect(stat(roots[0]!)).rejects.toMatchObject({ code: "ENOENT" });
+});
diff --git a/src/native/SignatureTargetBinding.ts b/src/native/SignatureTargetBinding.ts
index ac94a5f06..29c8651e6 100644
--- a/src/native/SignatureTargetBinding.ts
+++ b/src/native/SignatureTargetBinding.ts
@@ -1,7 +1,6 @@
import { createHash } from "node:crypto";
import { constants, type BigIntStats } from "node:fs";
-import { lstat, mkdtemp, open, rm, type FileHandle } from "node:fs/promises";
-import { tmpdir } from "node:os";
+import { lstat, open, type FileHandle } from "node:fs/promises";
import { basename, join } from "node:path";
import type { BinaryTarget } from "../domain/binaryTargetTypes.js";
import { AnalysisError } from "../domain/analysisErrorBase.js";
@@ -9,10 +8,17 @@ import {
AnalysisAccessDeniedError,
AnalysisArtifactChangedError,
AnalysisCancelledError,
+ AnalysisOutputError,
AnalysisResourceConstraintError,
} from "../domain/analysisErrorCore.js";
import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import { ProviderCleanupError } from "../domain/providerCleanupError.js";
+import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
import { err, ok, type Result } from "../domain/result.js";
+import { OwnedFileHandle } from "../filesystem/OwnedFileHandle.js";
+import { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
+import { PrivateRuntimeRoot } from "../process/PrivateRuntimeRoot.js";
+import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
import { NATIVE_MACOS_PROVIDER_IDENTITY } from "./NativeMacOSProviderMetadata.js";
/** Binding of commands to the selected executable's registered content/version. */
@@ -68,41 +74,126 @@ const signatureReadFailure = (
/** Inspect a digest-verified private copy, releasing it on every exit path. */
export const withSignatureTarget = async <T>(
target: BinaryTarget,
+ resources: ArtifactResourceScope,
inspect: (
binding: SignatureTargetBinding,
) => Promise<Result<T, AnalysisError>>,
signal?: AbortSignal,
+ createRoot: () => Promise<Pick<PrivateRuntimeRoot, "path" | "close">> = () =>
+ PrivateRuntimeRoot.create({ prefix: "rea-signature-" }),
): Promise<Result<T, AnalysisError>> => {
- let directory: string;
try {
- signal?.throwIfAborted();
- directory = await mkdtemp(join(tmpdir(), "rea-signature-"));
+ return await resources.run(async () => {
+ let root: Pick<PrivateRuntimeRoot, "path" | "close">;
+ try {
+ signal?.throwIfAborted();
+ root = await createRoot();
+ } catch (cause: unknown) {
+ return err(
+ signal?.aborted
+ ? new AnalysisCancelledError("inspect_signature")
+ : snapshotFailure(target, "create", cause),
+ );
+ }
+ const owner = {
+ kind: "private-runtime-root" as const,
+ root,
+ resource: root.path,
+ };
+ let result: Result<T, AnalysisError>;
+ try {
+ const binding = await bindSignatureTarget(
+ target,
+ join(root.path, basename(target.path)),
+ resources,
+ signal,
+ );
+ if (!binding.ok) result = binding;
+ else {
+ try {
+ result = await inspect(binding.value);
+ } catch (cause: unknown) {
+ result = err(
+ cause instanceof AnalysisError
+ ? cause
+ : new AnalysisOutputError(
+ "inspect_signature",
+ "Native output parsing failed",
+ { cause },
+ ),
+ );
+ }
+ }
+ } catch (cause: unknown) {
+ result = err(
+ cause instanceof AnalysisError
+ ? cause
+ : signatureReadFailure(target, cause),
+ );
+ }
+ const cleanup = await resources.release(owner);
+ if (cleanup.kind === "failed")
+ return combineCleanupFailure(
+ target,
+ result,
+ [root.path],
+ cleanup.cause,
+ "cleanup",
+ );
+ return result;
+ });
} catch (cause: unknown) {
+ if (cause instanceof AnalysisError) return err(cause);
+ const retained =
+ cause instanceof ArtifactReaderFailure && cause.cleanup !== undefined
+ ? cause.cleanup
+ : undefined;
+ if (retained !== undefined)
+ return combineCleanupFailure(
+ target,
+ err(
+ signal?.aborted
+ ? new AnalysisCancelledError("inspect_signature")
+ : signatureReadFailure(target, cause),
+ ),
+ retained.resources,
+ cause,
+ "retry",
+ );
return err(
signal?.aborted
? new AnalysisCancelledError("inspect_signature")
- : snapshotFailure(target, "create", cause),
- );
- }
- let result: Result<T, AnalysisError>;
- let cleanup: Result<void, AnalysisError>;
- try {
- const binding = await bindSignatureTarget(
- target,
- join(directory, basename(target.path)),
- signal,
+ : signatureReadFailure(target, cause),
);
- result = binding.ok ? await inspect(binding.value) : binding;
- } finally {
- try {
- await rm(directory, { recursive: true, force: true });
- cleanup = ok(undefined);
- } catch (cause: unknown) {
- cleanup = err(snapshotFailure(target, "cleanup", cause));
- }
}
- // Cleanup cannot replace the operation's original actionable failure.
- return result.ok && !cleanup.ok ? cleanup : result;
+};
+
+const combineCleanupFailure = <T>(
+ target: BinaryTarget,
+ primary: Result<T, AnalysisError>,
+ resources: readonly string[],
+ cause: unknown,
+ phase: string,
+): Result<T, AnalysisError> => {
+ const cleanup = new ProviderCleanupError(
+ NATIVE_MACOS_PROVIDER_IDENTITY.id,
+ resources,
+ {
+ reason: cause instanceof Error ? cause.message : String(cause),
+ phase: `signature-snapshot-${phase}`,
+ path: target.path,
+ },
+ { operation: "inspect_signature", cause },
+ );
+ return primary.ok
+ ? err(cleanup)
+ : err(
+ analysisErrorWithCleanupFailure(
+ primary.error,
+ cleanup,
+ "inspect_signature",
+ ),
+ );
};
const snapshotFailure = (
@@ -180,22 +271,28 @@ const copySignatureBytes = async (
const bindSignatureTarget = async (
target: BinaryTarget,
snapshotPath: string,
+ resources: ArtifactResourceScope,
signal?: AbortSignal,
): Promise<Result<SignatureTargetBinding, AnalysisError>> => {
- try {
- signal?.throwIfAborted();
- const before = await lstat(target.path, { bigint: true });
- signal?.throwIfAborted();
- if (!before.isFile() || before.isSymbolicLink())
- return changedTarget(
- target,
- `Signature target is no longer a regular file: ${target.path}`,
- );
- const file = await open(
- target.path,
- constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK,
- );
+ let sourceOwner: OwnedFileHandle | undefined;
+ let snapshotOwner: OwnedFileHandle | undefined;
+ const perform = async (): Promise<
+ Result<SignatureTargetBinding, AnalysisError>
+ > => {
try {
+ signal?.throwIfAborted();
+ const before = await lstat(target.path, { bigint: true });
+ signal?.throwIfAborted();
+ if (!before.isFile() || before.isSymbolicLink())
+ return changedTarget(
+ target,
+ `Signature target is no longer a regular file: ${target.path}`,
+ );
+ const file = await open(
+ target.path,
+ constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK,
+ );
+ sourceOwner = new OwnedFileHandle(file);
const opened = await file.stat({ bigint: true });
signal?.throwIfAborted();
if (identity(opened) !== identity(before))
@@ -206,44 +303,71 @@ const bindSignatureTarget = async (
const snapshot = await snapshotIO(target, "create-file", () =>
open(snapshotPath, "wx", 0o600),
);
- try {
- const observed = await copySignatureBytes(
+ snapshotOwner = new OwnedFileHandle(snapshot);
+ const observed = await copySignatureBytes(
+ target,
+ { file, stat: opened },
+ snapshot,
+ signal,
+ );
+ if (observed !== target.sha256)
+ return changedTarget(
target,
- { file, stat: opened },
- snapshot,
- signal,
+ `Signature target digest changed: ${target.path}; expected ${target.sha256}, observed ${observed}`,
);
- if (observed !== target.sha256)
- return changedTarget(
- target,
- `Signature target digest changed: ${target.path}; expected ${target.sha256}, observed ${observed}`,
- );
- const after = await file.stat({ bigint: true });
- const current = await lstat(target.path, { bigint: true });
- signal?.throwIfAborted();
- if (
- identity(after) !== identity(opened) ||
- identity(current) !== identity(opened)
- )
- return changedTarget(
- target,
- `Signature target changed while establishing its version: ${target.path}`,
- );
- await snapshotIO(target, "seal", () => snapshot.chmod(0o400));
- return ok({ identity: identity(opened), snapshotPath });
- } finally {
- await snapshotIO(target, "close", () => snapshot.close());
- }
- } finally {
- await file.close();
+ const after = await file.stat({ bigint: true });
+ const current = await lstat(target.path, { bigint: true });
+ signal?.throwIfAborted();
+ if (
+ identity(after) !== identity(opened) ||
+ identity(current) !== identity(opened)
+ )
+ return changedTarget(
+ target,
+ `Signature target changed while establishing its version: ${target.path}`,
+ );
+ await snapshotIO(target, "seal", () => snapshot.chmod(0o400));
+ return ok({ identity: identity(opened), snapshotPath });
+ } catch (cause: unknown) {
+ return err(
+ signal?.aborted
+ ? new AnalysisCancelledError("inspect_signature")
+ : signatureReadFailure(target, cause),
+ );
}
- } catch (cause: unknown) {
- return err(
- signal?.aborted
- ? new AnalysisCancelledError("inspect_signature")
- : signatureReadFailure(target, cause),
+ };
+ let result = await perform();
+ const cleanupFailures: {
+ readonly path: string;
+ readonly cause: unknown;
+ }[] = [];
+ for (const [owner, path] of [
+ [snapshotOwner, snapshotPath],
+ [sourceOwner, target.path],
+ ] as const) {
+ if (owner === undefined) continue;
+ const cleanup = await resources.release({
+ kind: "file-handle",
+ handle: owner,
+ resource: path,
+ });
+ if (cleanup.kind === "failed")
+ cleanupFailures.push({ path, cause: cleanup.cause });
+ }
+ if (cleanupFailures.length > 0) {
+ const cause = new AggregateError(
+ cleanupFailures.map(({ cause: failure }) => failure),
+ "Signature snapshot file handles could not be closed",
+ );
+ result = combineCleanupFailure(
+ target,
+ result,
+ cleanupFailures.map(({ path }) => path),
+ cause,
+ "close",
);
}
+ return result;
};
/** Reject target drift across signature command captures. */
diff --git a/tests/boundary/providers/native/nativeSignatureTargetBinding.test.ts b/tests/boundary/providers/native/nativeSignatureTargetBinding.test.ts
index 25b9e0730..b622e2d97 100644
--- a/tests/boundary/providers/native/nativeSignatureTargetBinding.test.ts
+++ b/tests/boundary/providers/native/nativeSignatureTargetBinding.test.ts
@@ -15,6 +15,7 @@ import {
import { dirname, join } from "node:path";
import { describe, expect, it } from "vitest";
import { NativeMacOSProvider } from "../../../../src/native/NativeMacOSProvider.js";
+import { ArtifactResourceScope } from "../../../../src/artifacts/ArtifactResourceScope.js";
import {
withSignatureTarget,
verifySignatureTarget,
@@ -277,6 +278,7 @@ it("returns typed cancellation at binding entry and final verification", async (
await expect(
withSignatureTarget(
target,
+ new ArtifactResourceScope(),
async () => {
throw new Error("Cancelled acquisition must not invoke inspection");
},
@@ -286,14 +288,18 @@ it("returns typed cancellation at binding entry and final verification", async (
ok: false,
error: { _tag: "AnalysisCancelledError" },
});
- await withSignatureTarget(target, async (binding) => {
- const result = await verifySignatureTarget(target, binding, signal);
- expect(result).toMatchObject({
- ok: false,
- error: { _tag: "AnalysisCancelledError" },
- });
- return result;
- });
+ await withSignatureTarget(
+ target,
+ new ArtifactResourceScope(),
+ async (binding) => {
+ const result = await verifySignatureTarget(target, binding, signal);
+ expect(result).toMatchObject({
+ ok: false,
+ error: { _tag: "AnalysisCancelledError" },
+ });
+ return result;
+ },
+ );
});
it("preserves cancellation after a capture instead of classifying it as invalid output", async () => {
@@ -348,21 +354,31 @@ it("copies and hashes the same bytes across multiple snapshot chunks", async ()
const bytes = Buffer.alloc(128 * 1024 + 13, 42);
await writeFile(path, bytes);
const target = await nativeMachoTargetForFile(path);
- await withSignatureTarget(target, async (binding) => {
- expect(await readFile(binding.snapshotPath)).toEqual(bytes);
- return verifySignatureTarget(target, binding);
- });
+ await withSignatureTarget(
+ target,
+ new ArtifactResourceScope(),
+ async (binding) => {
+ expect(await readFile(binding.snapshotPath)).toEqual(bytes);
+ return verifySignatureTarget(target, binding);
+ },
+ );
});
it("cleans the private snapshot when inspection throws", async () => {
const { target } = await fixture();
let snapshotPath: string | undefined;
- await expect(
- withSignatureTarget(target, async (binding) => {
+ const result = await withSignatureTarget(
+ target,
+ new ArtifactResourceScope(),
+ async (binding) => {
snapshotPath = binding.snapshotPath;
throw new Error("Invalid parsed output");
- }),
- ).rejects.toThrow("Invalid parsed output");
+ },
+ );
+ expect(result).toMatchObject({
+ ok: false,
+ error: { _tag: "AnalysisOutputError" },
+ });
if (snapshotPath === undefined) throw new Error("Expected snapshot");
await expect(lstat(dirname(snapshotPath))).rejects.toMatchObject({
code: "ENOENT",