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 type { ProviderAvailability } from "../application/AnalysisProvider.js";
import type { JebAnalysisAvailability } from "../application/jeb/JebAnalysisPort.js";
import { AnalysisError } from "../domain/analysisErrorBase.js";
import {
buildCapabilityInventory,
compactToolAvailability,
} from "../application/CapabilityInventory.js";
import { toolContract } from "../contracts/toolContracts.js";
import type {
ClientFeatureAvailability,
ToolAvailability,
} from "../contracts/toolOutputSchemaPrimitives.js";
import { jsonObjectSchema, type JsonValue } from "../domain/jsonValue.js";
import { createServerIdentity } from "../serverIdentity.js";
import { mcpClientMetadata } from "./mcpClientMetadata.js";
import type { AvailabilityPolicy } from "../application/CapabilityInventory.js";
import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
import { err } from "../domain/result.js";
import { CURRENT_ENTRYPOINT_PATH } from "../process/CurrentEntrypointPath.js";
/** Provider-owned live probes used by session discovery. */
export interface SessionAvailabilityProbes {
readonly androidAnalysisAvailability: (
signal: AbortSignal,
) => Promise<ProviderAvailability>;
readonly adbAnalysisAvailability?: (
signal: AbortSignal,
) => Promise<ProviderAvailability>;
readonly apktoolAnalysisAvailability?: (
signal: AbortSignal,
) => Promise<ProviderAvailability>;
readonly jebAnalysisAvailability?: (
signal: AbortSignal,
) => Promise<JebAnalysisAvailability>;
readonly evmLimiterAvailability?: (
signal: AbortSignal,
) => Promise<ProviderAvailability | undefined>;
}
/** Inputs required to register the binary session status tool. */
export interface SessionStatusToolOptions extends SessionAvailabilityProbes {
readonly server: EvidenceMcpServer;
readonly session: BinarySessionPort;
readonly contract: ReturnType<typeof toolContract<"binary_session">>;
readonly startedAt: string;
readonly availabilityPolicy: () => AvailabilityPolicy;
}
const probeSessionAvailability = (
probes: SessionAvailabilityProbes,
signal: AbortSignal,
): Promise<{
readonly android: ProviderAvailability;
readonly adb: ProviderAvailability | undefined;
readonly apktool: ProviderAvailability | undefined;
readonly jeb: JebAnalysisAvailability | undefined;
readonly evmLimiter: ProviderAvailability | undefined;
}> =>
Promise.all([
probes.androidAnalysisAvailability(signal),
probes.adbAnalysisAvailability?.(signal) ?? undefined,
probes.apktoolAnalysisAvailability?.(signal) ?? undefined,
probes.jebAnalysisAvailability?.(signal) ?? undefined,
probes.evmLimiterAvailability?.(signal) ?? undefined,
] as const).then(([android, adb, apktool, jeb, evmLimiter]) => ({
android,
adb,
apktool,
jeb,
evmLimiter,
}));
/** Register the read-only provider and target status operation. */
export const registerSessionStatusTool = (
options: SessionStatusToolOptions,
): void => {
const { server, session, contract, startedAt, availabilityPolicy } = options;
server.registerTool(
contract.name,
toolRegistrationOptions(contract),
async (input, context) => {
const { client, clientFeatures, protocolVersion } = mcpClientMetadata(
context,
server.server,
);
let availabilityResults: Awaited<
ReturnType<typeof probeSessionAvailability>
>;
let status: JsonValue;
try {
availabilityResults = await probeSessionAvailability(
options,
context.mcpReq.signal,
);
status = await session.status({ signal: context.mcpReq.signal });
} catch (cause) {
if (!(cause instanceof AnalysisError)) throw cause;
return server.delivery.toCallToolResult(err(cause), contract);
}
const statusObject = jsonObjectSchema.parse(status);
const toolAvailability = buildCapabilityInventory(
status,
{
...availabilityPolicy(),
androidAnalysisAvailability: availabilityResults.android,
...(availabilityResults.adb === undefined
? {}
: { adbAnalysisAvailability: availabilityResults.adb }),
...(availabilityResults.apktool === undefined
? {}
: { apktoolAnalysisAvailability: availabilityResults.apktool }),
...(availabilityResults.jeb === undefined
? {}
: { jebAnalysisAvailability: availabilityResults.jeb }),
...(availabilityResults.evmLimiter === undefined
? {}
: { evmLimiterAvailability: availabilityResults.evmLimiter }),
},
clientFeatures,
);
const serverIdentity = createServerIdentity({
startedAt,
commandPath: CURRENT_ENTRYPOINT_PATH,
catalog: server.catalogIdentity,
expected: {
...(input.expected_package_version === undefined
? {}
: { package_version: input.expected_package_version }),
...(input.expected_catalog_digest === undefined
? {}
: { catalog_digest: input.expected_catalog_digest }),
...(input.expected_server_path === undefined
? {}
: { server_path: input.expected_server_path }),
},
...(client === undefined ? {} : { client }),
...(protocolVersion === undefined ? {} : { protocolVersion }),
});
return server.delivery.toCallToolResult(
{
ok: true,
value: projectSessionStatus({
status: statusObject,
toolAvailability,
serverIdentity,
clientFeatures,
}),
},
contract,
);
},
);
};
const projectSessionStatus = (options: {
readonly status: Readonly<
Record<string, import("../domain/jsonValue.js").JsonValue>
>;
readonly toolAvailability: readonly ToolAvailability[];
readonly serverIdentity: ReturnType<typeof createServerIdentity>;
readonly clientFeatures: ClientFeatureAvailability;
}) =>
jsonObjectSchema.parse({
...options.status,
tool_availability: compactToolAvailability(options.toolAvailability),
client_features: options.clientFeatures,
server_identity: options.serverIdentity,
});