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 type { EvidenceMcpServer } from "./EvidenceMcpServer.js";
import type { BinarySessionPort } from "../application/binary/BinarySessionPort.js";
import { toolContract } from "../contracts/toolContracts.js";
import { compareArtifacts } from "../domain/artifactComparison.js";
import { ARTIFACT_COMPARISON_PROVIDER } from "../domain/comparisonEvidenceIdentity.js";
import { createEvidence } from "../domain/evidence.js";
import { readEvidence } from "../domain/evidenceValidation.js";
import { jsonValueSchema } from "../domain/jsonValue.js";
import { resolveArtifactComparisonEvidence } from "../application/artifacts/ArtifactComparisonEvidence.js";
import { investigationEvidenceLookup } from "../application/investigation/InvestigationEvidence.js";
import type { RecordUnknownInput } from "../domain/residualUnknown.js";
import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
import { runDerivedOperation } from "./runDerivedOperation.js";
import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
import { withAdmittedAnalysis } from "./analysisAdmission.js";
import { runAdmittedToolOperation } from "./admittedToolOperation.js";
import { recordSessionEvidenceSources } from "./sessionEvidence.js";
/** Register Evidence-backed deterministic artifact comparison. */
export const registerArtifactComparisonTool = (
server: EvidenceMcpServer,
session: BinarySessionPort,
contract: ReturnType<typeof toolContract<"compare_artifacts">>,
): void => {
const admission = withAdmittedAnalysis({ kind: "session", session });
const evidenceById = investigationEvidenceLookup(session);
server.registerTool(
contract.name,
toolRegistrationOptions(contract),
async (input, context) =>
runAdmittedToolOperation(
server,
admission,
contract.name,
context.mcpReq.signal,
async () => {
const computed = await runDerivedOperation(
context,
contract.name,
() => {
const suppliedLeft = readEvidence(input.left);
if (!suppliedLeft.ok) throw suppliedLeft.error;
const suppliedRight = readEvidence(input.right);
if (!suppliedRight.ok) throw suppliedRight.error;
const resolvedLeft = resolveArtifactComparisonEvidence(
suppliedLeft.value,
evidenceById,
);
if (!resolvedLeft.ok) throw resolvedLeft.error;
const resolvedRight = resolveArtifactComparisonEvidence(
suppliedRight.value,
evidenceById,
);
if (!resolvedRight.ok) throw resolvedRight.error;
const left = resolvedLeft.value;
const right = resolvedRight.value;
return { left, right, comparison: compareArtifacts(left, right) };
},
);
if (!computed.ok)
return server.delivery.toCallToolResult(computed, contract);
const { left, right, comparison } = computed.value;
const recordedSources = recordSessionEvidenceSources(
(source) => session.recordEvidence(source),
[left, right],
);
if (!recordedSources.ok)
return server.delivery.toCallToolResult(recordedSources, contract);
const leftEvidenceIds = [left.evidence_id];
const rightEvidenceIds = [right.evidence_id];
const evidence = createEvidence(
undefined,
ARTIFACT_COMPARISON_PROVIDER,
{
predicateType: "rea.artifact-comparison",
operation: contract.name,
parameters: {
left_evidence_ids: leftEvidenceIds,
right_evidence_ids: rightEvidenceIds,
},
result: jsonValueSchema.parse(comparison),
confidence: "derived",
authority: "analyst-inference",
limitations: comparison.limitations,
evidenceLinks: [...leftEvidenceIds, ...rightEvidenceIds],
},
);
return server.delivery.toEvidenceToolResult(
evidence,
contract,
recordDerivedEvidence(
session,
evidence,
artifactUnknownInput(
left,
right,
comparison.status,
evidence.evidence_id,
),
),
);
},
),
);
};
const artifactUnknownInput = (
left: { readonly evidence_id: string },
right: { readonly evidence_id: string },
status: ReturnType<typeof compareArtifacts>["status"],
comparisonEvidenceId: string,
): RecordUnknownInput | undefined => {
if (status === "unchanged") return undefined;
const contradictory =
(status === "changed" || status === "contradiction") &&
left.evidence_id !== right.evidence_id;
return {
question: `Artifact comparison is ${status} (comparison ${comparisonEvidenceId})`,
severity:
status === "unknown" || status === "truncated" ? "high" : "medium",
domain: "artifact-comparison",
supporting_evidence_ids: contradictory
? [left.evidence_id]
: [...new Set([left.evidence_id, right.evidence_id])],
contradicting_evidence_ids: contradictory ? [right.evidence_id] : [],
required_authority: "shipped-artifact",
required_confidence: "observed",
required_environment: null,
recommended_probes: [
{
operation: "inspect_artifact",
rationale: "Inspect both artifacts and compare their complete graphs.",
},
],
relationships: [],
};
};