rea-agents 6.5.0 → 6.7.0

package/dist/native/pwntools/PwntoolsDecoder.js

@@ -1,3 +1,5 @@
+import { AnalysisCleanupLease, AnalysisCleanupLeaseGroup, } from "../../artifacts/AnalysisCleanupLease.js";
+import { bindArtifactFileCleanup, artifactFileCancellationCause, } from "../../artifacts/ArtifactFileOperation.js";
 import { pwntoolsDecoderFailure, pwntoolsUnavailable, capturedPwntoolsOutput, } from "./PwntoolsFailures.js";
 import { randomUUID } from "node:crypto";
 import { access, stat, writeFile } from "node:fs/promises";
@@ -55,7 +57,9 @@ export class PwntoolsDecoder {
     }
     #enqueue(inspect, options) {
         if (options?.signal?.aborted)
-            return Promise.resolve(err(new AnalysisCancelledError(this.profile.operation)));
+            return Promise.resolve(err(new AnalysisCancelledError(this.profile.operation, {
+                cause: options?.signal?.reason,
+            })));
         if (this.#closing)
             return Promise.resolve(err(this.#closedError()));
         const key = Symbol();
@@ -66,12 +70,16 @@ export class PwntoolsDecoder {
         const operation = this.#tail.then(() => {
             this.#admissions.settle(key, "admitted");
             if (options?.signal?.aborted)
-                return err(new AnalysisCancelledError(this.profile.operation));
+                return err(new AnalysisCancelledError(this.profile.operation, {
+                    cause: options?.signal?.reason,
+                }));
             return this.#closing ? err(this.#closedError()) : inspect();
         });
         this.#tail = operation.then(() => undefined, () => undefined);
         return admission.then((state) => state === "cancelled"
-            ? err(new AnalysisCancelledError(this.profile.operation))
+            ? err(new AnalysisCancelledError(this.profile.operation, {
+                cause: options?.signal?.reason,
+            }))
             : operation);
     }
     async #inspect(input, options) {
@@ -109,7 +117,9 @@ export class PwntoolsDecoder {
         const failure = (cause) => pwntoolsDecoderFailure(cause, phase, selectedPath, executablePath, {}, context);
         try {
             if (options?.signal?.aborted)
-                throw new AnalysisCancelledError(OPERATION);
+                throw new AnalysisCancelledError(OPERATION, {
+                    cause: options.signal.reason,
+                });
             if (process.platform !== "linux" || process.arch !== "x64")
                 throw new AnalysisCapabilityUnavailableError(this.identity.id, OPERATION, HOST_REQUIREMENT, { userMessage: HOST_REQUIREMENT });
             if (!isAbsolute(selectedPath))
@@ -131,6 +141,7 @@ export class PwntoolsDecoder {
             root = await this.createRuntime();
             this.#pendingCleanup = {
                 root,
+                rootLease: AnalysisCleanupLease.forCloseOwner(root, root.path),
                 process: undefined,
                 failure: undefined,
                 diagnostics: undefined,
@@ -139,11 +150,25 @@ export class PwntoolsDecoder {
             const requestPath = join(root.path, "request.json");
             const snapshotPath = join(root.path, "object.snapshot");
             const replyPath = join(root.path, "reply.json");
-            await writeFile(snapshotPath, snapshot.bytes, {
-                flag: "wx",
-                mode: 0o600,
-                ...(options?.signal === undefined ? {} : { signal: options.signal }),
-            });
+            try {
+                await writeFile(snapshotPath, snapshot.bytes, {
+                    flag: "wx",
+                    mode: 0o600,
+                    ...(options?.signal === undefined ? {} : { signal: options.signal }),
+                });
+            }
+            catch (cause) {
+                // Normalize Node's abort envelope only at the write that produced it.
+                if (options?.signal?.aborted &&
+                    cause instanceof Error &&
+                    "code" in cause &&
+                    cause.code === "ABORT_ERR" &&
+                    cause.cause === options.signal.reason)
+                    throw new AnalysisCancelledError(OPERATION, {
+                        cause: options.signal.reason,
+                    });
+                throw cause;
+            }
             await writeFile(requestPath, JSON.stringify({ snapshot_path: snapshotPath, reply_path: replyPath }), { flag: "wx", mode: 0o600 });
             const execution = await this.#runCommand({
                 command: this.environment.REA_PWNTOOLS_PYTHON ?? "",
@@ -154,9 +179,6 @@ export class PwntoolsDecoder {
                     requestPath,
                 ],
                 cwd: root.path,
-                // Caller-selected Python launchers can exec through prlimit or a
-                // shell wrapper. Keep parent/group/run-token ownership across exec.
-                expectedCommand: null,
                 runId: `rea-artifact-decoder-${randomUUID()}`,
                 hostEnvironment: {
                     ...this.environment,
@@ -172,12 +194,28 @@ export class PwntoolsDecoder {
                 reply = replySchema.parse(JSON.parse(file.bytes.toString("utf8")));
             }
             catch (cause) {
-                if (options?.signal?.aborted)
-                    throw new AnalysisCancelledError(OPERATION, {
-                        cause,
+                if (cause instanceof ArtifactReaderFailure &&
+                    cause.reason === "cancelled") {
+                    const error = new AnalysisCancelledError(OPERATION, {
+                        cause: artifactFileCancellationCause(cause),
                         capturedOutput,
+                        ...(cause instanceof ArtifactReaderFailure &&
+                            cause.cleanup !== undefined
+                            ? { cleanup: cause.cleanup }
+                            : {}),
                     });
-                throw new AnalysisOutputError(OPERATION, `Owned pwntools decoder reply failed for ${input.path}: ${cause instanceof z.ZodError ? cause.issues[0]?.message + " at " + (cause.issues[0]?.path.map(String).join(".") ?? "root") : cause instanceof Error ? cause.message : String(cause)}`, { cause, capturedOutput });
+                    bindArtifactFileCleanup(cause, error);
+                    throw error;
+                }
+                const error = new AnalysisOutputError(OPERATION, `Owned pwntools decoder reply failed for ${input.path}: ${cause instanceof z.ZodError ? cause.issues[0]?.message + " at " + (cause.issues[0]?.path.map(String).join(".") ?? "root") : cause instanceof Error ? cause.message : String(cause)}`, {
+                    cause,
+                    capturedOutput,
+                    ...(cause instanceof ArtifactReaderFailure
+                        ? { cleanup: cause.cleanup }
+                        : {}),
+                });
+                bindArtifactFileCleanup(cause, error);
+                throw error;
             }
             if (!reply.ok) {
                 if (reply.reason === "unsupported-target")
@@ -233,13 +271,7 @@ export class PwntoolsDecoder {
                 return err(cause);
             }
             const evidence = await readPwntoolsFailureEvidence(cause, root?.path, this.#resources);
-            const primary = options?.signal?.aborted &&
-                (cause === options.signal.reason ||
-                    (cause instanceof Error && cause.name === "AbortError") ||
-                    (cause instanceof ArtifactReaderFailure &&
-                        cause.cleanup !== undefined))
-                ? new AnalysisCancelledError(OPERATION, { cause })
-                : pwntoolsDecoderFailure(cause, phase, selectedPath, executablePath, evidence, context);
+            const primary = pwntoolsDecoderFailure(cause, phase, selectedPath, executablePath, evidence, context);
             result = err(primary);
         }
         if (this.#pendingCleanup !== undefined) {
@@ -252,20 +284,21 @@ export class PwntoolsDecoder {
                 : result.error.capturedOutput;
         }
         const cleanup = await this.#completeCleanup(() => this.#retire());
-        if (cleanup !== undefined)
-            return err(result.ok
-                ? cleanup
-                : analysisErrorWithCleanupFailure(result.error, cleanup, OPERATION));
-        return result.ok && options?.signal?.aborted
-            ? err(new AnalysisCancelledError(OPERATION, {
+        if (result.ok && options?.signal?.aborted)
+            result = err(new AnalysisCancelledError(OPERATION, {
+                cause: options.signal.reason,
                 partialObservation: result.value,
-                capturedOutput: {
-                    stdout: result.value.diagnostics.stdout,
-                    stderr: result.value.diagnostics.stderr,
-                    truncated: result.value.diagnostics.truncated,
-                },
-            }))
-            : result;
+                capturedOutput: result.value.diagnostics,
+            }));
+        if (cleanup !== undefined) {
+            const failure = result.ok
+                ? cleanup
+                : analysisErrorWithCleanupFailure(result.error, cleanup, OPERATION).bindCleanupDependencies([result.error, cleanup]);
+            if (this.#pendingCleanup !== undefined)
+                this.#pendingCleanup.failure = failure;
+            return err(failure);
+        }
+        return result;
     }
     async #runCommand(spawn, options, failure) {
         // A runtime is registered before either decoder stage may acquire a process.
@@ -274,7 +307,13 @@ export class PwntoolsDecoder {
             throw new Error("Decoder command requires an owned runtime.");
         let outcome;
         try {
-            outcome = ok(await runOwnedCommand(spawn, {
+            outcome = ok(await runOwnedCommand({
+                ...spawn,
+                // Every decoder stage can replace its launcher through exec,
+                // including the optional Python-to-GDB handoff. Preserve explicit
+                // pins; otherwise keep parent/group/run-token proof across exec.
+                expectedCommand: spawn.expectedCommand ?? null,
+            }, {
                 timeoutMs: PWNTOOLS_LIMITS.timeoutMs,
                 diagnosticBytes: PWNTOOLS_LIMITS.diagnosticBytes,
             }, {
@@ -282,8 +321,18 @@ export class PwntoolsDecoder {
                     ? {}
                     : { signal: options.signal }),
                 ...(this.launcher === undefined ? {} : { launcher: this.launcher }),
-                retainCleanup: (owner) => {
-                    pending.process = owner;
+                retainCleanup: (supervisor) => {
+                    const ownership = supervisor.launch.ownership;
+                    pending.process = {
+                        supervisor,
+                        lease: new AnalysisCleanupLease(async () => {
+                            const stopped = await supervisor.stop();
+                            if (stopped.status === "incomplete")
+                                throw new Error(stopped.reason, { cause: stopped });
+                        }, ownership === undefined
+                            ? ["owned-decoder"]
+                            : ownedCommandResources(ownership)),
+                    };
                 },
             }));
         }
@@ -296,7 +345,7 @@ export class PwntoolsDecoder {
                 throw cleanup;
             // Until retirement succeeds, resource-limit markers remain unverified.
             const primary = failure(outcome.error);
-            throw analysisErrorWithCleanupFailure(primary, cleanup, this.profile.operation);
+            throw analysisErrorWithCleanupFailure(primary, cleanup, this.profile.operation).bindCleanupDependencies([primary, cleanup]);
         }
         if (!outcome.ok)
             throw outcome.error;
@@ -320,10 +369,11 @@ export class PwntoolsDecoder {
             catch (cause) {
                 const observation = ArtifactReaderFailure.cleanupObservation(cause, "pwntools artifact read");
                 const resourceFailure = new ProviderCleanupError(this.identity.id, observation.resources, { reason: observation.reason }, { operation: this.profile.operation, cause });
+                bindArtifactFileCleanup(cause, resourceFailure);
                 failure =
                     failure === undefined
                         ? resourceFailure
-                        : analysisErrorWithCleanupFailure(failure, resourceFailure, this.profile.operation);
+                        : analysisErrorWithCleanupFailure(failure, resourceFailure, this.profile.operation).bindCleanupDependencies([failure, resourceFailure]);
             }
             if (failure !== undefined)
                 throw failure;
@@ -345,29 +395,39 @@ export class PwntoolsDecoder {
         const pending = this.#pendingCleanup;
         if (pending?.process === undefined)
             return undefined;
-        const stopped = await pending.process.stop();
-        const ownership = pending.process.launch.ownership;
-        if (stopped.status === "incomplete")
-            return new ProviderCleanupError(this.identity.id, ownership === undefined
+        const process = pending.process;
+        const ownership = process.supervisor.launch.ownership;
+        try {
+            await process.lease.release();
+        }
+        catch (cause) {
+            const failure = new ProviderCleanupError(this.identity.id, ownership === undefined
                 ? [
                     "owned-decoder",
                     ...(pending.root === undefined ? [] : [pending.root.path]),
                 ]
                 : ownedCommandResources(ownership, pending.root?.path), {
-                reason: stopped.reason,
+                reason: cause instanceof Error ? cause.message : String(cause),
                 captured_output: {
                     ...(pending.diagnostics ??
-                        capturedPwntoolsOutput(pending.process.snapshot())),
+                        capturedPwntoolsOutput(process.supervisor.snapshot())),
                 },
                 previous_error: pending.failure === undefined
                     ? null
                     : projectAnalysisError(pending.failure),
             }, {
                 operation: this.profile.operation,
+                cause,
                 ...(pending.observation === undefined
                     ? {}
                     : { partialObservation: pending.observation }),
             });
+            new AnalysisCleanupLeaseGroup(failure, [
+                process.lease,
+                pending.rootLease,
+            ]);
+            return failure;
+        }
         pending.process = undefined;
         return undefined;
     }
@@ -386,17 +446,22 @@ export class PwntoolsDecoder {
                     : { partialObservation: this.#pendingCleanup.observation }),
             });
         }
+        if (failure !== undefined)
+            bindArtifactFileCleanup(failure.cause, failure);
         const processFailure = await this.#retireProcess();
         if (processFailure !== undefined) {
             return failure === undefined
                 ? processFailure
-                : analysisErrorWithCleanupFailure(failure, processFailure, this.profile.operation);
+                : analysisErrorWithCleanupFailure(failure, processFailure, this.profile.operation).bindCleanupDependencies([failure, processFailure]);
         }
+        // Retained descriptors still own local evidence under this root.
+        if (failure !== undefined)
+            return failure;
         const pending = this.#pendingCleanup;
         if (pending?.root !== undefined) {
             const root = pending.root;
             try {
-                await root.close();
+                await pending.rootLease.release();
                 pending.root = undefined;
             }
             catch (cause) {
@@ -415,10 +480,8 @@ export class PwntoolsDecoder {
                         ? {}
                         : { partialObservation: pending.observation }),
                 });
-                failure =
-                    failure === undefined
-                        ? rootFailure
-                        : analysisErrorWithCleanupFailure(failure, rootFailure, this.profile.operation);
+                new AnalysisCleanupLeaseGroup(rootFailure, [pending.rootLease]);
+                failure = rootFailure;
             }
         }
         if (!this.#resources.hasPending && pending?.root === undefined)

package/dist/native/pwntools/PwntoolsFailures.js

@@ -1,3 +1,4 @@
+import { artifactFileCancellationCause, bindArtifactFileCleanup, } from "../../artifacts/ArtifactFileOperation.js";
 import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
 import { AnalysisError, } from "../../domain/analysisErrorBase.js";
 import { AnalysisAccessDeniedError, AnalysisArtifactChangedError, AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, AnalysisTimeoutError, AnalysisResourceConstraintError, } from "../../domain/analysisErrorCore.js";
@@ -49,7 +50,12 @@ export const pwntoolsDecoderFailure = (cause, phase, path, executablePath = path
                 },
             }, { operation: context.operation, cause });
         if (cause.reason === "cancelled")
-            return new AnalysisCancelledError(context.operation, outputOptions);
+            return new AnalysisCancelledError(context.operation, {
+                ...outputOptions,
+                cause: cause.cancellation === undefined
+                    ? cause.cause
+                    : cause.cancellation.reason,
+            });
         if (cause.reason === "timeout")
             return new AnalysisTimeoutError(context.operation, PWNTOOLS_LIMITS.timeoutMs, outputOptions);
         if (cause.reason === "output-limit")
@@ -90,8 +96,16 @@ export const pwntoolsDecoderFailure = (cause, phase, path, executablePath = path
             return new AnalysisArtifactChangedError(context.operation, path, cause.message, {
                 cause,
             });
-        if (cause.reason === "cancelled")
-            return new AnalysisCancelledError(context.operation);
+        if (cause.reason === "cancelled") {
+            const error = new AnalysisCancelledError(context.operation, {
+                cause: artifactFileCancellationCause(cause),
+                cleanup: cause.cleanup,
+                partialObservation: cause.partialObservation,
+                capturedOutput: context.precedingOutput,
+            });
+            bindArtifactFileCleanup(cause, error);
+            return error;
+        }
         if (cause.reason === "limit" ||
             cause.reason === "path" ||
             cause.reason === "format")

package/dist/native/pwntools/PwntoolsRecordedCrashProvider.js

@@ -1,9 +1,10 @@
-import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
+import { AnalysisCancelledError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
 import { AnalysisError } from "../../domain/analysisErrorBase.js";
 import { recordedCrashPayloadSchema, recordedCrashSchema, } from "../../domain/native/recordedCrash.js";
 import { PrivateRuntimeRoot } from "../../process/PrivateRuntimeRoot.js";
 import { PwntoolsDecoder } from "./PwntoolsDecoder.js";
 import { PWNTOOLS_PROVIDER_IDENTITY } from "./PwntoolsRelease.js";
+import { validateCoreFileMappingAuthority } from "../pwndbg/CoreFileMappingAuthority.js";
 import { validateRecordedCrashSources } from "./RecordedCrashSourceBindings.js";
 import { validateRecordedCrashStructure } from "./RecordedCrashStructureBindings.js";
 import { inspectPwndbgCore, recordedCrashStageOutput, } from "../pwndbg/PwndbgCoreContext.js";
@@ -56,8 +57,17 @@ export class PwntoolsRecordedCrashProvider extends PwntoolsDecoder {
                 if (!input.include_debugger_context)
                     return value;
                 try {
+                    if (options?.signal?.aborted)
+                        throw new AnalysisCancelledError("inspect_recorded_crash", {
+                            cause: options.signal.reason,
+                            capturedOutput: diagnostics,
+                        });
+                    const authority = validateCoreFileMappingAuthority(value, snapshot.bytes);
+                    if (!authority.ok)
+                        throw authority.error;
                     const context = await inspectPwndbgCore({
                         environment,
+                        architecture: value.architecture,
                         rootPath,
                         resources,
                         diagnostics,

package/dist/objdump/ObjdumpCommand.js

@@ -1,4 +1,4 @@
-import { resolve } from "node:path";
+import { absoluteCallerPath } from "../filesystem/callerPath.js";
 export const OBJDUMP_PROVIDER_IDENTITY = {
     id: "gnu.objdump",
     name: "GNU objdump",
@@ -17,5 +17,8 @@ export const objdumpCommand = (input) => {
         disassemble: ["-d"],
         disassemble_all: ["-D"],
     };
-    return [...argumentsByOperation[input.operation], resolve(input.path)];
+    return [
+        ...argumentsByOperation[input.operation],
+        absoluteCallerPath(input.path),
+    ];
 };

package/dist/pcap/PcapOutput.js

@@ -10,6 +10,42 @@ const MAX_DECODED_BYTES = 128 * 1024 * 1024;
 const protocolFailure = (reason) => {
     throw new AnalysisProtocolError(`Invalid packet-capture output: ${reason}`);
 };
+/**
+ * capinfos -S prints each packet timestamp as seconds since the Unix epoch
+ * with the capture's own fractional precision, a leading minus for an instant
+ * before the epoch. Its default spelling is a zone-less local wall-clock time,
+ * so one capture reads differently on hosts in different time zones. Project
+ * the exact value to an RFC 3339 UTC instant, keeping the fractional digit
+ * count. "n/a" (an empty capture), a wall-clock spelling and a value outside
+ * years 0000 to 9999 stay unknown.
+ */
+const captureInstant = (value) => {
+    // Wireshark formats at most 64-bit seconds and nine fractional digits.
+    const match = /^(-?)(\d{1,20})(?:\.(\d{1,9}))?$/u.exec(value ?? "");
+    if (match?.[2] === undefined)
+        return null;
+    const negative = match[1] === "-";
+    let seconds = BigInt(match[2]);
+    let fraction = match[3] ?? "";
+    if (negative) {
+        // -1.25 is one and a quarter seconds before the epoch: whole second
+        // -2 plus 0.75, so the fraction is borrowed from the next whole second.
+        const digits = fraction.length;
+        const borrowed = digits > 0 && BigInt(fraction) > 0n;
+        seconds = -seconds - (borrowed ? 1n : 0n);
+        if (borrowed)
+            fraction = (10n ** BigInt(digits) - BigInt(fraction))
+                .toString()
+                .padStart(digits, "0");
+    }
+    if (seconds < -62167219200n || seconds > 253402300799n)
+        return null;
+    const date = new Date(Number(seconds) * 1000);
+    const year = date.getUTCFullYear();
+    if (Number.isNaN(year) || year < 0 || year > 9999)
+        return null;
+    return `${date.toISOString().slice(0, 19)}${fraction === "" ? "" : `.${fraction}`}Z`;
+};
 /** capinfos -M with a C locale provides exact numbers instead of "20 k". */
 export const parseCapinfosOutput = (stdout) => {
     const lines = new Map();
@@ -42,8 +78,8 @@ export const parseCapinfosOutput = (stdout) => {
         fileType,
         encapsulation,
         packetCount,
-        captureStart: lines.get("Earliest packet time") ?? null,
-        captureEnd: lines.get("Latest packet time") ?? null,
+        captureStart: captureInstant(lines.get("Earliest packet time") ?? lines.get("First packet time")),
+        captureEnd: captureInstant(lines.get("Latest packet time") ?? lines.get("Last packet time")),
         captureDurationSeconds: duration === null ? null : Number(duration[1]),
         snapshotLength: snapshotLength !== null &&
             Number.isSafeInteger(snapshotLength) &&

package/dist/pcap/PcapProvider.js

@@ -69,6 +69,7 @@ export class PcapProvider {
     environment;
     launcher;
     snapshots = new Set();
+    snapshotFailures = new Map();
     commands = new Map();
     constructor(options = {}) {
         this.environment = options.environment ?? process.env;
@@ -76,6 +77,7 @@ export class PcapProvider {
     }
     async run(operation, command, args, limits, signal, snapshot, inputPath) {
         let cleanup;
+        let retainedCommand;
         const output = await runPcapCommand({
             operation,
             command,
@@ -94,17 +96,20 @@ export class PcapProvider {
                 : { nativeBound: this.nativeBound }),
             ...(this.launcher === undefined ? {} : { launcher: this.launcher }),
             retain: (owner, resources, reason, capturedOutput) => {
-                this.commands.set(owner, {
+                retainedCommand = {
                     snapshot,
                     resources,
                     reason,
                     capturedOutput,
-                });
+                    ownerReleased: false,
+                    failure: undefined,
+                };
+                this.commands.set(owner, retainedCommand);
                 cleanup = { reason, resources, capturedOutput };
             },
         });
-        if (inputPath === undefined && cleanup !== undefined)
-            throw new ProviderCleanupError("pcap", cleanup.resources, {
+        if (inputPath === undefined && cleanup !== undefined) {
+            const failure = new ProviderCleanupError("pcap", cleanup.resources, {
                 reason: cleanup.reason,
                 previous_error: null,
                 captured_output: {
@@ -113,6 +118,10 @@ export class PcapProvider {
                     truncated: cleanup.capturedOutput.truncated,
                 },
             }, { operation });
+            if (retainedCommand !== undefined)
+                retainedCommand.failure = failure;
+            throw failure;
+        }
         return output;
     }
     nativeBound;
@@ -187,10 +196,12 @@ export class PcapProvider {
     }
     async discard(snapshot) {
         try {
-            if ([...this.commands.values()].some((command) => command.snapshot === snapshot))
+            if ([...this.commands.values()].some((command) => command.snapshot === snapshot && !command.ownerReleased))
                 throw new Error("An unreleased command still owns the capture snapshot");
             await snapshot.close();
             this.snapshots.delete(snapshot);
+            this.snapshotFailures.get(snapshot)?.resolveCleanup();
+            this.snapshotFailures.delete(snapshot);
             return undefined;
         }
         catch (cause) {
@@ -205,15 +216,22 @@ export class PcapProvider {
         catch (cause) {
             failures.push(cause);
         }
-        for (const owner of this.commands.keys()) {
+        for (const [owner, command] of this.commands) {
+            if (command.ownerReleased)
+                continue;
             try {
                 const result = await owner.stop();
                 if (result.status === "incomplete")
                     failures.push(result.reason);
                 else if (result.status === "not-owned")
                     failures.push("Command ownership remains unresolved");
-                else
-                    this.commands.delete(owner);
+                else {
+                    command.ownerReleased = true;
+                    if (command.snapshot === undefined) {
+                        command.failure?.resolveCleanup();
+                        this.commands.delete(owner);
+                    }
+                }
             }
             catch (cause) {
                 failures.push(cause);
@@ -221,8 +239,16 @@ export class PcapProvider {
         }
         for (const snapshot of this.snapshots) {
             const failure = await this.discard(snapshot);
-            if (failure !== undefined)
+            if (failure !== undefined) {
                 failures.push(failure);
+            }
+            else {
+                for (const [owner, command] of this.commands) {
+                    if (command.snapshot !== snapshot)
+                        continue;
+                    this.commands.delete(owner);
+                }
+            }
         }
         if (failures.length > 0)
             throw new ProviderCleanupError("pcap", [...this.snapshots]
@@ -305,11 +331,9 @@ export class PcapProvider {
             const capturedOutput = result.ok
                 ? undefined
                 : result.error.capturedOutput;
-            result = err(new ProviderCleanupError("pcap", [...new Set([snapshot.path, ...pendingCommand.resources])], {
+            const cleanupFailure = new ProviderCleanupError("pcap", [...new Set([snapshot.path, ...pendingCommand.resources])], {
                 reason: pendingCommand.reason,
-                previous_error: result.ok
-                    ? null
-                    : projectAnalysisError(result.error),
+                previous_error: result.ok ? null : projectAnalysisError(result.error),
                 ...(capturedOutput === undefined &&
                     pendingCommand.capturedOutput.stdout === "" &&
                     pendingCommand.capturedOutput.stderr === ""
@@ -322,12 +346,18 @@ export class PcapProvider {
             }, {
                 operation: request.operation,
                 ...(partialObservation === undefined ? {} : { partialObservation }),
-            }));
+            });
+            result = err(cleanupFailure);
         }
+        if (snapshot !== undefined &&
+            this.snapshots.has(snapshot) &&
+            !result.ok &&
+            result.error.cleanupIncomplete)
+            this.snapshotFailures.set(snapshot, result.error);
         return result;
     }
     async inspectCapture(selection, snapshot, path, identity, signal, request, provider, client) {
-        const info = await this.run("inspect_pcap_capture", selection.capinfos.command, ["-M", "--", snapshot.path], { timeoutMs: 60_000, maxOutputBytes: 64 * 1024 }, signal, snapshot, path);
+        const info = await this.run("inspect_pcap_capture", selection.capinfos.command, ["-M", "-S", "--", snapshot.path], { timeoutMs: 60_000, maxOutputBytes: 64 * 1024 }, signal, snapshot, path);
         const metadata = parseCapinfosOutput(info.stdout);
         if (metadata.sha256 !== null && metadata.sha256 !== identity.sha256)
             throw new AnalysisProtocolError("capinfos SHA256 disagrees with the owned capture snapshot");

package/dist/pcap/PcapSnapshot.js

@@ -1,3 +1,4 @@
+import { regularFileCancellation } from "../filesystem/OwnedRegularFile.js";
 import { createHash } from "node:crypto";
 import { chmod, open, stat, mkdir } from "node:fs/promises";
 import { join } from "node:path";
@@ -44,6 +45,11 @@ export class PcapSnapshot {
                 return await read();
             }
             catch (cause) {
+                const cancellation = regularFileCancellation(cause);
+                if (cancellation !== undefined)
+                    throw new AnalysisCancelledError(OPERATION, {
+                        cause: cancellation.reason,
+                    });
                 if (signal?.aborted)
                     throw new AnalysisCancelledError(OPERATION, { cause });
                 if (cause instanceof AnalysisError)
@@ -119,10 +125,18 @@ export class PcapSnapshot {
             return { bytes: copied, sha256: hash.digest("hex") };
         }
         catch (cause) {
-            if (signal?.aborted)
-                throw new AnalysisCancelledError(OPERATION, { cause });
+            if (cause instanceof RegularFileAdmissionFailure)
+                this.own(cause.owner);
+            const primary = cause instanceof RegularFileAdmissionFailure ? cause.cause : cause;
+            const cancellation = regularFileCancellation(primary);
+            if (cancellation !== undefined)
+                throw new AnalysisCancelledError(OPERATION, {
+                    cause: cancellation.reason,
+                });
             if (cause instanceof AnalysisError)
                 throw cause;
+            if (signal?.aborted)
+                throw new AnalysisCancelledError(OPERATION, { cause: signal.reason });
             throw new AnalysisResourceConstraintError(OPERATION, "file-size", "Owned capture snapshot I/O failed", null, { cause });
         }
     }
@@ -152,12 +166,18 @@ export class PcapSnapshot {
             await this.release(file);
         }
         catch (cause) {
-            if (signal?.aborted)
-                throw new AnalysisCancelledError(OPERATION, { cause });
             if (cause instanceof RegularFileAdmissionFailure)
                 this.own(cause.owner);
+            const primary = cause instanceof RegularFileAdmissionFailure ? cause.cause : cause;
+            const cancellation = regularFileCancellation(primary);
+            if (cancellation !== undefined)
+                throw new AnalysisCancelledError(OPERATION, {
+                    cause: cancellation.reason,
+                });
             if (cause instanceof AnalysisError)
                 throw cause;
+            if (signal?.aborted)
+                throw new AnalysisCancelledError(OPERATION, { cause: signal.reason });
             throw new AnalysisArtifactChangedError(OPERATION, selectedPath, "Cannot establish the owned packet snapshot's post-analysis identity.", { cause });
         }
     }