Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
import {
AnalysisCleanupLease,
AnalysisCleanupLeaseGroup,
} from "../artifacts/AnalysisCleanupLease.js";
import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
import type { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
import type { AnalysisError } from "../domain/analysisErrorBase.js";
import type { PrivateRuntimeRoot } from "../process/PrivateRuntimeRoot.js";
import type { ProviderProcessSupervisor } from "../process/ProviderProcess.js";
import { OwnedCommandFailure } from "../process/OwnedCommand.js";
/** A private runtime cannot be removed until every retained command has stopped. */
export class WabtRuntime {
readonly lease: AnalysisCleanupLease;
readonly path: string;
readonly #commands = new Map<
ProviderProcessSupervisor,
AnalysisCleanupLease
>();
#unknownCommand: string | undefined;
constructor(root: Pick<PrivateRuntimeRoot, "path" | "close">) {
this.path = root.path;
this.lease = new AnalysisCleanupLease(async () => {
const pending = [...this.#commands.values()].filter(
(lease) => !lease.released,
);
if (pending.length > 0 || this.#unknownCommand !== undefined)
throw new ArtifactReaderFailure(
"unavailable",
"WABT commands must stop before runtime removal",
{
cleanup: {
reason:
this.#unknownCommand ??
"WABT command cleanup remains incomplete",
resources: [
...new Set([
root.path,
...pending.flatMap((lease) => lease.cleanupResources ?? []),
]),
],
},
},
);
await root.close();
}, [root.path]);
}
/** Adopt only the supervisor supplied by the command boundary, never a PID or label. */
retainCommandFailure(
cause: unknown,
failure: AnalysisError,
resources: ArtifactResourceScope,
): void {
if (
!(cause instanceof OwnedCommandFailure) ||
cause.cleanupFailure === null
)
return;
const owner = cause.cleanupOwner;
if (owner === undefined) {
this.#unknownCommand = cause.cleanupFailure;
return;
}
let lease = this.#commands.get(owner);
if (lease === undefined) {
lease = new AnalysisCleanupLease(async () => {
const stopped = await owner.stop();
if (stopped.status === "incomplete")
throw new ArtifactReaderFailure("unavailable", stopped.reason, {
cleanup: { reason: stopped.reason, resources: cause.resources },
});
}, cause.resources);
this.#commands.set(owner, lease);
resources.retain({
kind: "lease",
resource: cause.resources[0] ?? this.path,
lease,
});
}
new AnalysisCleanupLeaseGroup(failure, [lease]);
}
}