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 { open } from "node:fs/promises";
import type { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
import {
assertArtifactReadActive,
artifactFileCancellationCause,
artifactFilePrimaryFailure,
mapArtifactFileFailure,
bindArtifactFileCleanup,
withArtifactFileHandle,
withArtifactRegularFile,
} from "../artifacts/ArtifactFileOperation.js";
import {
readStableFileBytes,
RegularFileCapacityError,
} from "../filesystem/readStableFileBytes.js";
import { AnalysisError } from "../domain/analysisErrorBase.js";
import {
AnalysisCancelledError,
AnalysisAccessDeniedError,
AnalysisArtifactChangedError,
AnalysisResourceConstraintError,
} from "../domain/analysisErrorCore.js";
import { RegularFileChangedError } from "../filesystem/RegularFile.js";
import { ProviderAdapterError } from "../domain/providerAdapterError.js";
import { ProviderCleanupError } from "../domain/providerCleanupError.js";
import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
import type { JsonValue } from "../domain/jsonValue.js";
/** Bounded serial read; the caller owns admission and final descriptor cleanup. */
export const readGhidraProfileArtifact = <Value>(
path: string,
maximumBytes: number,
resources: ArtifactResourceScope,
signal: AbortSignal | undefined,
interpret: (bytes: Buffer) => Value,
): Promise<Value> =>
withArtifactRegularFile(path, resources, signal, async (file) => {
const bytes = await readStableFileBytes(file, path, maximumBytes, {
symlinks: "reject",
...(signal === undefined ? {} : { signal }),
});
return interpret(bytes);
});
/** Own the new private snapshot descriptor through write and final close. */
export const writeGhidraProfileArtifact = async (
path: string,
bytes: Buffer | string,
resources: ArtifactResourceScope,
signal?: AbortSignal,
): Promise<void> => {
assertArtifactReadActive(signal);
const file = await open(path, "wx", 0o600);
await withArtifactFileHandle(path, file, resources, signal, (handle) =>
handle.writeFile(bytes),
);
};
/** Preserve physical failure, exact cancellation, and all retained file leases. */
export const ghidraFileFailure = (
cause: unknown,
operation: string,
diagnostics: Readonly<Record<string, JsonValue>> = {},
): AnalysisError => {
cause = mapArtifactFileFailure(cause, (primary) => {
if (primary instanceof RegularFileCapacityError)
return new AnalysisResourceConstraintError(
operation,
"file-size",
primary.message,
{
maximum_bytes: primary.maximumBytes,
observed_bytes: primary.observedBytes.toString(),
},
{ cause: primary, diagnostics, retryable: false },
);
if (primary instanceof RegularFileChangedError)
return new AnalysisArtifactChangedError(
operation,
primary.path,
primary.message,
{ cause: primary, diagnostics },
);
if (
primary instanceof Error &&
"code" in primary &&
(primary.code === "EACCES" || primary.code === "EPERM")
) {
const path =
"path" in primary && typeof primary.path === "string"
? primary.path
: diagnostics.path;
if (typeof path === "string")
return new AnalysisAccessDeniedError(operation, path, primary.code, {
cause: primary,
diagnostics,
});
}
return primary;
});
if (cause instanceof AnalysisError) return cause;
const primary = artifactFilePrimaryFailure(cause);
const reason = primary instanceof Error ? primary.message : String(primary);
const cleanup =
cause instanceof ArtifactReaderFailure ? cause.cleanup : undefined;
if (primary instanceof AnalysisError) {
if (cleanup === undefined) return primary;
const failure = new ProviderCleanupError(
"ghidra",
cleanup.resources,
{
reason: cleanup.reason,
},
{ cause },
);
bindArtifactFileCleanup(cause, failure);
return analysisErrorWithCleanupFailure(
primary,
failure,
operation,
).bindCleanupDependencies([
...(primary.cleanupIncomplete ? [primary] : []),
failure,
]);
}
const error =
cause instanceof ArtifactReaderFailure && cause.reason === "cancelled"
? new AnalysisCancelledError(operation, {
cause: artifactFileCancellationCause(cause),
cleanup,
diagnostics,
})
: new ProviderAdapterError("ghidra", operation, {
cause,
cleanup,
diagnostics: {
...diagnostics,
...(primary instanceof Error &&
"code" in primary &&
typeof primary.code === "string"
? { system_code: primary.code }
: {}),
...(primary instanceof Error &&
"syscall" in primary &&
typeof primary.syscall === "string"
? { syscall: primary.syscall }
: {}),
reason,
},
userMessage: reason,
});
bindArtifactFileCleanup(cause, error);
return error;
};