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 {
analysisProfileSchema,
type AnalysisProfileCommitment,
} from "../../domain/analysisProfile.js";
import type { BinaryTarget } from "../../domain/binaryTargetTypes.js";
import {
AnalysisCancelledError,
AnalysisUnsupportedTargetError,
} from "../../domain/analysisErrorCore.js";
import { AnalysisError } from "../../domain/analysisErrorBase.js";
import { jsonObjectSchema, type JsonValue } from "../../domain/jsonValue.js";
import { err, ok, type Result } from "../../domain/result.js";
import type {
AnalysisProviderBoundClientFactory,
AnalysisProfileResolutionOptions,
AnalysisProviderCandidate,
} from "../AnalysisProvider.js";
import type { AnalysisProviderCandidateStatus } from "./AnalysisProviderRegistry.js";
import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
/** Profile-resolution truth for one discovered provider candidate. */
export interface AnalysisProviderCandidateEvaluation {
readonly candidate: AnalysisProviderCandidate;
readonly status: AnalysisProviderCandidateStatus;
readonly profile?: AnalysisProfileCommitment;
readonly createClient?: AnalysisProviderBoundClientFactory;
readonly profileError?: AnalysisError;
}
/** Resolve and validate one provider profile without starting its client. */
export const evaluateAnalysisProviderCandidate = async (
candidate: AnalysisProviderCandidate,
status: AnalysisProviderCandidateStatus,
target: BinaryTarget,
options: AnalysisProfileResolutionOptions = {},
): Promise<
Result<AnalysisProviderCandidateEvaluation, AnalysisCancelledError>
> => {
const { signal } = options;
if (signalIsAborted(signal))
return err(
new AnalysisCancelledError("open_binary", { cause: signal?.reason }),
);
let resolved: Awaited<ReturnType<typeof candidate.resolveAnalysisProfile>>;
try {
resolved = await candidate.resolveAnalysisProfile(target, options);
} catch (cause: unknown) {
resolved = err(
cause instanceof AnalysisError
? cause
: new ProviderAdapterError(
status.provider.id,
"resolve_analysis_profile",
{
cause,
diagnostics: { reason: "Provider profile resolution threw" },
},
),
);
}
if (!resolved.ok && resolved.error instanceof AnalysisCancelledError)
return err(resolved.error);
if (!resolved.ok) {
const error = resolved.error;
const rejection =
error instanceof AnalysisUnsupportedTargetError
? {
candidate,
status: {
...status,
targetSupport: {
status: "unsupported" as const,
code: "target_format_unsupported" as const,
reason: error.reason,
diagnostics: { path: error.path, error_tag: error._tag },
},
},
}
: rejectedProfile(candidate, status, error.message, {
error_tag: error._tag,
});
return ok({ ...rejection, profileError: error });
}
if (signalIsAborted(signal))
return err(
new AnalysisCancelledError("open_binary", { cause: signal?.reason }),
);
try {
if (resolved.value.profile === null)
return ok(
rejectedProfile(
candidate,
status,
"Provider version or analysis profile could not be resolved",
),
);
const profile = analysisProfileSchema.parse(resolved.value.profile);
const identity = candidate.identity();
if (
profile.provider.id !== identity.id ||
profile.provider.name !== identity.name ||
(identity.version !== null &&
profile.provider.version !== identity.version)
)
return ok(
rejectedProfile(
candidate,
status,
"Resolved analysis profile has mismatched provider identity",
),
);
return ok({
candidate,
status,
profile,
...(resolved.value.createClient === undefined
? {}
: { createClient: resolved.value.createClient }),
});
} catch (cause: unknown) {
void cause;
return ok(
rejectedProfile(
candidate,
status,
"Provider returned an invalid analysis profile",
),
);
}
};
const signalIsAborted = (signal: AbortSignal | undefined): boolean =>
signal?.aborted === true;
const rejectedProfile = (
candidate: AnalysisProviderCandidate,
status: AnalysisProviderCandidateStatus,
reason: string,
diagnostics: Readonly<Record<string, JsonValue>> = {},
): AnalysisProviderCandidateEvaluation => ({
candidate,
status: {
...status,
availability: {
status: "unavailable",
code: "version_unresolved",
reason,
diagnostics: jsonObjectSchema.parse({
...status.availability.diagnostics,
...diagnostics,
}),
},
},
});