mirror of
https://github.com/morluto/rea.git
synced 2026-11-19 21:23:45 +00:00
* feat(ghidra)!: verify the bridge on Ghidra 12.2 Admit 12.x from minor 2 upward, with 12.2 and JDK 25 as the verified pair. The bridge now calls the four-argument storage API added in 12.2, so 12.1.x cannot compile it and is no longer accepted. BREAKING CHANGE: Ghidra 12.1.x is rejected. Use Ghidra 12.2 or another 12.x build at or above minor 2, and a JDK inside that installation's declared range (25 or newer for the verified 12.2 build). * docs(ghidra): point remaining lanes at Ghidra 12.2 The Windows, 6502, and m68k prerequisites still named 12.1.4 and JDK 21, which the verified-build check now rejects. The bridge compile lane names the 12.2 jars it actually compiles against. Co-authored-by: morluto <morluto@users.noreply.github.com> * test(ghidra): admit the JDK the verified install declares The Java home framing probe still reported JDK 21 while the verified installation fixture now declares a minimum of 25, so doctor admission failed before the path framing was checked. Co-authored-by: morluto <morluto@users.noreply.github.com> * test(ghidra): derive admitted install fixtures from the verified release Boundary hosts and assertions still named Ghidra 12.1.4 after admission moved to 12.2, so list_procedures evidence and completed property reads disagreed with the install the provider actually reported. Co-authored-by: morluto <morluto@users.noreply.github.com> * fix(ghidra): record the exact 12.2 Clang switch-recovery defect Ghidra 12.2 stays the verified build. Sessions and decompiler results on that exact version name upstream issue 9996 and the 12.2.1 fix commit. Other version strings, including 12.2.1, do not carry the limitation. Co-authored-by: morluto <morluto@users.noreply.github.com> * test(ghidra): check switch-defect facts instead of the warning sentence The policy test keeps the structured defect record and checks that the owning formatter delivers its id, commit, release, and scope fields. Co-authored-by: morluto <morluto@users.noreply.github.com> * test(browser): name the Playwright launch boundary the lifecycle catalog checks Main retitled that case with a platform placeholder. The coverage catalog still required the old literal, so the merged full suite reported a missing title. Co-authored-by: morluto <morluto@users.noreply.github.com> * test(browser): point the lifecycle catalog at main's launch title The merged suite uses main's platform-specific Playwright launch test. The coverage catalog now names that title, and this branch keeps main's test body so the merge stays clean. Co-authored-by: morluto <morluto@users.noreply.github.com> * test(browser): cover the platform launch title on this branch The lifecycle catalog names main's platform launch title. This branch now has that quoted test too, so the check passes before and after the merge. Co-authored-by: morluto <morluto@users.noreply.github.com> * fix(ghidra): record the exact 12.2 masked byte-switch defect Ghidra 12.2 leaves an AArch64 and-0xff byte-offset switch unrecovered. Exact 12.2 sessions now cite open upstream issue 10154, and the AArch64 lane expects that jump table to stay unrecovered. Co-authored-by: morluto <morluto@users.noreply.github.com> * test(browser): keep one platform launch environment check The second launch test repeated the selected environment check. The remaining test is the parameterized title, and the launcher forwards SYSTEMROOT on win32 so that assertion holds. Co-authored-by: morluto <morluto@users.noreply.github.com> * fix(ghidra): keep the open switch defect on admitted builds The exact-version check cleared ghidra-10154 on every build except 12.2. That defect stays on admitted releases until one is known to fix it. ghidra-9996 still clears after the exact 12.2 build. Co-authored-by: morluto <morluto@users.noreply.github.com> * style(docs): format the Ghidra testing-lane table The AArch64 jump-table row wrapped past the formatter width and failed static checks. Co-authored-by: morluto <morluto@users.noreply.github.com> * test(ghidra): give the masked switch its full byte range The unrecovered oracle now uses 256 readable table bytes, and the same object must still recover its compare-bounded switch. Co-authored-by: morluto <morluto@users.noreply.github.com> * docs(website): point Ghidra setup at 12.2 and JDK 25 The public setup pages still told new users to install Ghidra 12.1.4 and JDK 21, which this release rejects. Changed setup sentences are extracted and left untranslated so those editions use the English page. Co-authored-by: morluto <morluto@users.noreply.github.com> * docs(website): keep catalog edits to the changed setup strings The catalog check compares active message ids, not a full rewrite. Restore the previous catalogs and update only the Ghidra 12.2 setup strings, leaving their translations empty. Co-authored-by: morluto <morluto@users.noreply.github.com> * fix(ghidra): apply the closed switch defect from the parsed patch 12.2, 12.2.0, and 12.2.0 with a suffix all precede 12.2.1, so they keep ghidra-9996. The masked-switch table lists all 256 byte entries. Co-authored-by: morluto <morluto@users.noreply.github.com> * fix(ghidra): share the AArch64 switch fixture compiler invocation --------- Co-authored-by: Cursor Agent <cursoragent@cursor.com> Co-authored-by: morluto <morluto@users.noreply.github.com>
881 lines
30 KiB
JavaScript
881 lines
30 KiB
JavaScript
#!/usr/bin/env node
|
|
// Real Kuna provider lane. Requires a caller-supplied kuna (REA_KUNA_COMMAND)
|
|
// and a host C compiler; REA installs neither. The default run builds a
|
|
// source-owned fixture, with symbols and stripped, and verifies the public MCP
|
|
// workflow: cold single-function pseudocode, the project export, warm reuse
|
|
// from a fresh server, and cleanup. `--targets DIR --functions a,b` adds
|
|
// caller-built binaries (DIR/<flavor>/<name> plus <name>.stripped).
|
|
// `--compare-ghidra` runs the same functions through a bring-your-own Ghidra
|
|
// and reports latency, CPU, memory, output size and simple quality signals.
|
|
import assert from "node:assert/strict";
|
|
import { execFile } from "node:child_process";
|
|
import { createHash } from "node:crypto";
|
|
import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
|
|
import { join, resolve } from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
import { parseArgs, promisify } from "node:util";
|
|
import { Client } from "@modelcontextprotocol/client";
|
|
import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
|
|
import { inspectKunaInstallation } from "../dist/kuna/KunaInstallation.js";
|
|
import { HOST_PLATFORM } from "../dist/platform/HostPlatform.js";
|
|
import {
|
|
KUNA_RELEASE_VERIFICATION_EXPLANATION,
|
|
KUNA_UNVERIFIED_VERSION_REMEDIATION,
|
|
KUNA_VERIFIED_VERSION,
|
|
} from "../dist/kuna/KunaRelease.js";
|
|
import { ArtifactResourceScope } from "../dist/resources/ArtifactResourceScope.js";
|
|
import { AnalysisCleanupLease } from "../dist/resources/AnalysisCleanupLease.js";
|
|
import {
|
|
KUNA_XREF_MISSING_NAME_REMEDIATION,
|
|
missingKunaXrefNameMessage,
|
|
} from "../dist/kuna/KunaSelectorGuidance.js";
|
|
import {
|
|
requireMcpOperationResult,
|
|
requireMcpToolError,
|
|
} from "./lib/mcp-verifier-results.mjs";
|
|
import { verifyKunaReferences } from "./lib/kuna-reference-verifier.mjs";
|
|
import {
|
|
nativeKunaStrings,
|
|
verifyKunaStrings,
|
|
} from "./lib/kuna-string-verifier.mjs";
|
|
import { nativeKunaIncomingSites } from "./lib/kuna-native-reference-verifier.mjs";
|
|
import {
|
|
assertVerifierCleanupComplete,
|
|
completeVerifierRun,
|
|
createVerifierRun,
|
|
} from "./lib/verifier-run.mjs";
|
|
import { VerifierFixture } from "./lib/verifier-fixture.mjs";
|
|
|
|
const exec = promisify(execFile);
|
|
const { values } = parseArgs({
|
|
options: {
|
|
targets: { type: "string" },
|
|
functions: { type: "string" },
|
|
"compare-ghidra": { type: "boolean", default: false },
|
|
report: { type: "string" },
|
|
entrypoint: { type: "string" },
|
|
},
|
|
});
|
|
const entrypoint =
|
|
values.entrypoint === undefined
|
|
? fileURLToPath(new URL("./rea.mjs", import.meta.url))
|
|
: resolve(values.entrypoint);
|
|
const kuna = process.env.REA_KUNA_COMMAND;
|
|
assert.ok(
|
|
kuna !== undefined && kuna.startsWith("/"),
|
|
"Kuna lane prerequisite missing: REA_KUNA_COMMAND must name a caller-supplied kuna by absolute path (bring your own)",
|
|
);
|
|
if (values["compare-ghidra"]) {
|
|
// The comparison runs on caller-built targets only; the fixture has none.
|
|
assert.ok(
|
|
values.targets !== undefined && values.functions !== undefined,
|
|
"--compare-ghidra compares caller-built targets: pass --targets DIR --functions a,b as well",
|
|
);
|
|
assert.ok(
|
|
process.env.GHIDRA_INSTALL_DIR,
|
|
"Ghidra comparison prerequisite missing: GHIDRA_INSTALL_DIR (bring your own Ghidra 12.2 and JDK 25)",
|
|
);
|
|
}
|
|
const run = createVerifierRun();
|
|
const inspectionResources = new ArtifactResourceScope();
|
|
const resourceScope = {
|
|
retain: (owner, resource) =>
|
|
inspectionResources.retain({
|
|
kind: "lease",
|
|
resource,
|
|
lease: AnalysisCleanupLease.forCloseOwner(owner, resource),
|
|
}),
|
|
run: (operation) => inspectionResources.run(operation),
|
|
};
|
|
// Kuna children cache under the root; a plain root admits them on every host.
|
|
const workspaceFixture = await VerifierFixture.open({
|
|
prefix: "rea-kuna-lane-",
|
|
private: false,
|
|
});
|
|
const workspace = workspaceFixture.path;
|
|
const cacheRoot = join(workspace, "cache");
|
|
// A server retains its workspace until both provider and transport cleanup
|
|
// have positively completed, even if later lineage observation is empty.
|
|
const pendingServers = new Set();
|
|
// Unproven native-oracle stops retain their supervisors and this workspace.
|
|
const retainedNative = new Set();
|
|
let kunaVersion;
|
|
|
|
const FIXTURE_SOURCE = String.raw`
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
static const char rea_kuna_utf8[] __attribute__((used)) = "_φ( °-°)/ REA unicode marker";
|
|
/* The leading NUL unit ends any UTF-16 run that bytes before this array would
|
|
start: the UTF-8 marker's last byte and NUL decode as the unit 'r', so on
|
|
layouts where it precedes this array Kuna reports "rREA wide marker". */
|
|
static const unsigned short rea_kuna_wide[] __attribute__((used)) = {
|
|
0,'R','E','A',' ','w','i','d','e',' ','m','a','r','k','e','r',0
|
|
};
|
|
#include <string.h>
|
|
__attribute__((noinline)) unsigned rea_checksum(const unsigned char *p, size_t n) {
|
|
unsigned h = 2166136261u;
|
|
for (size_t i = 0; i < n; i++) h = (h ^ p[i]) * 16777619u;
|
|
return h;
|
|
}
|
|
__attribute__((noinline)) int rea_classify(int c) {
|
|
switch (c) {
|
|
case 'a': return 1; case 'e': return 2; case 'i': return 3;
|
|
case 'o': return 4; case 'u': return 5; default: return c > 'z' ? -1 : 0;
|
|
}
|
|
}
|
|
int main(int argc, char **argv) {
|
|
if (argc < 2) return 2;
|
|
size_t length = strlen(argv[1]);
|
|
printf("%u %u %d\n", rea_checksum((const unsigned char *)argv[1], length),
|
|
rea_checksum((const unsigned char *)argv[1], length ? length - 1 : 0),
|
|
rea_classify(argv[1][0]));
|
|
return 0;
|
|
}
|
|
`;
|
|
|
|
/** Resolve function entry addresses from a symbol-bearing build. */
|
|
const symbolAddresses = async (binary, names) => {
|
|
const { stdout } = await exec(process.env.REA_NM ?? "nm", [binary]);
|
|
const found = new Map();
|
|
for (const line of stdout.split("\n")) {
|
|
const [address, type, symbol] = line.trim().split(/\s+/u);
|
|
if (symbol === undefined || !/^[tT]$/u.test(type ?? "")) continue;
|
|
const plain = symbol.startsWith("_") ? symbol.slice(1) : symbol;
|
|
for (const name of names)
|
|
if ((symbol === name || plain === name) && !found.has(name))
|
|
found.set(name, `0x${BigInt(`0x${address}`).toString(16)}`);
|
|
}
|
|
return found;
|
|
};
|
|
|
|
/** Sum the resident memory and CPU time of a process and its descendants. */
|
|
const sampleTree = async (root) => {
|
|
const { stdout } = await exec("ps", ["-A", "-o", "pid=,ppid=,rss=,time="]);
|
|
const rows = stdout
|
|
.trim()
|
|
.split("\n")
|
|
.map((line) => line.trim().split(/\s+/u))
|
|
.map(([pid, ppid, rss, time]) => ({
|
|
pid: Number(pid),
|
|
ppid: Number(ppid),
|
|
rssKiB: Number(rss),
|
|
cpuSeconds: (time ?? "0:0")
|
|
.split(/[:-]/u)
|
|
.map(Number)
|
|
.reduce((total, part) => total * 60 + part, 0),
|
|
}));
|
|
const members = new Set([root]);
|
|
for (let grew = true; grew;) {
|
|
grew = false;
|
|
for (const row of rows)
|
|
if (!members.has(row.pid) && members.has(row.ppid)) {
|
|
members.add(row.pid);
|
|
grew = true;
|
|
}
|
|
}
|
|
const tree = rows.filter(({ pid }) => members.has(pid));
|
|
return {
|
|
rssKiB: tree.reduce((total, row) => total + row.rssKiB, 0),
|
|
cpu: new Map(tree.map((row) => [row.pid, row.cpuSeconds])),
|
|
};
|
|
};
|
|
|
|
/** One MCP server with a selected provider, sampled while it runs. */
|
|
const openServer = async (provider, kunaSettings = {}) => {
|
|
const owner = Symbol(provider.id);
|
|
pendingServers.add(owner);
|
|
const transport = new StdioClientTransport({
|
|
command: process.execPath,
|
|
args: [entrypoint, "--mcp"],
|
|
env: {
|
|
PATH: process.env.PATH ?? "/usr/bin:/bin",
|
|
HOME: process.env.HOME ?? workspace,
|
|
REA_LOG_LEVEL: "silent",
|
|
REA_PROCESS_RUN_ID: run.run_id,
|
|
REA_KUNA_COMMAND: kuna,
|
|
REA_KUNA_CACHE_DIR: cacheRoot,
|
|
...kunaSettings,
|
|
...(process.env.GHIDRA_INSTALL_DIR === undefined
|
|
? {}
|
|
: { GHIDRA_INSTALL_DIR: process.env.GHIDRA_INSTALL_DIR }),
|
|
...(process.env.JAVA_HOME === undefined
|
|
? {}
|
|
: { JAVA_HOME: process.env.JAVA_HOME }),
|
|
},
|
|
stderr: "ignore",
|
|
});
|
|
const client = new Client({ name: "rea-real-kuna", version: "1" });
|
|
let peakKiB = 0;
|
|
const cpu = new Map();
|
|
const sampleOnce = async () => {
|
|
const pid = transport.pid;
|
|
if (pid === null) return;
|
|
const observed = await sampleTree(pid).catch(() => undefined);
|
|
if (observed === undefined) return;
|
|
peakKiB = Math.max(peakKiB, observed.rssKiB);
|
|
for (const [member, seconds] of observed.cpu)
|
|
cpu.set(member, Math.max(cpu.get(member) ?? 0, seconds));
|
|
};
|
|
let sampling;
|
|
const sample = () => {
|
|
sampling ??= sampleOnce().finally(() => {
|
|
sampling = undefined;
|
|
});
|
|
return sampling;
|
|
};
|
|
let timer;
|
|
const call = async (name, arguments_ = {}) => {
|
|
const started = performance.now();
|
|
const result = await client.callTool(
|
|
{ name, arguments: arguments_ },
|
|
{ timeout: 3_600_000 },
|
|
);
|
|
const ms = Math.round(performance.now() - started);
|
|
const bytes = Buffer.byteLength(JSON.stringify(result));
|
|
return {
|
|
ms,
|
|
bytes,
|
|
value: requireMcpOperationResult(result, name),
|
|
structured: result.structuredContent,
|
|
};
|
|
};
|
|
const callError = async (name, arguments_ = {}) =>
|
|
requireMcpToolError(
|
|
await client.callTool(
|
|
{ name, arguments: arguments_ },
|
|
{ timeout: 3_600_000 },
|
|
),
|
|
);
|
|
const close = async (priorFailure) => {
|
|
clearInterval(timer);
|
|
await sample();
|
|
const failures = priorFailure === undefined ? [] : [priorFailure];
|
|
// Attempt each cleanup independently. Disposing a transport is not proof
|
|
// that close_binary released retained provider processes or files.
|
|
for (const cleanup of [
|
|
() => call("close_binary"),
|
|
() => client.close(),
|
|
() => transport.close(),
|
|
])
|
|
try {
|
|
await cleanup();
|
|
} catch (cause) {
|
|
failures.push(cause);
|
|
}
|
|
// A prior verification error must survive successful cleanup. Only the
|
|
// cleanup failures retain this server's files.
|
|
if (failures.length > (priorFailure === undefined ? 0 : 1))
|
|
throw new AggregateError(
|
|
failures,
|
|
"MCP server cleanup was not confirmed",
|
|
);
|
|
pendingServers.delete(owner);
|
|
if (priorFailure !== undefined) throw priorFailure;
|
|
return {
|
|
peak_rss_mib: Math.round(peakKiB / 1024),
|
|
cpu_seconds: [...cpu.values()].reduce((total, value) => total + value, 0),
|
|
};
|
|
};
|
|
try {
|
|
await client.connect(transport);
|
|
timer = setInterval(() => void sample(), 200);
|
|
await call("open_binary", {
|
|
path: provider.path,
|
|
provider_id: provider.id,
|
|
});
|
|
const session = (await call("binary_session")).value;
|
|
assert.equal(
|
|
session.analysis_provider_candidates_observed,
|
|
"target_selection",
|
|
);
|
|
if (provider.id === "kuna") {
|
|
const binding = session.analysis_provider_binding;
|
|
const verification = binding.release_verification;
|
|
assert.equal(verification.basis, "reported_version");
|
|
assert.equal(verification.verified_version, KUNA_VERIFIED_VERSION);
|
|
assert.equal(
|
|
verification.reported_version,
|
|
binding.analysis_profile.parameters.kuna_version,
|
|
);
|
|
assert.equal(
|
|
verification.status,
|
|
binding.analysis_profile.parameters.kuna_version ===
|
|
KUNA_VERIFIED_VERSION
|
|
? "verified"
|
|
: "unverified",
|
|
);
|
|
assert.equal(
|
|
verification.explanation,
|
|
KUNA_RELEASE_VERIFICATION_EXPLANATION,
|
|
);
|
|
if (verification.status === "unverified")
|
|
assert.equal(
|
|
verification.remediation,
|
|
KUNA_UNVERIFIED_VERSION_REMEDIATION,
|
|
);
|
|
else assert.equal(verification.remediation, null);
|
|
}
|
|
} catch (cause) {
|
|
// A rejected connection/target still owns its transport and workspace.
|
|
await close(cause);
|
|
}
|
|
return { call, callError, close };
|
|
};
|
|
|
|
/** Verify a forced inventory timeout can be retried without changing jobs. */
|
|
const verifyProjectTimeoutRecovery = async (path, address) => {
|
|
const before = createHash("sha256")
|
|
.update(await readFile(path))
|
|
.digest("hex");
|
|
const settings = {
|
|
REA_KUNA_JOBS: "2",
|
|
REA_KUNA_TIMEOUT_MS: "60000",
|
|
REA_KUNA_PROJECT_TIMEOUT_MS: "1",
|
|
};
|
|
const timed = await openServer({ path, id: "kuna" }, settings);
|
|
let timedFailure;
|
|
try {
|
|
const failure = await timed.callError("procedure_assembly", {
|
|
procedure: address,
|
|
});
|
|
assert.equal(failure.code, "capability_unavailable");
|
|
assert.match(failure.message, /kuna functions/u);
|
|
assert.match(failure.remediation.action, /REA_KUNA_PROJECT_TIMEOUT_MS/u);
|
|
assert.doesNotMatch(failure.remediation.action, /REA_KUNA_JOBS/u);
|
|
} catch (cause) {
|
|
timedFailure = cause;
|
|
} finally {
|
|
await timed.close(timedFailure);
|
|
}
|
|
const retry = await openServer(
|
|
{ path, id: "kuna" },
|
|
{ ...settings, REA_KUNA_PROJECT_TIMEOUT_MS: "60000" },
|
|
);
|
|
let retryFailure;
|
|
try {
|
|
const assembly = await retry.call("procedure_assembly", {
|
|
procedure: address,
|
|
});
|
|
assert.equal(typeof assembly.value, "string");
|
|
assert.ok(assembly.value.length > 0);
|
|
assert.equal(assembly.structured.analysis_profile.parameters.jobs, 2);
|
|
} catch (cause) {
|
|
retryFailure = cause;
|
|
} finally {
|
|
await retry.close(retryFailure);
|
|
}
|
|
assert.equal(
|
|
createHash("sha256")
|
|
.update(await readFile(path))
|
|
.digest("hex"),
|
|
before,
|
|
"Kuna timeout recovery changed the target",
|
|
);
|
|
return { forced_deadline_ms: 1, retry_deadline_ms: 60000, jobs: 2 };
|
|
};
|
|
|
|
/** Count structuring and diagnostic markers in provider pseudocode. */
|
|
const quality = (text) => ({
|
|
bytes: text === null ? 0 : Buffer.byteLength(text),
|
|
gotos: text === null ? 0 : (text.match(/\bgoto\b/gu) ?? []).length,
|
|
warnings:
|
|
text === null ? 0 : (text.match(/WARNING|\/\/ warn:/gu) ?? []).length,
|
|
});
|
|
|
|
/** Verify Kuna on one binary and measure its cold and warm answers. */
|
|
const verifyKuna = async (
|
|
path,
|
|
functions,
|
|
{
|
|
expectedCaller,
|
|
expectedStrings = [],
|
|
verifyNamedTrace = false,
|
|
minimumTraceReferences = {},
|
|
} = {},
|
|
) => {
|
|
const sha256 = createHash("sha256")
|
|
.update(await readFile(path))
|
|
.digest("hex");
|
|
const cold = await openServer({ path, id: "kuna" });
|
|
const answers = [];
|
|
let coldFailure;
|
|
try {
|
|
const status = await cold.call("binary_session", { detail: "complete" });
|
|
if (status.value.format === "elf") {
|
|
const availability = status.value.tool_availability;
|
|
const dispatch = availability.find(
|
|
({ name }) => name === "inspect_native_dispatch_metadata",
|
|
);
|
|
const trace = availability.find(
|
|
({ name }) => name === "trace_native_ui_action",
|
|
);
|
|
assert.equal(dispatch?.available, false);
|
|
assert.equal(
|
|
trace?.modes?.find(({ name }) => name === "native_seed_call_trace")
|
|
?.available,
|
|
false,
|
|
);
|
|
if (process.platform === "darwin") {
|
|
const { MULTI_MODE_REMEDIATION } =
|
|
await import("../dist/application/CapabilityInventory.js");
|
|
const authored = trace?.modes?.find(
|
|
({ name }) => name === "authored_ui_dispatch",
|
|
);
|
|
const nativeSeed = trace?.modes?.find(
|
|
({ name }) => name === "native_seed_call_trace",
|
|
);
|
|
assert.equal(trace?.remediation, MULTI_MODE_REMEDIATION);
|
|
assert.notEqual(authored?.remediation, nativeSeed?.remediation);
|
|
assert.ok(
|
|
authored?.missing_operations.includes("decode_interface_builder"),
|
|
);
|
|
assert.ok(nativeSeed?.missing_operations.includes("list_names"));
|
|
}
|
|
}
|
|
answers.push({
|
|
strings: await verifyKunaStrings({
|
|
call: cold.call,
|
|
cacheRoot,
|
|
expectedStrings,
|
|
nativeStrings: () =>
|
|
nativeKunaStrings({
|
|
executable: kuna,
|
|
cacheRoot,
|
|
workspace,
|
|
binary: path,
|
|
retain: (owner) => retainedNative.add(owner),
|
|
resourceScope,
|
|
}),
|
|
}),
|
|
});
|
|
const listed = await cold.call("list_procedures");
|
|
if (verifyNamedTrace) {
|
|
const missing = await cold.callError("xrefs", {
|
|
address: "rea_missing_xref_inventory_name",
|
|
});
|
|
assert.equal(missing.code, "invalid_request");
|
|
assert.equal(
|
|
missing.message,
|
|
missingKunaXrefNameMessage("rea_missing_xref_inventory_name"),
|
|
);
|
|
assert.equal(
|
|
missing.remediation.action,
|
|
KUNA_XREF_MISSING_NAME_REMEDIATION,
|
|
);
|
|
assert.ok(missing.message.includes("rea_missing_xref_inventory_name"));
|
|
assert.equal(missing.recovery, undefined);
|
|
const procedure = await cold.callError("procedure_address", {
|
|
procedure: "rea_missing_procedure_name",
|
|
});
|
|
assert.equal(procedure.code, "invalid_request");
|
|
assert.equal(procedure.recovery, undefined);
|
|
assert.match(procedure.remediation.action, /search_procedures/u);
|
|
assert.ok(
|
|
procedure.details.issues.some(
|
|
(issue) => issue.observed?.procedure === "rea_missing_procedure_name",
|
|
),
|
|
);
|
|
const missingAddress = await cold.callError("procedure_address", {
|
|
procedure: "0x00000001",
|
|
});
|
|
assert.equal(missingAddress.code, "invalid_request");
|
|
assert.equal(missingAddress.recovery, undefined);
|
|
assert.match(missingAddress.remediation.action, /list_procedures/u);
|
|
assert.ok(
|
|
missingAddress.details.issues.some(
|
|
(issue) => issue.observed?.procedure === "0x00000001",
|
|
),
|
|
);
|
|
}
|
|
for (const [name, address] of functions) {
|
|
assert.ok(
|
|
listed.value.some((entry) => entry.address === address),
|
|
`${name} at ${address} is missing from Kuna's procedure list for ${path}`,
|
|
);
|
|
const references = await verifyKunaReferences({
|
|
call: cold.call,
|
|
cacheRoot,
|
|
name,
|
|
address,
|
|
expectedCaller,
|
|
verifyNamedTrace,
|
|
minimumTraceReferences: minimumTraceReferences[name],
|
|
nativeIncoming: (targetAddress) =>
|
|
nativeKunaIncomingSites({
|
|
executable: kuna,
|
|
cacheRoot,
|
|
workspace,
|
|
binary: path,
|
|
address: targetAddress,
|
|
retain: (outcome) => retainedNative.add(outcome),
|
|
resourceScope,
|
|
}),
|
|
});
|
|
const pseudocode = await cold.call("procedure_pseudo_code", {
|
|
procedure: address,
|
|
});
|
|
assert.equal(pseudocode.structured.subject.identity.sha256, sha256);
|
|
assert.equal(pseudocode.structured.provider.id, "kuna");
|
|
const source = pseudocode.structured.raw_result?.source?.kind;
|
|
// A fast export can finish before the first request reaches the
|
|
// decompile path; both sources are valid answers. The single-function
|
|
// fallback itself is covered by the provider's boundary tests.
|
|
assert.ok(
|
|
source === "single-function" || source === "project-export",
|
|
`Unexpected pseudocode source ${String(source)}`,
|
|
);
|
|
const assembly = await cold.call("procedure_assembly", {
|
|
procedure: address,
|
|
});
|
|
assert.equal(
|
|
assembly.structured.raw_result.source.kind,
|
|
"project-export",
|
|
);
|
|
assert.match(assembly.value, new RegExp(`: ; ${address}\\n`, "u"));
|
|
const exported = await cold.call("procedure_pseudo_code", {
|
|
procedure: address,
|
|
});
|
|
const recorded = exported.structured.raw_result.source;
|
|
assert.equal(recorded.kind, "project-export");
|
|
const block = (await readFile(join(recorded.directory, recorded.file)))
|
|
.subarray(
|
|
recorded.byte_offset,
|
|
recorded.byte_offset + recorded.byte_length,
|
|
)
|
|
.toString("utf8");
|
|
assert.ok(
|
|
exported.value === null || block.includes(exported.value),
|
|
"Served pseudocode differs from the recorded export span",
|
|
);
|
|
const dossier = await cold.call("analyze_function", {
|
|
procedure: address,
|
|
detail: "complete",
|
|
});
|
|
assert.deepEqual(
|
|
dossier.structured.relationship_coverage,
|
|
references.relationship_coverage,
|
|
"Function dossier lost the directional call coverage",
|
|
);
|
|
const combined = dossier.structured.raw_result.source;
|
|
assert.equal(combined.kind, "project-export");
|
|
assert.deepEqual(
|
|
combined.files.map(({ facet }) => facet),
|
|
["pseudocode", "assembly"],
|
|
);
|
|
for (const file of combined.files) {
|
|
const bytes = await readFile(join(combined.directory, file.file));
|
|
assert.equal(
|
|
createHash("sha256").update(bytes).digest("hex"),
|
|
file.file_sha256,
|
|
);
|
|
const span = bytes
|
|
.subarray(file.byte_offset, file.byte_offset + file.byte_length)
|
|
.toString("utf8");
|
|
const facet = dossier.value[file.facet];
|
|
assert.ok(
|
|
span.includes(Array.isArray(facet) ? facet.join("\n") : facet),
|
|
);
|
|
}
|
|
answers.push({
|
|
name,
|
|
address,
|
|
cold_source: source,
|
|
cold_ms: pseudocode.ms,
|
|
export_wait_ms: assembly.ms,
|
|
warm_same_session_ms: exported.ms,
|
|
response_bytes: exported.bytes,
|
|
dossier_response_bytes: dossier.bytes,
|
|
...quality(exported.value),
|
|
references,
|
|
});
|
|
}
|
|
if (functions.length > 0) {
|
|
const trace = await cold.call("trace_native_values", {
|
|
procedure: functions[0][1],
|
|
max_depth: 0,
|
|
max_functions: 1,
|
|
});
|
|
const bundle = await cold.call("get_evidence_bundle", {
|
|
detail: "complete",
|
|
});
|
|
for (const source of [
|
|
...trace.value.procedures,
|
|
...trace.value.nodes,
|
|
...trace.value.edges,
|
|
]) {
|
|
assert.ok(trace.structured.evidence_links.includes(source.evidence_id));
|
|
assert.equal(
|
|
bundle.value.records.find(
|
|
(record) => record.evidence_id === source.evidence_id,
|
|
)?.operation,
|
|
"analyze_function",
|
|
`Missing source Evidence ${source.evidence_id}`,
|
|
);
|
|
}
|
|
}
|
|
} catch (cause) {
|
|
coldFailure = cause;
|
|
} finally {
|
|
answers.push({ cold_server: await cold.close(coldFailure) });
|
|
}
|
|
const staging = await readdir(join(cacheRoot, "staging"));
|
|
assert.deepEqual(staging, [], "Kuna staging survived a completed export");
|
|
// A fresh server reuses the export immediately.
|
|
const warm = await openServer({ path, id: "kuna" });
|
|
let warmFailure;
|
|
try {
|
|
for (const answer of answers)
|
|
if (answer.address !== undefined) {
|
|
const reread = await warm.call("procedure_pseudo_code", {
|
|
procedure: answer.address,
|
|
});
|
|
assert.equal(
|
|
reread.structured.raw_result.source.kind,
|
|
"project-export",
|
|
);
|
|
answer.warm_fresh_server_ms = reread.ms;
|
|
}
|
|
} catch (cause) {
|
|
warmFailure = cause;
|
|
} finally {
|
|
answers.push({ warm_server: await warm.close(warmFailure) });
|
|
}
|
|
return answers;
|
|
};
|
|
|
|
/** Measure Ghidra on the same functions through the same public workflow. */
|
|
const measureGhidra = async (path, functions) => {
|
|
const server = await openServer({ path, id: "ghidra" });
|
|
const answers = [];
|
|
let failure;
|
|
try {
|
|
for (const [name, address] of functions) {
|
|
const cold = await server.call("procedure_pseudo_code", {
|
|
procedure: address,
|
|
});
|
|
const warm = await server.call("procedure_pseudo_code", {
|
|
procedure: address,
|
|
});
|
|
answers.push({
|
|
name,
|
|
address,
|
|
first_call_ms: cold.ms,
|
|
repeat_ms: warm.ms,
|
|
response_bytes: cold.bytes,
|
|
...quality(cold.value),
|
|
});
|
|
}
|
|
} catch (cause) {
|
|
failure = cause;
|
|
} finally {
|
|
answers.push({ server: await server.close(failure) });
|
|
}
|
|
return answers;
|
|
};
|
|
|
|
const describeFailure = (cause) => ({
|
|
message: cause instanceof Error ? cause.message : String(cause),
|
|
...(cause instanceof AggregateError
|
|
? { causes: cause.errors.map(describeFailure) }
|
|
: {}),
|
|
});
|
|
|
|
/** Inspect symbol-bearing caller binaries, retaining both selected and unmatched inputs. */
|
|
const targetPairs = async (root, names, selection) => {
|
|
const pairs = [];
|
|
for (const flavor of (await readdir(root)).sort()) {
|
|
const directory = join(root, flavor);
|
|
if (!(await stat(directory)).isDirectory()) continue;
|
|
for (const file of (await readdir(directory)).sort()) {
|
|
if (file.endsWith(".stripped")) continue;
|
|
let symbols;
|
|
try {
|
|
symbols = await symbolAddresses(join(directory, file), names);
|
|
} catch (cause) {
|
|
selection.examined.push({
|
|
binary: `${flavor}/${file}`,
|
|
status: "inspection_failed",
|
|
error: describeFailure(cause),
|
|
});
|
|
throw cause;
|
|
}
|
|
selection.examined.push({
|
|
binary: `${flavor}/${file}`,
|
|
status: symbols.size > 0 ? "selected" : "no_matching_text_symbols",
|
|
matched_functions: [...symbols.keys()],
|
|
});
|
|
if (symbols.size > 0) pairs.push({ flavor, directory, file, symbols });
|
|
}
|
|
}
|
|
return pairs;
|
|
};
|
|
|
|
/** Verify Kuna, and optionally measure Ghidra, on one binary of a pair. */
|
|
const verifyVariant = async ({ flavor, directory, symbols }, variant) => {
|
|
const path = join(directory, variant);
|
|
const entry = { binary: `${flavor}/${variant}` };
|
|
entry.kuna = await verifyKuna(path, [...symbols]);
|
|
if (values["compare-ghidra"])
|
|
entry.ghidra = await measureGhidra(path, [...symbols]);
|
|
process.stderr.write(`verified ${entry.binary}\n`);
|
|
return entry;
|
|
};
|
|
|
|
const results = [];
|
|
let timeoutRecovery;
|
|
const failures = [];
|
|
const callerTargetSelection =
|
|
values.targets === undefined
|
|
? undefined
|
|
: {
|
|
directory: values.targets,
|
|
functions_argument: values.functions ?? null,
|
|
requested_functions: (values.functions ?? "")
|
|
.split(",")
|
|
.filter(Boolean),
|
|
symbol_scan_complete: false,
|
|
examined: [],
|
|
};
|
|
let inspectionResourcesClean = true;
|
|
try {
|
|
const installation = await inspectKunaInstallation(
|
|
{ REA_KUNA_COMMAND: kuna, REA_KUNA_CACHE_DIR: cacheRoot },
|
|
{ platform: HOST_PLATFORM.platform, resourceScope },
|
|
);
|
|
assert.ok(
|
|
installation.ok,
|
|
installation.ok ? undefined : installation.error.reason,
|
|
);
|
|
kunaVersion = `kuna ${installation.value.version}`;
|
|
let callerPairs = [];
|
|
if (callerTargetSelection !== undefined) {
|
|
const names = callerTargetSelection.requested_functions;
|
|
assert.ok(names.length > 0, "--targets requires --functions");
|
|
callerPairs = await targetPairs(
|
|
callerTargetSelection.directory,
|
|
names,
|
|
callerTargetSelection,
|
|
);
|
|
callerTargetSelection.symbol_scan_complete = true;
|
|
assert.ok(
|
|
callerPairs.length > 0,
|
|
`No caller-built targets contain the requested functions in ${callerTargetSelection.directory}`,
|
|
);
|
|
const found = new Set(
|
|
callerPairs.flatMap(({ symbols }) => [...symbols.keys()]),
|
|
);
|
|
const missing = names.filter((name) => !found.has(name));
|
|
assert.deepEqual(
|
|
missing,
|
|
[],
|
|
"Requested functions were not found in any caller-built target",
|
|
);
|
|
}
|
|
|
|
// Source-owned fixture: always built and verified.
|
|
const fixtureDir = join(workspace, "fixture");
|
|
await mkdir(fixtureDir);
|
|
const source = join(fixtureDir, "fixture.c");
|
|
await writeFile(source, FIXTURE_SOURCE);
|
|
const built = join(fixtureDir, "rea-kuna-fixture");
|
|
await exec(process.env.REA_CC ?? "cc", ["-O2", "-o", built, source]);
|
|
const stripped = `${built}.stripped`;
|
|
await writeFile(stripped, await readFile(built));
|
|
await exec(process.env.REA_STRIP ?? "strip", [stripped]);
|
|
const fixtureFunctions = await symbolAddresses(built, [
|
|
"rea_checksum",
|
|
"rea_classify",
|
|
"main",
|
|
]);
|
|
assert.equal(fixtureFunctions.size, 3, "Fixture symbols were not found");
|
|
const fixtureMain = fixtureFunctions.get("main");
|
|
fixtureFunctions.delete("main");
|
|
for (const binary of [built, stripped])
|
|
results.push({
|
|
binary: binary.slice(workspace.length + 1),
|
|
kuna: await verifyKuna(binary, [...fixtureFunctions], {
|
|
expectedCaller: fixtureMain,
|
|
expectedStrings: ["_φ( °-°)/ REA unicode marker", "REA wide marker"],
|
|
verifyNamedTrace: binary === built,
|
|
minimumTraceReferences: { rea_checksum: 2 },
|
|
}),
|
|
});
|
|
|
|
timeoutRecovery = await verifyProjectTimeoutRecovery(
|
|
built,
|
|
fixtureFunctions.get("rea_checksum"),
|
|
);
|
|
|
|
// Caller-built matrix.
|
|
for (const pair of callerPairs)
|
|
for (const variant of [pair.file, `${pair.file}.stripped`])
|
|
results.push(await verifyVariant(pair, variant));
|
|
} catch (cause) {
|
|
failures.push(cause);
|
|
}
|
|
// Failure paths need the same process evidence as successful verification.
|
|
for (const retained of [...retainedNative]) {
|
|
try {
|
|
const stopped = await retained.owner?.stop();
|
|
if (stopped !== undefined && stopped.status !== "incomplete")
|
|
retainedNative.delete(retained);
|
|
} catch (cause) {
|
|
failures.push(cause);
|
|
}
|
|
}
|
|
try {
|
|
await inspectionResources.close();
|
|
} catch (cause) {
|
|
inspectionResourcesClean = false;
|
|
failures.push(cause);
|
|
}
|
|
const lifecycle = await completeVerifierRun(run);
|
|
let cleanupComplete =
|
|
pendingServers.size === 0 &&
|
|
retainedNative.size === 0 &&
|
|
inspectionResourcesClean;
|
|
try {
|
|
assertVerifierCleanupComplete(lifecycle.process_lineage);
|
|
} catch (cause) {
|
|
cleanupComplete = false;
|
|
failures.push(cause);
|
|
}
|
|
if (cleanupComplete)
|
|
try {
|
|
await workspaceFixture.release();
|
|
} catch (cause) {
|
|
cleanupComplete = false;
|
|
failures.push(cause);
|
|
}
|
|
const report = {
|
|
lane: "kuna",
|
|
status: failures.length === 0 ? "passed" : "failed",
|
|
kuna_version: kunaVersion,
|
|
platform: `${process.platform}/${process.arch}`,
|
|
verifier_run: lifecycle,
|
|
...(callerTargetSelection === undefined
|
|
? {}
|
|
: { caller_target_selection: callerTargetSelection }),
|
|
results,
|
|
...(timeoutRecovery === undefined
|
|
? {}
|
|
: { timeout_recovery: timeoutRecovery }),
|
|
limitations: [
|
|
"Targets are analyzed statically; they are never executed.",
|
|
"Memory is the sampled peak resident set of the MCP server process tree; CPU is its sampled cumulative time. A short-lived peak between 200 ms samples is not observed.",
|
|
"Quality signals count gotos and warning markers only; they are not a correctness judgement and not a DecBench reproduction.",
|
|
"Response bytes are UTF-8 serialization sizes. Model token usage, tool schema costs and agent task completion were not measured.",
|
|
],
|
|
cleanup: cleanupComplete ? "complete" : "incomplete",
|
|
...(cleanupComplete ? {} : { retained_workspace: workspace }),
|
|
...(failures.length === 0 ? {} : { failures: failures.map(describeFailure) }),
|
|
};
|
|
if (values.report !== undefined)
|
|
await writeFile(values.report, `${JSON.stringify(report, null, 2)}\n`);
|
|
process.stdout.write(`${JSON.stringify(report)}\n`);
|
|
if (failures.length > 0)
|
|
throw new AggregateError(
|
|
failures,
|
|
"Kuna verification failed; see the report for cleanup evidence",
|
|
);
|