mirror of
https://github.com/morluto/rea.git
synced 2026-11-15 19:23:24 +00:00
* feat(ida)!: require an explicit protocol for attached IDA registrations An attached registration (the default mode) silently selected the legacy ida-pro-mcp 1.4 GUI proxy when `protocol` was omitted. The registration schema now resolves the upstream protocol once: attached registrations must name `"legacy"` or `"native"`, headless registrations resolve to the database supervisor, and consumers read the resolved protocol instead of inferring it from `mode`. BREAKING CHANGE: an attached IDA registration without `protocol` is refused with a configuration error naming the choice. Add `"protocol": "legacy"` to an ida-pro-mcp 1.4 proxy registration (or `"protocol": "native"` for the ida-free-mcp plugin). Headless registrations are unchanged. * test(ida): name the protocol in every attached registration fixture The setup budget fixture still wrote an attached URL registration without a protocol, and the IDA registration rejection fixtures relied on the missing protocol as one of several failures. Each now names its protocol, so setup reaches its timeout checks and every rejection case fails only for its own constraint.
140 lines
4.6 KiB
TypeScript
140 lines
4.6 KiB
TypeScript
import { rm } from "node:fs/promises";
|
|
import { decodeIdaToolResult } from "../../src/ida/IdaMcpConnection.js";
|
|
import { IdaSessionClient } from "../../src/ida/IdaSessionClient.js";
|
|
import type { JsonValue } from "../../src/domain/jsonValue.js";
|
|
import { createIdaTarget, RecordingIdaMcp } from "./idaMcp.js";
|
|
|
|
const roots: string[] = [];
|
|
|
|
/** Remove the workspaces of every session opened through `callGraphSession`. */
|
|
export const removeCallGraphSessions = async (): Promise<void> => {
|
|
for (const root of roots.splice(0))
|
|
await rm(root, { recursive: true, force: true });
|
|
};
|
|
|
|
export const FUNCTIONS: Readonly<
|
|
Record<string, { addr: string; name: string }>
|
|
> = {
|
|
main: { addr: "0x1000", name: "main" },
|
|
"0x1000": { addr: "0x1000", name: "main" },
|
|
"0x2000": { addr: "0x2000", name: "square" },
|
|
"0x3000": { addr: "0x3000", name: "printf_stub" },
|
|
};
|
|
|
|
export const edge = (from: string, to: string, type = "call") => ({
|
|
from,
|
|
to,
|
|
type,
|
|
});
|
|
export const graphRow = (
|
|
edges: readonly ReturnType<typeof edge>[],
|
|
extra: Readonly<Record<string, JsonValue>> = {},
|
|
): JsonValue => [
|
|
{
|
|
root: "0x1000",
|
|
nodes: [{ addr: "0x1000", name: "main", depth: 0 }],
|
|
edges: [...edges],
|
|
max_depth: 0,
|
|
truncated: false,
|
|
limit_reason: null,
|
|
max_edges_per_func: 200,
|
|
per_func_capped: false,
|
|
...extra,
|
|
},
|
|
];
|
|
|
|
/** A realistic reply for a callee that makes no further calls. */
|
|
const leafGraphRow = (root: string): JsonValue => [
|
|
{
|
|
root,
|
|
nodes: [{ addr: root, name: FUNCTIONS[root]?.name ?? null, depth: 0 }],
|
|
edges: [],
|
|
max_depth: 0,
|
|
truncated: false,
|
|
limit_reason: null,
|
|
max_edges_per_func: 200,
|
|
per_func_capped: false,
|
|
},
|
|
];
|
|
|
|
export interface Upstream {
|
|
/** Roots, besides the procedure itself, that the fake answers with a leaf graph; any other root is rejected. */
|
|
readonly leafRoots?: readonly string[];
|
|
/** Advertise the fake server's tools; omit for the default full set. */
|
|
readonly tools?: readonly string[];
|
|
/** Items the fake `callees` tool reports for the procedure. */
|
|
readonly callees: readonly JsonValue[];
|
|
/** Raw `callgraph` reply, or undefined when the tool is absent/failing. */
|
|
readonly callgraph?: JsonValue;
|
|
readonly callgraphFailure?: string;
|
|
/** Make the fake transport report a truncated preview for the `callgraph` reply. */
|
|
readonly callgraphTruncatedOutput?: boolean;
|
|
}
|
|
|
|
export const callGraphSession = async (
|
|
upstream: Upstream,
|
|
architecture: "x86_64" | "arm64" = "arm64",
|
|
available: readonly ("x86_64" | "arm64")[] = [architecture],
|
|
) => {
|
|
const { root, target } = await createIdaTarget(architecture, available);
|
|
roots.push(root);
|
|
const producer = new RecordingIdaMcp(target, "headless");
|
|
if (upstream.tools !== undefined) producer.tools = upstream.tools;
|
|
producer.beforeCall = async (name) => {
|
|
if (name !== "callgraph") return;
|
|
if (upstream.callgraphFailure !== undefined)
|
|
decodeIdaToolResult({
|
|
content: [{ type: "text", text: upstream.callgraphFailure }],
|
|
isError: true,
|
|
});
|
|
if (upstream.callgraphTruncatedOutput === true)
|
|
decodeIdaToolResult({
|
|
content: [{ type: "text", text: "preview" }],
|
|
_meta: { ida_mcp: { output_truncated: true } },
|
|
});
|
|
};
|
|
producer.overrideCall = (name, args): JsonValue | undefined => {
|
|
if (name === "lookup_funcs") {
|
|
const queries = args.queries;
|
|
const addresses = Array.isArray(queries) ? queries.map(String) : [];
|
|
return addresses.map((query) => {
|
|
const fn = FUNCTIONS[query];
|
|
return fn === undefined
|
|
? { query, fn: null, error: "Not found" }
|
|
: { query, fn: { ...fn, size: "0x20" }, error: null };
|
|
});
|
|
}
|
|
if (name === "callees")
|
|
return [{ callees: [...upstream.callees], more: false }];
|
|
if (name === "callgraph") {
|
|
const requested = Array.isArray(args.roots) ? args.roots : [];
|
|
const rootKnown =
|
|
JSON.stringify(requested) === JSON.stringify(["0x1000"]) ||
|
|
(requested.length === 1 &&
|
|
upstream.leafRoots?.includes(String(requested[0])) === true);
|
|
if (!rootKnown || args.max_depth !== 0)
|
|
throw new Error(
|
|
`Unexpected callgraph request: ${JSON.stringify(args)}`,
|
|
);
|
|
return String(requested[0]) === "0x1000"
|
|
? upstream.callgraph
|
|
: leafGraphRow(String(requested[0]));
|
|
}
|
|
return undefined;
|
|
};
|
|
const client = new IdaSessionClient(
|
|
{
|
|
command: "fixture",
|
|
args: [],
|
|
env: {},
|
|
mode: "headless",
|
|
protocol: "modern",
|
|
timeoutMs: 1000,
|
|
workspaceRoot: root,
|
|
},
|
|
target,
|
|
producer,
|
|
);
|
|
return { client, producer };
|
|
};
|