chore: reconcile iNES inventory with current main
This commit is contained in:
@@ -24,7 +24,7 @@ export const bundleRuntime = async (root) => {
|
||||
{
|
||||
cli: "cli.js",
|
||||
cliOutput: "cliOutput.js",
|
||||
streamedJsonOutput: "cli/streamedJsonOutput.js",
|
||||
cliResultOutput: "cli/cliResultOutput.js",
|
||||
mcpDoctor: "mcpDoctor.js",
|
||||
},
|
||||
],
|
||||
|
||||
@@ -24,6 +24,7 @@ const NATIVE_TEST_OWNERS = ["apple", "package"];
|
||||
const GUARDED_WORKFLOWS = new Set([
|
||||
".github/workflows/release.yml",
|
||||
".github/workflows/real-ghidra-windows.yml",
|
||||
".github/workflows/sqlite-runtime.yml",
|
||||
]);
|
||||
// Sources compiled by build-conformance-fixtures.mjs. The readiness journey
|
||||
// analyzes the built C fixture as well as its own applications.
|
||||
|
||||
@@ -2,7 +2,7 @@ const jobs = JSON.parse(process.env.CI_JOBS);
|
||||
const outputs = jobs.changes.outputs;
|
||||
const required = ["changes", "static", "test"];
|
||||
const lanes = {
|
||||
code: ["build", "test-shard"],
|
||||
code: ["build", "test-shard", "sqlite-runtime"],
|
||||
runtime: ["windows-native-build", "package-e2e"],
|
||||
package: ["windows-curated"],
|
||||
apple: ["apple-artifacts"],
|
||||
|
||||
@@ -64,6 +64,7 @@ export const SCOPES = {
|
||||
"tests/boundary/filesystem/javascript-applications/javascriptArtifactReconstruction.test.ts",
|
||||
"tests/conformance/providers/ghidra/windowsCapabilities.test.ts",
|
||||
"src/ghidra/GhidraInstallation.test.ts",
|
||||
"tests/boundary/filesystem/ghidraJavaProbe.test.ts",
|
||||
"tests/boundary/providers/ghidra/ghidraTransport.test.ts",
|
||||
"tests/boundary/providers/ghidra/ghidraTargetSnapshot.test.ts",
|
||||
"tests/boundary/providers/ghidra/ghidraLauncher.test.ts",
|
||||
|
||||
@@ -0,0 +1,149 @@
|
||||
import { spawnSync } from "node:child_process";
|
||||
import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
|
||||
import { createRequire } from "node:module";
|
||||
import { dirname, join, relative, sep } from "node:path";
|
||||
import { z } from "zod";
|
||||
|
||||
const require = createRequire(import.meta.url);
|
||||
const mode = process.argv[2];
|
||||
const reportRoot = join(".cache", "static-checks");
|
||||
const extraArguments = process.argv.slice(3);
|
||||
const lintReport = z.object({
|
||||
number_of_files: z.number(),
|
||||
diagnostics: z.array(
|
||||
z.object({
|
||||
message: z.string(),
|
||||
code: z.string().optional(),
|
||||
severity: z.enum(["error", "warning", "advice"]),
|
||||
filename: z.string(),
|
||||
labels: z.array(
|
||||
z.object({
|
||||
span: z.object({ line: z.number(), column: z.number() }),
|
||||
}),
|
||||
),
|
||||
}),
|
||||
),
|
||||
});
|
||||
const duplicateReport = z
|
||||
.object({
|
||||
duplicates: z.array(
|
||||
z
|
||||
.object({
|
||||
firstFile: z.object({ name: z.string() }).passthrough(),
|
||||
secondFile: z.object({ name: z.string() }).passthrough(),
|
||||
})
|
||||
.passthrough(),
|
||||
),
|
||||
statistics: z
|
||||
.object({
|
||||
total: z
|
||||
.object({
|
||||
sources: z.number(),
|
||||
clones: z.number(),
|
||||
percentage: z.number(),
|
||||
})
|
||||
.passthrough(),
|
||||
})
|
||||
.passthrough(),
|
||||
})
|
||||
.passthrough();
|
||||
|
||||
const run = (packageName, entrypoint, arguments_) => {
|
||||
const executable = join(
|
||||
dirname(require.resolve(`${packageName}/package.json`)),
|
||||
entrypoint,
|
||||
);
|
||||
const result = spawnSync(process.execPath, [executable, ...arguments_], {
|
||||
encoding: "utf8",
|
||||
maxBuffer: 32 * 1024 * 1024,
|
||||
});
|
||||
if (result.stderr) process.stderr.write(result.stderr);
|
||||
if (result.error !== undefined) throw result.error;
|
||||
if (result.status === null)
|
||||
throw new Error(`${packageName} terminated by ${result.signal}`);
|
||||
return result;
|
||||
};
|
||||
|
||||
try {
|
||||
await mkdir(reportRoot, { recursive: true });
|
||||
if (mode === "lint") {
|
||||
const reportPath = join(reportRoot, "oxlint.json");
|
||||
await rm(reportPath, { force: true });
|
||||
const result = run("oxlint", "bin/oxlint", [
|
||||
...extraArguments,
|
||||
"--format",
|
||||
"json",
|
||||
]);
|
||||
let report;
|
||||
try {
|
||||
report = lintReport.parse(JSON.parse(result.stdout));
|
||||
} catch (cause) {
|
||||
process.stderr.write(result.stdout);
|
||||
throw cause;
|
||||
}
|
||||
await writeFile(reportPath, result.stdout);
|
||||
const warnings = report.diagnostics.filter(
|
||||
({ severity }) => severity === "warning",
|
||||
);
|
||||
const errors = report.diagnostics.filter(
|
||||
({ severity }) => severity === "error",
|
||||
);
|
||||
console.log(
|
||||
`Lint: ${report.number_of_files} files, ${errors.length} errors, ${warnings.length} warnings.`,
|
||||
);
|
||||
for (const diagnostic of errors) {
|
||||
const location = diagnostic.labels[0]?.span;
|
||||
console.error(
|
||||
`${diagnostic.filename}:${location?.line ?? 1}:${location?.column ?? 1}: ${diagnostic.code ?? "lint"}: ${diagnostic.message}`,
|
||||
);
|
||||
}
|
||||
const counts = new Map();
|
||||
for (const { code } of warnings)
|
||||
counts.set(code ?? "warning", (counts.get(code ?? "warning") ?? 0) + 1);
|
||||
for (const [rule, count] of [...counts]
|
||||
.sort(
|
||||
(left, right) => right[1] - left[1] || left[0].localeCompare(right[0]),
|
||||
)
|
||||
.slice(0, 8))
|
||||
console.log(` ${rule}: ${count} warnings`);
|
||||
console.log(`Full diagnostics: ${reportPath}; npm run lint:details`);
|
||||
process.exitCode = result.status;
|
||||
} else if (mode === "duplicates") {
|
||||
const output = join(reportRoot, "jscpd");
|
||||
const reportPath = join(output, "jscpd-report.json");
|
||||
await rm(reportPath, { force: true });
|
||||
const result = run("jscpd", "run-jscpd.js", [
|
||||
"src/",
|
||||
"tests/",
|
||||
...extraArguments,
|
||||
"--reporters",
|
||||
"json",
|
||||
"--output",
|
||||
output,
|
||||
"--no-colors",
|
||||
"--no-tips",
|
||||
"--absolute",
|
||||
]);
|
||||
if (result.stdout) process.stdout.write(result.stdout);
|
||||
const report = duplicateReport.parse(
|
||||
JSON.parse(await readFile(reportPath, "utf8")),
|
||||
);
|
||||
// jscpd otherwise strips each scan root, making src/ and tests/ names
|
||||
// ambiguous. Normalize absolute producer paths once for portable reports.
|
||||
for (const clone of report.duplicates)
|
||||
for (const file of [clone.firstFile, clone.secondFile])
|
||||
file.name = relative(process.cwd(), file.name).split(sep).join("/");
|
||||
await writeFile(reportPath, JSON.stringify(report, null, 2));
|
||||
const { sources, clones, percentage } = report.statistics.total;
|
||||
console.log(
|
||||
`Duplication: ${sources} files, ${clones} clones, ${percentage.toFixed(2)}% duplicated lines.`,
|
||||
);
|
||||
console.log(`Full diagnostics: ${reportPath}; npm run jscpd:details`);
|
||||
process.exitCode = result.status;
|
||||
} else {
|
||||
throw new Error("Expected lint or duplicates");
|
||||
}
|
||||
} catch (cause) {
|
||||
console.error(cause instanceof Error ? cause.message : String(cause));
|
||||
process.exitCode = 1;
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
import { appendFile, mkdir, readFile, rm, writeFile } from "node:fs/promises";
|
||||
import { isAbsolute, join, relative, resolve, sep } from "node:path";
|
||||
|
||||
import { z } from "zod";
|
||||
|
||||
const root = process.cwd();
|
||||
const historyDirectory = join(root, ".cache/ci-test-history");
|
||||
const historyPath = join(historyDirectory, "test-results.json");
|
||||
// Never let a failed or partial rerun leave a previous successful history file.
|
||||
await rm(historyPath, { force: true });
|
||||
const report = z
|
||||
.object({
|
||||
success: z.boolean(),
|
||||
numFailedTests: z.number().int().nonnegative(),
|
||||
testResults: z.array(
|
||||
z.object({
|
||||
name: z.string().min(1),
|
||||
startTime: z.number().finite(),
|
||||
endTime: z.number().finite(),
|
||||
}),
|
||||
),
|
||||
})
|
||||
.parse(JSON.parse(await readFile("test-results.json", "utf8")));
|
||||
|
||||
const files = report.testResults.map(({ name, startTime, endTime }) => {
|
||||
const path = relative(root, resolve(root, name));
|
||||
if (
|
||||
path === "" ||
|
||||
path === ".." ||
|
||||
path.startsWith(".." + sep) ||
|
||||
isAbsolute(path)
|
||||
)
|
||||
throw new Error(`Test report path is outside the checkout: ${name}`);
|
||||
const duration = endTime - startTime;
|
||||
if (!Number.isFinite(duration) || duration < 0)
|
||||
throw new Error(`Test report has an invalid duration: ${name}`);
|
||||
return { name: path.split(sep).join("/"), startTime: 0, endTime: duration };
|
||||
});
|
||||
const complete = process.env.SHARD_RESULT === "success";
|
||||
const passed =
|
||||
complete &&
|
||||
process.env.MERGE_RESULT === "success" &&
|
||||
report.success &&
|
||||
report.numFailedTests === 0;
|
||||
const summary = [
|
||||
complete ? "## Merged test diagnostics" : "## Partial test diagnostics",
|
||||
"",
|
||||
`Shard result: ${process.env.SHARD_RESULT ?? "unknown"}; merge result: ${process.env.MERGE_RESULT ?? "unknown"}.`,
|
||||
passed
|
||||
? "Successful timing history is available."
|
||||
: "This report is diagnostic only and is not a successful timing baseline.",
|
||||
"",
|
||||
"| Slowest file | Duration (ms) |",
|
||||
"| --- | ---: |",
|
||||
...files
|
||||
.toSorted((left, right) => right.endTime - left.endTime)
|
||||
.slice(0, 20)
|
||||
.map(
|
||||
({ name, endTime }) => `| ${name.replaceAll("|", "\\|")} | ${endTime} |`,
|
||||
),
|
||||
"",
|
||||
].join("\n");
|
||||
if (process.env.GITHUB_STEP_SUMMARY)
|
||||
await appendFile(process.env.GITHUB_STEP_SUMMARY, summary);
|
||||
else console.log(summary);
|
||||
|
||||
if (passed) {
|
||||
await mkdir(historyDirectory, { recursive: true });
|
||||
await writeFile(
|
||||
historyPath,
|
||||
JSON.stringify({ success: true, numFailedTests: 0, testResults: files }),
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
{
|
||||
"target_sha256": "659b5fc6a4319dfe4f117d00ad4e7ec004915ebcadcb96628797fb3544040e29",
|
||||
"snapshot_hash": "65817c30a78bb44c3dc3771876b6010a",
|
||||
"engines": {
|
||||
"x86_64": {
|
||||
"dart_version": null,
|
||||
"toolchain_lines": [
|
||||
"Android (5900059 based on r365631c) clang version 9.0.8 (https://android.googlesource.com/toolchain/llvm-project 207d7abc1a2abf3ef8d4301736d6a7ebc224a290) (based on LLVM 9.0.8svn)"
|
||||
]
|
||||
},
|
||||
"armeabi-v7a": {
|
||||
"dart_version": null,
|
||||
"toolchain_lines": [
|
||||
"Android (5900059 based on r365631c) clang version 9.0.8 (https://android.googlesource.com/toolchain/llvm-project 207d7abc1a2abf3ef8d4301736d6a7ebc224a290) (based on LLVM 9.0.8svn)"
|
||||
]
|
||||
},
|
||||
"arm64-v8a": {
|
||||
"dart_version": null,
|
||||
"toolchain_lines": [
|
||||
"Android (5900059 based on r365631c) clang version 9.0.8 (https://android.googlesource.com/toolchain/llvm-project 207d7abc1a2abf3ef8d4301736d6a7ebc224a290) (based on LLVM 9.0.8svn)"
|
||||
]
|
||||
}
|
||||
},
|
||||
"string_pools": {
|
||||
"x86_64": {
|
||||
"package_uri_count_at_least": 756,
|
||||
"dart_uri_count_at_least": 201
|
||||
},
|
||||
"armeabi-v7a": {
|
||||
"package_uri_count_at_least": 212,
|
||||
"dart_uri_count_at_least": 48
|
||||
},
|
||||
"arm64-v8a": {
|
||||
"package_uri_count_at_least": 756,
|
||||
"dart_uri_count_at_least": 201
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,13 +1,11 @@
|
||||
import assert from "node:assert/strict";
|
||||
import { execFile } from "node:child_process";
|
||||
import { createHash } from "node:crypto";
|
||||
import { join } from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import { promisify } from "node:util";
|
||||
import { TraceMap, eachMapping } from "@jridgewell/trace-mapping";
|
||||
import { CdpBrowserProvider } from "../../dist/browser/CdpBrowserProvider.js";
|
||||
import { CdpConnection } from "../../dist/browser/CdpConnection.js";
|
||||
import { waitForBrowserDevtoolsPort } from "../../dist/browser/BrowserProcessStartup.js";
|
||||
import { parseEvidence } from "../../dist/domain/evidence.js";
|
||||
import { traceSourceMap } from "../../dist/javascript/sourceMaps/TraceSourceMap.js";
|
||||
import { startBrowserSourceMapSite } from "../fixtures/browser-source-map-site.mjs";
|
||||
@@ -63,7 +61,6 @@ async function verifyCase(executable, entrypoint, scenario) {
|
||||
let fixture;
|
||||
let connection;
|
||||
let primaryError;
|
||||
let stderr = "";
|
||||
let phase = "native-map-admission";
|
||||
let browserVersion;
|
||||
let expected;
|
||||
@@ -90,17 +87,7 @@ async function verifyCase(executable, entrypoint, scenario) {
|
||||
|
||||
phase = "owned-browser-startup";
|
||||
fixture = await startRuntimeFixtureBrowser(executable, site.origin);
|
||||
fixture.browser.stderr.on("data", (chunk) => {
|
||||
if (stderr.length < 65536) stderr += chunk;
|
||||
});
|
||||
const port = await waitForBrowserDevtoolsPort({
|
||||
child: fixture.browser,
|
||||
executable,
|
||||
activePortPath: join(fixture.profile, "DevToolsActivePort"),
|
||||
stderr: () => stderr,
|
||||
timeoutMs: 20_000,
|
||||
});
|
||||
const endpoint = `http://127.0.0.1:${port}`;
|
||||
const endpoint = `http://127.0.0.1:${fixture.port}`;
|
||||
const provider = new CdpBrowserProvider();
|
||||
const targets = await provider.listTargets({
|
||||
cdp_endpoint: endpoint,
|
||||
|
||||
@@ -3,14 +3,12 @@ import { spawn, execFile } from "node:child_process";
|
||||
import { createHash } from "node:crypto";
|
||||
import { once } from "node:events";
|
||||
import { access } from "node:fs/promises";
|
||||
import { join } from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import { promisify } from "node:util";
|
||||
import { Client } from "@modelcontextprotocol/client";
|
||||
import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
|
||||
import { CdpBrowserProvider } from "../../dist/browser/CdpBrowserProvider.js";
|
||||
import { CdpConnection } from "../../dist/browser/CdpConnection.js";
|
||||
import { waitForBrowserDevtoolsPort } from "../../dist/browser/BrowserProcessStartup.js";
|
||||
import { parseEvidence } from "../../dist/domain/evidence.js";
|
||||
import { webExecutionSchema } from "../../dist/domain/webExecution.js";
|
||||
import { webEventListenersSchema } from "../../dist/domain/webEventListeners.js";
|
||||
@@ -42,23 +40,11 @@ export async function verifyBrowserRuntime(
|
||||
const site = await startBrowserRuntimeSite();
|
||||
let fixture;
|
||||
let primaryError;
|
||||
let stderr = "";
|
||||
let action;
|
||||
let client;
|
||||
try {
|
||||
fixture = await startRuntimeFixtureBrowser(executable, site.origin);
|
||||
const { browser, profile } = fixture;
|
||||
browser.stderr.on("data", (chunk) => {
|
||||
if (stderr.length < 65536) stderr += chunk;
|
||||
});
|
||||
const port = await waitForBrowserDevtoolsPort({
|
||||
child: browser,
|
||||
executable,
|
||||
activePortPath: join(profile, "DevToolsActivePort"),
|
||||
stderr: () => stderr,
|
||||
timeoutMs: 20_000,
|
||||
});
|
||||
const endpoint = `http://127.0.0.1:${port}`;
|
||||
const endpoint = `http://127.0.0.1:${fixture.port}`;
|
||||
const targets = await new CdpBrowserProvider().listTargets({
|
||||
cdp_endpoint: endpoint,
|
||||
allowed_origins: [site.origin],
|
||||
|
||||
@@ -8,8 +8,9 @@ import { spawnOwnedProviderProcess } from "../../dist/process/ProviderProcess.js
|
||||
import { createSystemProcessOwnershipHost } from "../../dist/process/ProcessOwnershipObservation.js";
|
||||
import { liveProcesses } from "../../dist/process/ProcessOwnershipProcessTree.js";
|
||||
import { CdpConnection } from "../../dist/browser/CdpConnection.js";
|
||||
import { waitForBrowserDevtoolsPort } from "../../dist/browser/BrowserProcessStartup.js";
|
||||
|
||||
/** Launch only the synthetic fixture browser in its own verified process group. */
|
||||
/** Launch the synthetic fixture browser and await CDP in its own verified process group. */
|
||||
export async function startRuntimeFixtureBrowser(executable, origin) {
|
||||
const profile = await mkdtemp(join(tmpdir(), "rea-real-web-runtime-"));
|
||||
let owned;
|
||||
@@ -38,9 +39,21 @@ export async function startRuntimeFixtureBrowser(executable, origin) {
|
||||
expectedCommand: null,
|
||||
});
|
||||
owned.process.stdout?.resume();
|
||||
let stderr = "";
|
||||
owned.process.stderr?.on("data", (chunk) => {
|
||||
if (stderr.length < 65536) stderr += chunk;
|
||||
});
|
||||
const port = await waitForBrowserDevtoolsPort({
|
||||
child: owned.process,
|
||||
executable,
|
||||
activePortPath: join(profile, "DevToolsActivePort"),
|
||||
stderr: () => stderr,
|
||||
// Match the broader real-browser verifier's allowance for cold Chrome
|
||||
// startup on shared runners; early process failures still reject at once.
|
||||
timeoutMs: 60_000,
|
||||
});
|
||||
return {
|
||||
browser: owned.process,
|
||||
profile,
|
||||
port,
|
||||
close: async () => {
|
||||
await stopOwnedBrowser(owned, profile);
|
||||
await rm(profile, {
|
||||
|
||||
@@ -29,6 +29,9 @@ export const toolFamilyCatalog = (sources) => {
|
||||
...sources.evmContracts.EVM_TOOL_CONTRACTS,
|
||||
...sources.goContracts.GO_TOOL_CONTRACTS,
|
||||
...sources.wasmContracts.WASM_TOOL_CONTRACTS,
|
||||
...sources.sqliteContracts.SQLITE_TOOL_CONTRACTS,
|
||||
...sources.captureContracts.CAPTURE_TOOL_CONTRACTS,
|
||||
...sources.signalContracts.SIGNAL_TOOL_CONTRACTS,
|
||||
],
|
||||
},
|
||||
{
|
||||
@@ -49,6 +52,11 @@ export const toolFamilyCatalog = (sources) => {
|
||||
surface: "android-provider",
|
||||
contracts: sources.androidContracts.ANDROID_TOOL_CONTRACTS,
|
||||
},
|
||||
{
|
||||
id: "flutter",
|
||||
surface: "flutter-provider",
|
||||
contracts: sources.flutterContracts.FLUTTER_TOOL_CONTRACTS,
|
||||
},
|
||||
{
|
||||
id: "frida",
|
||||
surface: "instrumentation-provider",
|
||||
@@ -190,6 +198,14 @@ export const providerCatalog = (sources) => {
|
||||
({ name }) => name === "inspect_pe_resources",
|
||||
),
|
||||
},
|
||||
{
|
||||
identity: sources.captureProvider.TSHARK_PROVIDER_IDENTITY,
|
||||
contracts: sources.captureContracts.CAPTURE_TOOL_CONTRACTS,
|
||||
},
|
||||
{
|
||||
identity: sources.signalProvider.SIGROK_PROVIDER_IDENTITY,
|
||||
contracts: sources.signalContracts.SIGNAL_TOOL_CONTRACTS,
|
||||
},
|
||||
{
|
||||
identity: sources.wasmProvider.WABT_PROVIDER_IDENTITY,
|
||||
contracts: sources.wasmContracts.WASM_TOOL_CONTRACTS,
|
||||
@@ -202,6 +218,10 @@ export const providerCatalog = (sources) => {
|
||||
identity: sources.goProvider.GO_BINARY_PROVIDER_IDENTITY,
|
||||
contracts: sources.goContracts.GO_TOOL_CONTRACTS,
|
||||
},
|
||||
{
|
||||
identity: sources.sqliteDomain.SQLITE_PROVIDER_IDENTITY,
|
||||
contracts: sources.sqliteContracts.SQLITE_TOOL_CONTRACTS,
|
||||
},
|
||||
{
|
||||
identity: sources.artifactProviders.ARTIFACT_GRAPH_PROVIDER,
|
||||
contracts: sources.artifactContracts.ARTIFACT_TOOL_CONTRACTS,
|
||||
@@ -231,6 +251,10 @@ export const providerCatalog = (sources) => {
|
||||
identity: sources.androidProvider.JADX_PROVIDER_IDENTITY,
|
||||
contracts: sources.androidContracts.ANDROID_TOOL_CONTRACTS,
|
||||
},
|
||||
{
|
||||
identity: sources.flutterProvider.FLUTTER_PROVIDER_IDENTITY,
|
||||
contracts: sources.flutterContracts.FLUTTER_TOOL_CONTRACTS,
|
||||
},
|
||||
{
|
||||
identity: sources.apktoolProvider.APKTOOL_PROVIDER_IDENTITY,
|
||||
contracts: sources.apktoolContracts.APKTOOL_TOOL_CONTRACTS,
|
||||
|
||||
@@ -47,9 +47,15 @@ const SOURCE_PATHS = {
|
||||
fridaProvider: "dist/frida/FridaInstrumentationManager.js",
|
||||
pwntoolsProvider: "dist/native/pwntools/PwntoolsRelease.js",
|
||||
nativeContracts: "dist/contracts/native/nativeToolContracts.js",
|
||||
captureContracts: "dist/contracts/captures/captureToolContracts.js",
|
||||
captureProvider: "dist/captures/TsharkCaptureProvider.js",
|
||||
signalContracts: "dist/contracts/signals/signalToolContracts.js",
|
||||
signalProvider: "dist/signals/SigrokRecordingProvider.js",
|
||||
wasmContracts: "dist/contracts/wasm/wasmToolContracts.js",
|
||||
wasmProvider: "dist/wasm/WabtRelease.js",
|
||||
evmContracts: "dist/contracts/evm/evmToolContracts.js",
|
||||
sqliteContracts: "dist/contracts/sqlite/sqliteToolContracts.js",
|
||||
sqliteDomain: "dist/domain/sqlite/sqliteDatabase.js",
|
||||
evmProvider: "dist/evm/EvmoleRelease.js",
|
||||
goContracts: "dist/contracts/go/goToolContracts.js",
|
||||
goProvider: "dist/go/GoBinaryProvider.js",
|
||||
@@ -58,8 +64,12 @@ const SOURCE_PATHS = {
|
||||
firmwareContracts: "dist/contracts/firmware/firmwareToolContracts.js",
|
||||
firmwareProvider: "dist/firmware/FirmwareRelease.js",
|
||||
androidContracts: "dist/contracts/android/androidToolContracts.js",
|
||||
flutterContracts: "dist/contracts/flutter/flutterToolContracts.js",
|
||||
flutterProvider: "dist/flutter/FlutterBuildProvider.js",
|
||||
androidProvider: "dist/android/JadxRelease.js",
|
||||
apktoolContracts: "dist/contracts/apktool/apktoolToolContracts.js",
|
||||
flutterContracts: "dist/contracts/flutter/flutterToolContracts.js",
|
||||
flutterProvider: "dist/flutter/FlutterBuildProvider.js",
|
||||
apktoolProvider: "dist/apktool/ApktoolProvider.js",
|
||||
jebContracts: "dist/contracts/jeb/jebToolContracts.js",
|
||||
jebProvider: "dist/jeb/JebProvider.js",
|
||||
|
||||
@@ -5,9 +5,12 @@ import { fileURLToPath, pathToFileURL } from "node:url";
|
||||
|
||||
const PURE_LAYERS = new Set(["domain", "contracts"]);
|
||||
const MIGRATED_PROVIDER_ROOTS = new Set([
|
||||
"sqlite",
|
||||
"evm",
|
||||
"go",
|
||||
"wasm",
|
||||
"captures",
|
||||
"signals",
|
||||
"android",
|
||||
"firmware",
|
||||
"ghidra",
|
||||
|
||||
@@ -36,16 +36,11 @@ export async function verifyGhidraSnapshotLifecycle(
|
||||
);
|
||||
const error = requireMcpToolError(reply);
|
||||
assert.equal(
|
||||
error?.code,
|
||||
error.code,
|
||||
"evidence_integrity_mismatch",
|
||||
JSON.stringify(reply),
|
||||
);
|
||||
assert.match(error.message, /after analysis metadata mutations/u);
|
||||
assert.match(
|
||||
error.remediation.action,
|
||||
/close.*without saving a snapshot/iu,
|
||||
);
|
||||
assert.match(error.remediation.action, /export_evidence_bundle/u);
|
||||
assert.equal(error.retryable, false);
|
||||
rejectedCalls++;
|
||||
};
|
||||
try {
|
||||
|
||||
+1
-1
@@ -49,7 +49,7 @@ if (await pathExists(join(root, "src"))) {
|
||||
"dist/mcp/main.js",
|
||||
"dist/cli-runtime/cli.js",
|
||||
"dist/cli-runtime/cliOutput.js",
|
||||
"dist/cli-runtime/streamedJsonOutput.js",
|
||||
"dist/cli-runtime/cliResultOutput.js",
|
||||
"dist/cli-runtime/mcpDoctor.js",
|
||||
"dist/mcpDoctor.js",
|
||||
"dist/cli.js",
|
||||
|
||||
+4
-4
@@ -37,7 +37,7 @@ const runtimeFiles = isMcpMode
|
||||
: [
|
||||
"dist/cli-runtime/cli.js",
|
||||
"dist/cli-runtime/cliOutput.js",
|
||||
"dist/cli-runtime/streamedJsonOutput.js",
|
||||
"dist/cli-runtime/cliResultOutput.js",
|
||||
];
|
||||
|
||||
if (!(await compiledRuntimeExists(runtimeFiles))) {
|
||||
@@ -60,8 +60,8 @@ if (!(await compiledRuntimeExists(runtimeFiles))) {
|
||||
} else {
|
||||
const { cliConfigurationError, createCli } =
|
||||
await import("../dist/cli-runtime/cli.js");
|
||||
const { createStreamedCliJsonOutput } =
|
||||
await import("../dist/cli-runtime/streamedJsonOutput.js");
|
||||
const { createCliResultOutput } =
|
||||
await import("../dist/cli-runtime/cliResultOutput.js");
|
||||
const {
|
||||
renderCliOutputArgumentError,
|
||||
renderEmptyFilteredCliOutput,
|
||||
@@ -77,7 +77,7 @@ if (!(await compiledRuntimeExists(runtimeFiles))) {
|
||||
process.exitCode = 1;
|
||||
} else {
|
||||
let wroteOutput = false;
|
||||
const resultOutput = createStreamedCliJsonOutput(args, process.stdout);
|
||||
const resultOutput = createCliResultOutput(args, process.stdout);
|
||||
await createCli(process.env, resultOutput).serve(args, {
|
||||
stdout: (output) => {
|
||||
if (resultOutput?.handled) {
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#!/usr/bin/env node
|
||||
|
||||
import { spawn } from "node:child_process";
|
||||
import spawn from "cross-spawn";
|
||||
import { mkdir } from "node:fs/promises";
|
||||
import { join, resolve } from "node:path";
|
||||
import { DatabaseSync } from "node:sqlite";
|
||||
@@ -74,7 +74,6 @@ function runCommand() {
|
||||
child = spawn(command[0], command.slice(1), {
|
||||
cwd: process.cwd(),
|
||||
env: process.env,
|
||||
shell: process.platform === "win32",
|
||||
stdio: "inherit",
|
||||
});
|
||||
child.once("error", reject);
|
||||
|
||||
@@ -0,0 +1,259 @@
|
||||
import assert from "node:assert/strict";
|
||||
import { execFile } from "node:child_process";
|
||||
import { readdir, readFile } from "node:fs/promises";
|
||||
import { resolve } from "node:path";
|
||||
import { promisify } from "node:util";
|
||||
import { Client } from "@modelcontextprotocol/client";
|
||||
import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
|
||||
import { toolContract } from "../dist/contracts/toolContracts.js";
|
||||
import { PrivateRuntimeRoot } from "../dist/process/PrivateRuntimeRoot.js";
|
||||
import { hashStableFile } from "../dist/filesystem/StableFileHash.js";
|
||||
import { mcpTextValue } from "./lib/mcp-verifier-results.mjs";
|
||||
|
||||
const options = parseArguments(process.argv.slice(2));
|
||||
if (options.help) {
|
||||
process.stdout.write(
|
||||
"Usage: npm run verify:flutter -- --apk PATH [--plain-apk PATH] [--expectations JSON]\n" +
|
||||
"Checks real APK parsing through compiled CLI and stdio MCP. Optional\n" +
|
||||
"expectations bind exact engine labels, URI counts and snapshot hash to an APK digest.\n",
|
||||
);
|
||||
process.exit(0);
|
||||
}
|
||||
if (options.apk === null) {
|
||||
process.stderr.write("No Flutter APK was provided; pass --apk PATH.\n");
|
||||
process.exit(2);
|
||||
}
|
||||
const expectations =
|
||||
options.expectations === null
|
||||
? null
|
||||
: JSON.parse(await readFile(options.expectations, "utf8"));
|
||||
const root = await PrivateRuntimeRoot.create({
|
||||
prefix: "rea-flutter-verifier-",
|
||||
});
|
||||
const entrypoint = resolve("scripts/rea.mjs");
|
||||
const environment = Object.fromEntries(
|
||||
Object.entries(process.env).filter(([, value]) => typeof value === "string"),
|
||||
);
|
||||
Object.assign(environment, {
|
||||
TMPDIR: root.path,
|
||||
TMP: root.path,
|
||||
TEMP: root.path,
|
||||
});
|
||||
const client = new Client({ name: "flutter-verifier", version: "1" });
|
||||
const transport = new StdioClientTransport({
|
||||
command: process.execPath,
|
||||
args: [entrypoint, "mcp"],
|
||||
env: environment,
|
||||
stderr: "pipe",
|
||||
});
|
||||
const execute = promisify(execFile);
|
||||
try {
|
||||
await client.connect(transport);
|
||||
const apk = resolve(options.apk);
|
||||
const identity = await hashStableFile(apk);
|
||||
const identified = await run("identify_flutter_build", { path: apk });
|
||||
assert.deepEqual(identified.target, { path: apk, ...identity });
|
||||
assert.equal(identified.flutter_detected, true);
|
||||
assert.equal(identified.coverage, "complete");
|
||||
const abis = identified.abis.filter((abi) => abi.libapp.present);
|
||||
assert.ok(abis.length > 0);
|
||||
const hashes = new Set();
|
||||
for (const abi of abis) {
|
||||
assert.equal(abi.libapp.elf_header_valid, true);
|
||||
assert.equal(abi.libapp.snapshot_hash_sources, 2);
|
||||
assert.ok(abi.libapp.snapshot_hash);
|
||||
hashes.add(abi.libapp.snapshot_hash);
|
||||
assert.equal(abi.libflutter.present, true);
|
||||
assert.match(abi.libflutter.build_id ?? "", /^(?:[0-9a-f]{2}){4,64}$/u);
|
||||
assert.deepEqual(abi.libflutter.build_id_candidates, [
|
||||
abi.libflutter.build_id,
|
||||
]);
|
||||
}
|
||||
assert.equal(hashes.size, 1, "Every ABI must agree on the snapshot hash");
|
||||
if (expectations !== null) {
|
||||
assert.equal(identity.sha256, expectations.target_sha256);
|
||||
assert.deepEqual([...hashes], [expectations.snapshot_hash]);
|
||||
assert.deepEqual(
|
||||
abis.map((abi) => abi.abi).sort(),
|
||||
Object.keys(expectations.engines).sort(),
|
||||
);
|
||||
for (const abi of abis) {
|
||||
assert.deepEqual(
|
||||
{
|
||||
dart_version: abi.libflutter.dart_version,
|
||||
toolchain_lines: abi.libflutter.toolchain_lines,
|
||||
},
|
||||
expectations.engines[abi.abi],
|
||||
);
|
||||
assert.equal(abi.libflutter.dart_version_capped, false);
|
||||
assert.equal(abi.libflutter.toolchain_capped, false);
|
||||
}
|
||||
process.stdout.write(
|
||||
"[ok] Exact per-ABI engine labels match digest-bound expectations\n",
|
||||
);
|
||||
} else {
|
||||
process.stdout.write(
|
||||
"[unverified] Exact engine labels and their absence need --expectations JSON\n",
|
||||
);
|
||||
}
|
||||
// The same checks apply to the default selection and each remaining ABI.
|
||||
const preferred = await run("inspect_dart_aot", { path: apk });
|
||||
for (const abi of abis) {
|
||||
const aot =
|
||||
abi.abi === preferred.abi
|
||||
? preferred
|
||||
: await run("inspect_dart_aot", { path: apk, abi: abi.abi });
|
||||
assert.equal(aot.abi, abi.abi);
|
||||
assert.equal(
|
||||
aot.libapp.coverage,
|
||||
"complete",
|
||||
`Snapshot decoding must be complete on ${abi.abi}`,
|
||||
);
|
||||
assert.equal(aot.coverage, aot.string_pool.coverage);
|
||||
if (aot.coverage !== "complete") {
|
||||
process.stdout.write(
|
||||
`[unverified] ${abi.abi}: full string-pool projection (returned pool is bounded and partial)\n`,
|
||||
);
|
||||
}
|
||||
assert.deepEqual(aot.target, identified.target);
|
||||
assert.equal(aot.libapp.sha256, abi.libapp.sha256);
|
||||
assert.equal(aot.libapp.bytes, abi.libapp.bytes);
|
||||
assert.equal(aot.libapp.snapshot_hash_sources, 2);
|
||||
assert.equal(aot.libapp.snapshot_hash, abi.libapp.snapshot_hash);
|
||||
assert.deepEqual(
|
||||
aot.libapp.sections.map((section) => section.name).sort(),
|
||||
[
|
||||
"_kDartVmSnapshotData",
|
||||
"_kDartVmSnapshotInstructions",
|
||||
"_kDartIsolateSnapshotData",
|
||||
"_kDartIsolateSnapshotInstructions",
|
||||
].sort(),
|
||||
);
|
||||
for (const section of aot.libapp.sections) {
|
||||
assert.ok(section.offset + section.size <= aot.libapp.bytes);
|
||||
if (!section.name.endsWith("Data")) continue;
|
||||
assert.equal(section.magic_valid, true);
|
||||
assert.equal(
|
||||
section.kind,
|
||||
3,
|
||||
"This verifier requires an AOT app snapshot",
|
||||
);
|
||||
assert.ok(
|
||||
section.header_length >= 48 &&
|
||||
section.header_length + 4 <= section.size,
|
||||
`Snapshot extent must fit ${section.name} on ${abi.abi}`,
|
||||
);
|
||||
}
|
||||
assert.ok(aot.string_pool.package_uri_count_at_least > 0);
|
||||
assert.ok(aot.string_pool.dart_uri_count_at_least > 0);
|
||||
if (expectations?.string_pools !== undefined) {
|
||||
const expected = expectations.string_pools[abi.abi];
|
||||
assert.ok(
|
||||
expected,
|
||||
`Pinned string-pool counts are required on ${abi.abi}`,
|
||||
);
|
||||
assert.equal(
|
||||
aot.string_pool.package_uri_count_at_least,
|
||||
expected.package_uri_count_at_least,
|
||||
);
|
||||
assert.equal(
|
||||
aot.string_pool.dart_uri_count_at_least,
|
||||
expected.dart_uri_count_at_least,
|
||||
);
|
||||
process.stdout.write(
|
||||
`[ok] ${abi.abi}: exact pinned package and Dart URI counts\n`,
|
||||
);
|
||||
} else {
|
||||
process.stdout.write(
|
||||
`[unverified] ${abi.abi}: exact string-pool counts need --expectations JSON\n`,
|
||||
);
|
||||
}
|
||||
process.stdout.write(
|
||||
`[ok] ${abi.abi}: four symbols, bounded AOT headers, agreeing hashes and string pool\n`,
|
||||
);
|
||||
}
|
||||
if (options.plainApk !== null) {
|
||||
const plain = resolve(options.plainApk);
|
||||
const negative = await run("identify_flutter_build", { path: plain });
|
||||
assert.deepEqual(negative.target, {
|
||||
path: plain,
|
||||
...(await hashStableFile(plain)),
|
||||
});
|
||||
assert.equal(negative.flutter_detected, false);
|
||||
assert.equal(negative.coverage, "complete");
|
||||
}
|
||||
assert.deepEqual(
|
||||
await hashStableFile(apk),
|
||||
identity,
|
||||
"Verification must preserve its input",
|
||||
);
|
||||
} finally {
|
||||
// Server shutdown retries retained provider cleanup and must settle before success.
|
||||
try {
|
||||
await client.close();
|
||||
await transport.close();
|
||||
assert.deepEqual(
|
||||
await readdir(root.path),
|
||||
[],
|
||||
"Provider snapshots must be released before verification succeeds",
|
||||
);
|
||||
} finally {
|
||||
await root.close();
|
||||
}
|
||||
}
|
||||
process.stdout.write(
|
||||
"all asserted Flutter CLI/MCP checks passed; unverified facets are reported above\n",
|
||||
);
|
||||
|
||||
async function run(operation, input) {
|
||||
const contract = toolContract(operation);
|
||||
const args = [
|
||||
entrypoint,
|
||||
operation.replaceAll("_", "-"),
|
||||
input.path,
|
||||
"--json",
|
||||
];
|
||||
if (input.abi !== undefined) args.push("--abi", input.abi);
|
||||
const { stdout } = await execute(process.execPath, args, {
|
||||
env: environment,
|
||||
timeout: 60_000,
|
||||
maxBuffer: 8 * 1024 * 1024,
|
||||
});
|
||||
const cli = contract.outputSchema.parse(JSON.parse(stdout));
|
||||
const response = await client.callTool(
|
||||
{ name: operation, arguments: input },
|
||||
{ timeout: 60_000 },
|
||||
);
|
||||
assert.notEqual(response.isError, true, mcpTextValue(response));
|
||||
const mcp = contract.outputSchema.parse(JSON.parse(mcpTextValue(response)));
|
||||
assert.deepEqual(cli.normalized_result, mcp.normalized_result);
|
||||
assert.deepEqual(cli.subject, mcp.subject);
|
||||
assert.equal(cli.subject.local_path, input.path);
|
||||
assert.equal(cli.subject.digest.sha256, cli.normalized_result.target.sha256);
|
||||
assert.deepEqual(cli.limitations, mcp.limitations);
|
||||
process.stdout.write(
|
||||
`[ok] ${operation}${input.abi === undefined ? "" : ` ${input.abi}`}: CLI/MCP Evidence parity\n`,
|
||||
);
|
||||
return cli.normalized_result;
|
||||
}
|
||||
|
||||
function parseArguments(argv) {
|
||||
const parsed = { help: false, apk: null, plainApk: null, expectations: null };
|
||||
const names = {
|
||||
"--apk": "apk",
|
||||
"--plain-apk": "plainApk",
|
||||
"--expectations": "expectations",
|
||||
};
|
||||
for (let index = 0; index < argv.length; index += 1) {
|
||||
const argument = argv[index];
|
||||
if (argument === "--help" || argument === "-h") parsed.help = true;
|
||||
else if (
|
||||
Object.hasOwn(names, argument) &&
|
||||
typeof argv[index + 1] === "string" &&
|
||||
!argv[index + 1].startsWith("--")
|
||||
) {
|
||||
parsed[names[argument]] = argv[++index];
|
||||
} else throw new Error(`Unknown argument or missing value: ${argument}`);
|
||||
}
|
||||
return parsed;
|
||||
}
|
||||
@@ -115,16 +115,25 @@ try {
|
||||
],
|
||||
{ GOOS: os, GOARCH: arch },
|
||||
);
|
||||
await verify(path, target, oracle);
|
||||
await verify(path, target, oracle, null, "stripped");
|
||||
if (os === "linux" && arch === "amd64") {
|
||||
const sectionless = join(root.path, "linux-amd64-sectionless");
|
||||
const bytes = Buffer.from(await readFile(path));
|
||||
bytes.fill(0, 40, 48); // ELF64 e_shoff.
|
||||
bytes.fill(0, 58, 64); // e_shentsize, e_shnum and e_shstrndx.
|
||||
await writeFile(sectionless, bytes);
|
||||
await verify(sectionless, target, oracle);
|
||||
await verify(sectionless, target, oracle, null, "sectionless");
|
||||
}
|
||||
}
|
||||
for (const target of targets.filter(([os]) => os === "darwin")) {
|
||||
const [os, arch] = target;
|
||||
const path = join(root.path, `${os}-${arch}-unstripped`);
|
||||
await go(["build", "-trimpath", "-buildvcs=false", "-o", path, "."], {
|
||||
GOOS: os,
|
||||
GOARCH: arch,
|
||||
});
|
||||
await verify(path, target, oracle, null, "unstripped");
|
||||
}
|
||||
if (process.platform === "win32")
|
||||
omittedCoverage.push(
|
||||
"Compiler-produced non-UTF-8 argv strings were not verified on Windows; Windows argv cannot preserve arbitrary byte arguments.",
|
||||
@@ -317,7 +326,13 @@ async function inspect(mode, path) {
|
||||
return { evidence, report };
|
||||
}
|
||||
|
||||
async function verify(path, target, oracle, byteExpected = null) {
|
||||
async function verify(
|
||||
path,
|
||||
target,
|
||||
oracle,
|
||||
byteExpected = null,
|
||||
fileKind = "stripped",
|
||||
) {
|
||||
const bytes = await readFile(path);
|
||||
const expected =
|
||||
byteExpected ??
|
||||
@@ -387,12 +402,7 @@ async function verify(path, target, oracle, byteExpected = null) {
|
||||
);
|
||||
verified.push({
|
||||
target: `${target[0]}/${target[1]}`,
|
||||
file:
|
||||
byteExpected === null
|
||||
? path.endsWith("sectionless")
|
||||
? "sectionless"
|
||||
: "stripped"
|
||||
: "byte-valued-strings",
|
||||
file: byteExpected === null ? fileKind : "byte-valued-strings",
|
||||
go_version: expected.GoVersion,
|
||||
...(byteExpected === null
|
||||
? {}
|
||||
|
||||
@@ -0,0 +1,294 @@
|
||||
#!/usr/bin/env node
|
||||
import assert from "node:assert/strict";
|
||||
import { execFile } from "node:child_process";
|
||||
import { createHash } from "node:crypto";
|
||||
import { readFile, writeFile, readdir } from "node:fs/promises";
|
||||
import { isAbsolute, join } from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import { promisify } from "node:util";
|
||||
import { Client } from "@modelcontextprotocol/client";
|
||||
import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
|
||||
import { Ajv2020 } from "ajv/dist/2020.js";
|
||||
import { PrivateRuntimeRoot } from "../dist/process/PrivateRuntimeRoot.js";
|
||||
import { parseEvidence } from "../dist/domain/evidence.js";
|
||||
import { createVerifierRun, completeVerifierRun } from "./lib/verifier-run.mjs";
|
||||
|
||||
if (process.platform !== "linux")
|
||||
throw new Error(
|
||||
"Real packet capture verification requires Linux with util-linux prlimit.",
|
||||
);
|
||||
if (!isAbsolute(process.env.REA_TSHARK_COMMAND ?? ""))
|
||||
throw new Error("Supply absolute REA_TSHARK_COMMAND for TShark 4.x.");
|
||||
const entrypoint =
|
||||
process.argv[2] ?? fileURLToPath(new URL("./rea.mjs", import.meta.url));
|
||||
const run = createVerifierRun();
|
||||
const root = await PrivateRuntimeRoot.create({
|
||||
prefix: "rea-capture-verifier-",
|
||||
});
|
||||
const path = join(root.path, "network with spaces.pcap");
|
||||
const bluetooth = join(root.path, "bluetooth.pcap");
|
||||
const execute = promisify(execFile);
|
||||
const environment = {
|
||||
...process.env,
|
||||
TMPDIR: root.path,
|
||||
TMP: root.path,
|
||||
TEMP: root.path,
|
||||
};
|
||||
const client = new Client({ name: "packet-capture-verifier", version: "1" });
|
||||
const transport = new StdioClientTransport({
|
||||
command: process.execPath,
|
||||
args: [entrypoint, "mcp"],
|
||||
env: environment,
|
||||
stderr: "pipe",
|
||||
});
|
||||
|
||||
// Independently synthesize PCAP bytes; no external captures or device access.
|
||||
const pcap = (linktype, packets) => {
|
||||
const header = Buffer.alloc(24);
|
||||
header.writeUInt32LE(0xa1b2c3d4, 0);
|
||||
header.writeUInt16LE(2, 4);
|
||||
header.writeUInt16LE(4, 6);
|
||||
header.writeUInt32LE(65535, 16);
|
||||
header.writeUInt32LE(linktype, 20);
|
||||
return Buffer.concat([
|
||||
header,
|
||||
...packets.flatMap((bytes, i) => {
|
||||
const record = Buffer.alloc(16);
|
||||
record.writeUInt32LE(1700000000 + i, 0);
|
||||
record.writeUInt32LE(bytes.length, 8);
|
||||
record.writeUInt32LE(bytes.length, 12);
|
||||
return [record, bytes];
|
||||
}),
|
||||
]);
|
||||
};
|
||||
const udp = (destination, payload) => {
|
||||
const ip = Buffer.from("450000000001000040110000c0000201c0000202", "hex");
|
||||
ip.writeUInt16BE(28 + payload.length, 2);
|
||||
let checksum = 0;
|
||||
for (let i = 0; i < ip.length; i += 2) checksum += ip.readUInt16BE(i);
|
||||
while (checksum > 0xffff) checksum = (checksum & 0xffff) + (checksum >>> 16);
|
||||
ip.writeUInt16BE(~checksum & 0xffff, 10);
|
||||
const header = Buffer.alloc(8);
|
||||
header.writeUInt16BE(40000, 0);
|
||||
header.writeUInt16BE(destination, 2);
|
||||
header.writeUInt16BE(8 + payload.length, 4);
|
||||
return Buffer.concat([
|
||||
Buffer.from("0200000000020200000000010800", "hex"),
|
||||
ip,
|
||||
header,
|
||||
payload,
|
||||
]);
|
||||
};
|
||||
const dnsQuery = Buffer.from(
|
||||
"123401000001000000000000076578616d706c6504746573740000010001",
|
||||
"hex",
|
||||
);
|
||||
const source = pcap(1, [
|
||||
udp(5554, Buffer.from("REA")),
|
||||
udp(5555, dnsQuery),
|
||||
udp(5555, dnsQuery),
|
||||
]);
|
||||
// LINKTYPE_BLUETOOTH_HCI_H4 = 187; H4 command packet, HCI Reset opcode 0x0c03, no parameters.
|
||||
const bluetoothSource = pcap(187, [Buffer.from("01030c00", "hex")]);
|
||||
let cases = 0;
|
||||
try {
|
||||
await writeFile(path, source);
|
||||
await writeFile(bluetooth, bluetoothSource);
|
||||
await client.connect(transport);
|
||||
const tool = (await client.listTools()).tools.find(
|
||||
({ name }) => name === "inspect_packet_capture",
|
||||
);
|
||||
assert.ok(tool?.outputSchema);
|
||||
const ajv = new Ajv2020({ strict: false, validateFormats: false });
|
||||
assert.ok(ajv.validateSchema(tool.inputSchema));
|
||||
assert.ok(ajv.validateSchema(tool.outputSchema));
|
||||
const inspect = async (input) => {
|
||||
const response = await client.callTool({
|
||||
name: tool.name,
|
||||
arguments: input,
|
||||
});
|
||||
assert.notEqual(response.isError, true, JSON.stringify(response));
|
||||
assert.ok(
|
||||
ajv.validate(tool.outputSchema, response.structuredContent),
|
||||
JSON.stringify(ajv.errors),
|
||||
);
|
||||
const evidence = parseEvidence(response.structuredContent);
|
||||
const report = evidence.normalized_result;
|
||||
assert.equal(
|
||||
report.artifact.sha256,
|
||||
createHash("sha256")
|
||||
.update(await readFile(input.path))
|
||||
.digest("hex"),
|
||||
);
|
||||
assert.equal(report.hardware_acquisition, "not-performed");
|
||||
assert.equal(report.limits.address_space_bytes, 1073741824);
|
||||
assert.equal(report.tool.configured_path, process.env.REA_TSHARK_COMMAND);
|
||||
assert.equal(
|
||||
report.resource_limiter.configured_path,
|
||||
process.env.REA_TSHARK_PRLIMIT_COMMAND ?? "/usr/bin/prlimit",
|
||||
);
|
||||
assert.ok(
|
||||
report.resource_limiter.arguments.includes("--as=1073741824:1073741824"),
|
||||
);
|
||||
assert.equal(report.configuration, "private-empty-personal-profile");
|
||||
const flags = Object.entries(input)
|
||||
.filter(([key]) => key !== "path")
|
||||
.flatMap(([key, value]) =>
|
||||
key === "match_limit" && value === null
|
||||
? ["--all_matches"]
|
||||
: typeof value === "boolean"
|
||||
? [value ? `--${key}` : `--no-${key}`]
|
||||
: (Array.isArray(value) ? value : [value]).flatMap((item) => [
|
||||
`--${key}`,
|
||||
String(item),
|
||||
]),
|
||||
);
|
||||
const cli = JSON.parse(
|
||||
(
|
||||
await execute(
|
||||
process.execPath,
|
||||
[
|
||||
entrypoint,
|
||||
"inspect-packet-capture",
|
||||
input.path,
|
||||
...flags,
|
||||
"--format",
|
||||
"json",
|
||||
],
|
||||
{ env: environment, timeout: 60000, maxBuffer: 16 * 1024 * 1024 },
|
||||
)
|
||||
).stdout,
|
||||
);
|
||||
assert.deepEqual(parseEvidence(cli), evidence);
|
||||
const bundle = await client.callTool({
|
||||
name: "get_evidence_bundle",
|
||||
arguments: {},
|
||||
});
|
||||
assert.ok(JSON.stringify(bundle).includes(evidence.evidence_id));
|
||||
cases++;
|
||||
return report;
|
||||
};
|
||||
for (const two_pass of [true, false]) {
|
||||
const report = await inspect({
|
||||
path,
|
||||
fields: ["ip.addr", "udp.port", "tcp.port"],
|
||||
display_filter: "udp.dstport == 5555",
|
||||
two_pass,
|
||||
});
|
||||
assert.deepEqual(
|
||||
report.packets.map((p) => p["frame.number"]),
|
||||
[["2"], ["3"]],
|
||||
);
|
||||
assert.deepEqual(report.packets[0]["ip.addr"], ["192.0.2.1", "192.0.2.2"]);
|
||||
assert.deepEqual(report.packets[0]["udp.port"], ["40000", "5555"]);
|
||||
assert.equal(Object.hasOwn(report.packets[0], "tcp.port"), false);
|
||||
assert.equal(report.read_scope, "to-eof");
|
||||
}
|
||||
const selected = {
|
||||
path,
|
||||
fields: ["dns.qry.name"],
|
||||
decode_as: ["udp.port==5555,dns"],
|
||||
display_filter: "dns",
|
||||
};
|
||||
const dns = await inspect(selected);
|
||||
assert.equal(dns.packets.length, 2);
|
||||
assert.deepEqual(dns.packets[0]["dns.qry.name"], ["example.test"]);
|
||||
const prefix = await inspect({ ...selected, packet_limit: 1 });
|
||||
assert.deepEqual(prefix.packets, []);
|
||||
assert.equal(prefix.read_scope, "up-to-input-packet-limit");
|
||||
const empty = await inspect({
|
||||
path,
|
||||
fields: ["frame.number"],
|
||||
display_filter: "tcp",
|
||||
});
|
||||
assert.deepEqual(empty.packets, []);
|
||||
const pagedPath = join(root.path, "paged.pcap");
|
||||
const pagedSource = pcap(
|
||||
1,
|
||||
Array.from({ length: 120 }, () =>
|
||||
udp(5555, Buffer.from("owned paging fixture")),
|
||||
),
|
||||
);
|
||||
await writeFile(pagedPath, pagedSource);
|
||||
const page = await inspect({ path: pagedPath, fields: ["ip.addr"] });
|
||||
assert.equal(page.packets.length, 50);
|
||||
assert.deepEqual(page.output_window, {
|
||||
matching_packets: 120,
|
||||
returned_packets: 50,
|
||||
has_more: true,
|
||||
});
|
||||
const nextPage = await inspect({
|
||||
path: pagedPath,
|
||||
fields: ["ip.addr"],
|
||||
match_offset: 50,
|
||||
match_limit: 40,
|
||||
});
|
||||
assert.deepEqual(nextPage.packets[0]["frame.number"], ["51"]);
|
||||
assert.deepEqual(nextPage.packets.at(-1)["frame.number"], ["90"]);
|
||||
const complete = await inspect({
|
||||
path: pagedPath,
|
||||
fields: ["ip.addr"],
|
||||
match_limit: null,
|
||||
});
|
||||
assert.equal(complete.packets.length, 120);
|
||||
assert.equal(complete.output_window.has_more, false);
|
||||
assert.deepEqual(await readFile(pagedPath), pagedSource);
|
||||
const hci = await inspect({ path: bluetooth, fields: ["bthci_cmd.opcode"] });
|
||||
assert.deepEqual(hci.packets[0]["bthci_cmd.opcode"], ["0x0c03"]);
|
||||
assert.deepEqual(await readFile(path), source);
|
||||
assert.deepEqual(await readFile(bluetooth), bluetoothSource);
|
||||
for (const input of [
|
||||
{ path, fields: ["frame.number"], display_filter: "this is not a filter" },
|
||||
{ path, fields: ["no_such_field"] },
|
||||
{
|
||||
path,
|
||||
fields: ["frame.number"],
|
||||
decode_as: ["no_such_protocol==1,unknown"],
|
||||
},
|
||||
{ path: join(root.path, "absent.pcap"), fields: ["frame.number"] },
|
||||
{ path, fields: ["frame.number"], interface: "lo0" },
|
||||
]) {
|
||||
const response = await client.callTool({
|
||||
name: tool.name,
|
||||
arguments: input,
|
||||
});
|
||||
assert.equal(response.isError, true);
|
||||
await client.ping();
|
||||
cases++;
|
||||
}
|
||||
await writeFile(path, "not a capture");
|
||||
assert.equal(
|
||||
(
|
||||
await client.callTool({
|
||||
name: tool.name,
|
||||
arguments: { path, fields: ["frame.number"] },
|
||||
})
|
||||
).isError,
|
||||
true,
|
||||
);
|
||||
cases++;
|
||||
await client.close();
|
||||
assert.deepEqual((await readdir(root.path)).sort(), [
|
||||
"bluetooth.pcap",
|
||||
"network with spaces.pcap",
|
||||
"paged.pcap",
|
||||
]);
|
||||
} finally {
|
||||
await client.close();
|
||||
await transport.close();
|
||||
await root.close();
|
||||
}
|
||||
console.log(
|
||||
JSON.stringify(
|
||||
{
|
||||
status: "passed",
|
||||
cases,
|
||||
host: `${process.platform}/${process.arch}`,
|
||||
scope:
|
||||
"real TShark CLI/MCP; synthetic Ethernet/IPv4/UDP/DNS and Bluetooth HCI PCAP; no hardware acquisition",
|
||||
...(await completeVerifierRun(run)),
|
||||
},
|
||||
null,
|
||||
2,
|
||||
),
|
||||
);
|
||||
@@ -4,7 +4,11 @@ import { join } from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
|
||||
import { PlaywrightElectronActiveProvider } from "../dist/browser/PlaywrightElectronActiveProvider.js";
|
||||
import { electronActiveObservationInputSchema } from "../dist/domain/javascript/electronActiveObservation.js";
|
||||
import { captureElectronScenario } from "../dist/application/javascript/ElectronActiveObservationService.js";
|
||||
import {
|
||||
electronActiveObservationInputSchema,
|
||||
electronActiveObservationResultSchema,
|
||||
} from "../dist/domain/javascript/electronActiveObservation.js";
|
||||
import { completeVerifierRun, createVerifierRun } from "./lib/verifier-run.mjs";
|
||||
import { verifyElectronToolContracts } from "./verify/electron/tool-contracts.mjs";
|
||||
|
||||
@@ -50,61 +54,65 @@ const input = electronActiveObservationInputSchema.parse({
|
||||
],
|
||||
});
|
||||
const verifierRun = createVerifierRun();
|
||||
const result = await new PlaywrightElectronActiveProvider(process.env).capture(
|
||||
const result = await captureElectronScenario(
|
||||
new PlaywrightElectronActiveProvider(process.env),
|
||||
input,
|
||||
);
|
||||
if (!result.ok) throw result.error;
|
||||
const capture = electronActiveObservationResultSchema.parse(
|
||||
result.value.normalized_result,
|
||||
);
|
||||
|
||||
const output = {
|
||||
verifier_run: await completeVerifierRun(verifierRun),
|
||||
electron: result.value.application,
|
||||
actions: result.value.actions,
|
||||
processes: result.value.processes,
|
||||
ipc: result.value.ipc,
|
||||
timeline: result.value.timeline,
|
||||
windows: result.value.windows,
|
||||
electron: capture.application,
|
||||
actions: capture.actions,
|
||||
processes: capture.processes,
|
||||
ipc: capture.ipc,
|
||||
timeline: capture.timeline,
|
||||
windows: capture.windows,
|
||||
verified:
|
||||
result.value.coverage.status === "partial_attach" &&
|
||||
result.value.actions.every(({ status }) => status === "completed") &&
|
||||
result.value.actions.some(
|
||||
capture.coverage.status === "partial_attach" &&
|
||||
capture.actions.every(({ status }) => status === "completed") &&
|
||||
capture.actions.some(
|
||||
({ kind, window_index }) =>
|
||||
kind === "renderer-reload" && window_index === 1,
|
||||
) &&
|
||||
result.value.actions.some(
|
||||
capture.actions.some(
|
||||
({ kind, window_index }) =>
|
||||
kind === "renderer-crash" && window_index === 1,
|
||||
) &&
|
||||
result.value.windows.length >= 2 &&
|
||||
result.value.ipc.events.some(
|
||||
capture.windows.length >= 2 &&
|
||||
capture.ipc.events.some(
|
||||
({ kind, channel }) =>
|
||||
kind === "main-handler-invocation" && channel === "readiness:echo",
|
||||
) &&
|
||||
result.value.timeline.events.some(
|
||||
capture.timeline.events.some(
|
||||
({ kind, event, phase }) =>
|
||||
kind === "window-lifecycle" &&
|
||||
event === "created" &&
|
||||
phase === "completed",
|
||||
) &&
|
||||
result.value.timeline.events.some(
|
||||
capture.timeline.events.some(
|
||||
({ kind, event }) =>
|
||||
kind === "process-lifecycle" && event === "utility-process-fork",
|
||||
) &&
|
||||
result.value.timeline.events.some(
|
||||
capture.timeline.events.some(
|
||||
({ kind, event, phase }) =>
|
||||
kind === "shell-attempt" &&
|
||||
event === "openExternal" &&
|
||||
phase === "blocked",
|
||||
) &&
|
||||
result.value.timeline.events.some(
|
||||
capture.timeline.events.some(
|
||||
({ kind, event, phase }) =>
|
||||
kind === "preload" && event === "configured" && phase === "completed",
|
||||
) &&
|
||||
result.value.timeline.events.some(
|
||||
capture.timeline.events.some(
|
||||
({ kind, event }) =>
|
||||
kind === "protocol" &&
|
||||
(event === "open-url" || event === "second-instance"),
|
||||
) &&
|
||||
result.value.timeline.events.some(
|
||||
capture.timeline.events.some(
|
||||
({ kind, event }) =>
|
||||
kind === "process-lifecycle" && event === "child.spawn",
|
||||
),
|
||||
|
||||
@@ -124,9 +124,7 @@ async function verifyFixture(byteOrder, kernelModule) {
|
||||
});
|
||||
const call = async (name, args = {}) =>
|
||||
requireMcpOperationResult(
|
||||
await client.callTool({ name, arguments: args }, undefined, {
|
||||
timeout: 180000,
|
||||
}),
|
||||
await client.callTool({ name, arguments: args }, { timeout: 180000 }),
|
||||
name,
|
||||
);
|
||||
try {
|
||||
|
||||
@@ -171,7 +171,6 @@ try {
|
||||
const call = async (name, args = {}) => {
|
||||
const reply = await client.callTool(
|
||||
{ name, arguments: args },
|
||||
undefined,
|
||||
{ timeout: 180000 },
|
||||
);
|
||||
return requireMcpOperationResult(reply, name);
|
||||
@@ -184,7 +183,6 @@ try {
|
||||
name: "open_binary",
|
||||
arguments: { path: fixture.path, provider_id: "ghidra" },
|
||||
},
|
||||
undefined,
|
||||
{ timeout: 60000 },
|
||||
);
|
||||
const error = requireMcpToolError(rejected);
|
||||
@@ -423,7 +421,6 @@ try {
|
||||
snapshot_path: snapshotPath,
|
||||
},
|
||||
},
|
||||
undefined,
|
||||
{ timeout: 180000 },
|
||||
);
|
||||
requireMcpToolError(wrongSnapshot);
|
||||
|
||||
@@ -0,0 +1,391 @@
|
||||
#!/usr/bin/env node
|
||||
import assert from "node:assert/strict";
|
||||
import { execFile } from "node:child_process";
|
||||
import { createHash } from "node:crypto";
|
||||
import {
|
||||
mkdtemp,
|
||||
mkdir,
|
||||
readFile,
|
||||
readdir,
|
||||
rm,
|
||||
writeFile,
|
||||
} from "node:fs/promises";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import { promisify } from "node:util";
|
||||
import { Client } from "@modelcontextprotocol/client";
|
||||
import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
|
||||
import Ajv from "ajv/dist/2020.js";
|
||||
import addFormats from "ajv-formats";
|
||||
import { parseBinaryTarget } from "../dist/application/BinaryTargetResolver.js";
|
||||
import { parseAnalysisSnapshot } from "../dist/domain/analysisSnapshot.js";
|
||||
import { parseEvidence } from "../dist/domain/evidence.js";
|
||||
import { functionDossierSchema } from "../dist/domain/hopperValues.js";
|
||||
import { inspectGhidraInstallation } from "../dist/ghidra/GhidraInstallation.js";
|
||||
import { buildRiscvFixture } from "../tests/conformance/ghidra/riscv-fixture.mjs";
|
||||
import {
|
||||
mcpTextValue,
|
||||
requireMcpOperationResult,
|
||||
requireMcpToolError,
|
||||
} from "./lib/mcp-verifier-results.mjs";
|
||||
import { createVerifierRun, completeVerifierRun } from "./lib/verifier-run.mjs";
|
||||
|
||||
if (process.argv.length !== 2)
|
||||
throw new Error("Usage: node scripts/verify-real-ghidra-riscv.mjs");
|
||||
if (!["linux", "darwin"].includes(process.platform))
|
||||
throw new Error("This optional lane requires a Linux/macOS Ghidra host.");
|
||||
if (process.env.GHIDRA_INSTALL_DIR === undefined)
|
||||
throw new Error("Missing prerequisite: caller-supplied GHIDRA_INSTALL_DIR");
|
||||
for (const key of ["REA_GHIDRA_LANGUAGE_ID", "REA_GHIDRA_COMPILER_SPEC_ID"])
|
||||
if (process.env[key] !== undefined)
|
||||
throw new Error(
|
||||
`Unset ${key}: this lane verifies provider-pinned selection.`,
|
||||
);
|
||||
const installation = inspectGhidraInstallation({
|
||||
environment: process.env,
|
||||
installDir: process.env.GHIDRA_INSTALL_DIR,
|
||||
...(process.env.JAVA_HOME === undefined
|
||||
? {}
|
||||
: { javaHome: process.env.JAVA_HOME }),
|
||||
});
|
||||
assert.equal(installation.status, "available", JSON.stringify(installation));
|
||||
assert.equal(installation.providerVersion, "12.1.4");
|
||||
|
||||
const execute = promisify(execFile);
|
||||
const entrypoint = fileURLToPath(new URL("./rea.mjs", import.meta.url));
|
||||
const run = createVerifierRun();
|
||||
const workspace = await mkdtemp(join(tmpdir(), "rea-riscv-proof-"));
|
||||
const runtime = join(workspace, "runtime");
|
||||
await mkdir(runtime);
|
||||
const env = {
|
||||
PATH: process.env.PATH ?? "/usr/bin:/bin",
|
||||
TMPDIR: runtime,
|
||||
REA_LOG_LEVEL: "silent",
|
||||
REA_ANALYSIS_PROVIDER: "ghidra",
|
||||
REA_PROCESS_RUN_ID: run.run_id,
|
||||
GHIDRA_INSTALL_DIR: installation.installDir,
|
||||
JAVA_HOME: installation.javaHome,
|
||||
};
|
||||
for (const key of ["GHIDRA_HEADLESS_MAXMEM", "GHIDRA_MAXMEM"])
|
||||
if (process.env[key] !== undefined) env[key] = process.env[key];
|
||||
const transport = new StdioClientTransport({
|
||||
command: process.execPath,
|
||||
args: [entrypoint, "mcp"],
|
||||
env,
|
||||
stderr: "pipe",
|
||||
});
|
||||
const client = new Client({ name: "rea-real-riscv-proof", version: "1" });
|
||||
let stderr = "";
|
||||
transport.stderr?.on("data", (chunk) => {
|
||||
stderr = (stderr + chunk.toString()).slice(-65536);
|
||||
});
|
||||
|
||||
const reports = [];
|
||||
let failure;
|
||||
try {
|
||||
await client.connect(transport);
|
||||
const catalog = await client.listTools();
|
||||
const ajv = new Ajv({ strict: false });
|
||||
addFormats(ajv);
|
||||
const validators = new Map();
|
||||
for (const tool of catalog.tools) {
|
||||
assert.ok(
|
||||
ajv.validateSchema(tool.outputSchema),
|
||||
`${tool.name}: invalid output schema`,
|
||||
);
|
||||
const existing =
|
||||
typeof tool.outputSchema.$id === "string"
|
||||
? ajv.getSchema(tool.outputSchema.$id)
|
||||
: undefined;
|
||||
validators.set(tool.name, existing ?? ajv.compile(tool.outputSchema));
|
||||
}
|
||||
for (const bits of [32, 64]) {
|
||||
const fixture = await buildRiscvFixture(workspace, bits);
|
||||
const resolved = await parseBinaryTarget(fixture.path);
|
||||
if (!resolved.ok) throw resolved.error;
|
||||
assert.equal(resolved.value.architecture, "riscv");
|
||||
assert.equal(resolved.value.sha256, fixture.sha256);
|
||||
assert.deepEqual(resolved.value.riscv, fixture.riscv);
|
||||
const expectedLanguage = `RISCV:LE:${bits}:default`;
|
||||
const assertProfile = (profile) => {
|
||||
assert.equal(profile.provider.id, "ghidra");
|
||||
assert.equal(profile.provider.version, installation.providerVersion);
|
||||
const parameters = profile.parameters;
|
||||
assert.equal(parameters.language_id, expectedLanguage);
|
||||
assert.equal(parameters.compiler_spec_id, "gcc");
|
||||
assert.equal(parameters.language_selection, "provider-pinned-v1");
|
||||
assert.equal(
|
||||
parameters.riscv_support_lane,
|
||||
`elf${bits}-exec-le-double-float-generic-v1`,
|
||||
);
|
||||
assert.deepEqual(parameters.riscv_elf, {
|
||||
elf_class: bits,
|
||||
byte_order: "little",
|
||||
type: 2,
|
||||
flags: 5,
|
||||
float_abi_double: true,
|
||||
rvc_declared: true,
|
||||
rve_declared: false,
|
||||
tso_declared: false,
|
||||
});
|
||||
};
|
||||
const assertEvidence = (evidence) => {
|
||||
assert.equal(evidence.provider.id, "ghidra");
|
||||
assert.equal(evidence.subject.architecture, "riscv");
|
||||
assert.equal(evidence.subject.digest.sha256, fixture.sha256);
|
||||
assertProfile(evidence.analysis_profile);
|
||||
};
|
||||
const call = async (name, args = {}) => {
|
||||
const reply = await client.callTool(
|
||||
{ name, arguments: args },
|
||||
{ timeout: 240000 },
|
||||
);
|
||||
const projected = requireMcpOperationResult(reply, name);
|
||||
const textual = JSON.parse(mcpTextValue(reply));
|
||||
assert.deepEqual(reply.structuredContent, textual);
|
||||
const validate = validators.get(name);
|
||||
assert.ok(validate, `${name} missing from advertised catalog`);
|
||||
assert.ok(
|
||||
validate(textual),
|
||||
`${name}: ${JSON.stringify(validate.errors)}`,
|
||||
);
|
||||
if (!["open_binary", "close_binary", "binary_session"].includes(name))
|
||||
assertEvidence(parseEvidence(textual));
|
||||
return projected;
|
||||
};
|
||||
const opened = await call("open_binary", {
|
||||
path: fixture.path,
|
||||
provider_id: "ghidra",
|
||||
});
|
||||
assert.equal(opened.architecture, "riscv");
|
||||
assert.equal(opened.sha256, fixture.sha256);
|
||||
const image = await call("inspect_native_load_image");
|
||||
assert.equal(image.observations.language_id, expectedLanguage);
|
||||
assert.equal(image.observations.compiler_spec_id, "gcc");
|
||||
assert.ok(image.observations.source_files.length > 0);
|
||||
for (const source of image.observations.source_files) {
|
||||
assert.equal(source.original_sha256, fixture.sha256);
|
||||
assert.equal(source.modified_sha256, fixture.sha256);
|
||||
}
|
||||
const procedures = await call("list_procedures");
|
||||
for (const name of [
|
||||
"rea_riscv_entry",
|
||||
"rea_riscv_leaf",
|
||||
"rea_riscv_float",
|
||||
"rea_riscv_probe",
|
||||
]) {
|
||||
const procedure = procedures.find((value) => value.value === name);
|
||||
assert.ok(procedure, `${name} missing from Ghidra inventory`);
|
||||
assert.equal(BigInt(procedure.address), BigInt(fixture.symbols[name]));
|
||||
}
|
||||
const probe = await call("inspect_native_instruction", {
|
||||
address: fixture.symbols.rea_riscv_probe,
|
||||
});
|
||||
assert.equal(probe.status, "decoded");
|
||||
assert.equal(probe.architecture, expectedLanguage);
|
||||
assert.equal(probe.length, 4);
|
||||
assert.equal(probe.bytes, "13051501"); // addi a0, a0, 17
|
||||
const mapping = await call("address_to_file_offset", {
|
||||
address: fixture.symbols.rea_riscv_probe,
|
||||
});
|
||||
const sourceBytes = await readFile(fixture.path);
|
||||
assert.equal(
|
||||
sourceBytes
|
||||
.subarray(mapping.file_offset, mapping.file_offset + 4)
|
||||
.toString("hex"),
|
||||
probe.bytes,
|
||||
);
|
||||
const global = await call("read_bytes", {
|
||||
address: fixture.symbols.rea_riscv_global,
|
||||
length: 4,
|
||||
});
|
||||
assert.equal(global.bytes_hex, "07000000");
|
||||
const callees = await call("procedure_callees", {
|
||||
procedure: fixture.symbols.rea_riscv_entry,
|
||||
});
|
||||
for (const name of ["rea_riscv_leaf", "rea_riscv_probe"])
|
||||
assert.ok(
|
||||
callees.some(
|
||||
(address) => BigInt(address) === BigInt(fixture.symbols[name]),
|
||||
),
|
||||
);
|
||||
const dossier = functionDossierSchema.parse(
|
||||
await call("analyze_function", {
|
||||
procedure: fixture.symbols.rea_riscv_entry,
|
||||
}),
|
||||
);
|
||||
assert.ok(dossier.pseudocode.trim().length > 0);
|
||||
const floatCode = await call("procedure_pseudo_code", {
|
||||
procedure: fixture.symbols.rea_riscv_float,
|
||||
});
|
||||
assert.ok(typeof floatCode === "string" && floatCode.trim().length > 0);
|
||||
assert.match(floatCode, /\bdouble\b/u);
|
||||
|
||||
const refusals = [];
|
||||
for (const [flags, reason] of [
|
||||
[1, "EF_RISCV_FLOAT_ABI_DOUBLE"],
|
||||
[0x80000005, "(0x80000000)"],
|
||||
]) {
|
||||
// Header-mutated copies test admission; they are not new compiler claims.
|
||||
const rejectedPath = join(
|
||||
workspace,
|
||||
`rv${bits}-flags-${flags.toString(16)}.elf`,
|
||||
);
|
||||
const rejectedBytes = Buffer.from(sourceBytes);
|
||||
rejectedBytes.writeUInt32LE(flags, bits === 32 ? 36 : 48);
|
||||
await writeFile(rejectedPath, rejectedBytes);
|
||||
const reply = await client.callTool(
|
||||
{
|
||||
name: "open_binary",
|
||||
arguments: { path: rejectedPath, provider_id: "ghidra" },
|
||||
},
|
||||
{ timeout: 60000 },
|
||||
);
|
||||
const error = requireMcpToolError(reply);
|
||||
assert.ok(JSON.stringify(error).includes(reason), JSON.stringify(error));
|
||||
await assert.rejects(
|
||||
execute(
|
||||
process.execPath,
|
||||
[
|
||||
entrypoint,
|
||||
"function",
|
||||
rejectedPath,
|
||||
"rea_riscv_entry",
|
||||
"--provider",
|
||||
"ghidra",
|
||||
"--json",
|
||||
],
|
||||
{
|
||||
env,
|
||||
timeout: 60000,
|
||||
maxBuffer: 1024 * 1024,
|
||||
},
|
||||
),
|
||||
(cause) =>
|
||||
Number.isInteger(cause.code) &&
|
||||
cause.code !== 0 &&
|
||||
`${cause.stdout}\n${cause.stderr}`.includes(reason),
|
||||
);
|
||||
refusals.push({ flags, reason });
|
||||
}
|
||||
const snapshotPath = join(workspace, `rv${bits}.snapshot.json`);
|
||||
const saved = await call("close_binary", { snapshot_path: snapshotPath });
|
||||
assert.ok(saved.evidence_records > 0);
|
||||
const snapshot = parseAnalysisSnapshot(
|
||||
JSON.parse(await readFile(snapshotPath, "utf8")),
|
||||
);
|
||||
assert.equal(snapshot.target.architecture, "riscv");
|
||||
assert.equal(snapshot.target.sha256, fixture.sha256);
|
||||
assertProfile(snapshot.binding.analysis_profile);
|
||||
for (const record of snapshot.evidence_bundle.records)
|
||||
assertEvidence(parseEvidence(record));
|
||||
await call("open_binary", {
|
||||
path: fixture.path,
|
||||
provider_id: "ghidra",
|
||||
snapshot_path: snapshotPath,
|
||||
});
|
||||
assert.deepEqual(await call("list_procedures"), procedures);
|
||||
await call("close_binary");
|
||||
|
||||
for (const [command, arguments_] of [
|
||||
["search", ["rea_riscv_", "--kind", "procedures"]],
|
||||
["function", ["rea_riscv_entry"]],
|
||||
]) {
|
||||
const cli = await execute(
|
||||
process.execPath,
|
||||
[
|
||||
entrypoint,
|
||||
command,
|
||||
fixture.path,
|
||||
...arguments_,
|
||||
"--provider",
|
||||
"ghidra",
|
||||
"--json",
|
||||
],
|
||||
{ env, timeout: 240000, maxBuffer: 16 * 1024 * 1024 },
|
||||
);
|
||||
const evidence = parseEvidence(JSON.parse(cli.stdout));
|
||||
assertEvidence(evidence);
|
||||
if (command === "search")
|
||||
for (const name of [
|
||||
"rea_riscv_entry",
|
||||
"rea_riscv_leaf",
|
||||
"rea_riscv_float",
|
||||
"rea_riscv_probe",
|
||||
])
|
||||
assert.ok(
|
||||
evidence.normalized_result.some((value) => value.value === name),
|
||||
);
|
||||
else {
|
||||
const cliDossier = functionDossierSchema.parse(
|
||||
evidence.normalized_result,
|
||||
);
|
||||
assert.equal(cliDossier.procedure.address, dossier.procedure.address);
|
||||
assert.ok(cliDossier.pseudocode.trim().length > 0);
|
||||
}
|
||||
}
|
||||
assert.equal(
|
||||
createHash("sha256")
|
||||
.update(await readFile(fixture.path))
|
||||
.digest("hex"),
|
||||
fixture.sha256,
|
||||
);
|
||||
reports.push({
|
||||
...fixture,
|
||||
language: expectedLanguage,
|
||||
procedures: procedures.length,
|
||||
refusals,
|
||||
cli: true,
|
||||
stdio_mcp: true,
|
||||
snapshot_replay: true,
|
||||
original_unchanged: true,
|
||||
});
|
||||
}
|
||||
} catch (cause) {
|
||||
failure = cause;
|
||||
}
|
||||
for (const close of [() => client.close(), () => transport.close()]) {
|
||||
try {
|
||||
await close();
|
||||
} catch (cause) {
|
||||
failure = new AggregateError(
|
||||
failure === undefined ? [cause] : [failure, cause],
|
||||
"Verification or cleanup failed",
|
||||
);
|
||||
}
|
||||
}
|
||||
const completed = await completeVerifierRun(run);
|
||||
if (
|
||||
completed.process_lineage.status !== "verified" ||
|
||||
completed.process_lineage.descendants.length !== 0
|
||||
)
|
||||
throw new Error(`Cleanup unverified; retained workspace: ${workspace}`, {
|
||||
cause: failure,
|
||||
});
|
||||
if (failure !== undefined)
|
||||
throw new Error(
|
||||
`RISC-V verification failed; retained workspace: ${workspace}; MCP stderr: ${stderr}`,
|
||||
{ cause: failure },
|
||||
);
|
||||
assert.deepEqual(
|
||||
await readdir(runtime),
|
||||
[],
|
||||
`Runtime resources survived server shutdown; retained workspace: ${workspace}`,
|
||||
);
|
||||
await rm(workspace, { recursive: true, force: true });
|
||||
console.log(
|
||||
JSON.stringify(
|
||||
{
|
||||
verifier_run: completed,
|
||||
lane: "ghidra-riscv",
|
||||
mocked: false,
|
||||
host: { platform: process.platform, architecture: process.arch },
|
||||
provider: { id: "ghidra", version: installation.providerVersion },
|
||||
fixtures: reports,
|
||||
cleanup: "complete",
|
||||
},
|
||||
null,
|
||||
2,
|
||||
),
|
||||
);
|
||||
+148
-6
@@ -16,6 +16,10 @@ const { values } = parseArgs({
|
||||
options: {
|
||||
target: { type: "string" },
|
||||
procedure: { type: "string", default: "rea_fixture_add" },
|
||||
"second-procedure": { type: "string" },
|
||||
"second-marker": { type: "string" },
|
||||
"expected-string": { type: "string" },
|
||||
"expected-xref": { type: "string" },
|
||||
"package-root": { type: "string" },
|
||||
report: { type: "string" },
|
||||
},
|
||||
@@ -24,6 +28,16 @@ if (values.target === undefined || process.env.REA_IDA_MCP_CONFIG === undefined)
|
||||
throw new Error(
|
||||
"IDA verification requires --target and REA_IDA_MCP_CONFIG; see docs/ida-provider.md. No toolchain is installed by this lane.",
|
||||
);
|
||||
if (
|
||||
(values["second-procedure"] === undefined) !==
|
||||
(values["second-marker"] === undefined) ||
|
||||
values["second-marker"] === ""
|
||||
)
|
||||
throw new Error(
|
||||
"IDA verification requires --second-procedure and a nonempty --second-marker together; choose a marker unique to the second function's pseudocode.",
|
||||
);
|
||||
if (values["expected-string"] === "" || values["expected-xref"] === "")
|
||||
throw new Error("IDA verification oracles must be nonempty.");
|
||||
const packageRoot = resolve(
|
||||
values["package-root"] ?? fileURLToPath(new URL("..", import.meta.url)),
|
||||
);
|
||||
@@ -37,16 +51,26 @@ const [
|
||||
{ functionDossierSchema },
|
||||
{ readIdaConfiguration },
|
||||
{ createIdaMcpConnection },
|
||||
{ idaAddressSchema },
|
||||
] = await Promise.all([
|
||||
importBuilt("contracts/toolContracts.js"),
|
||||
importBuilt("domain/evidence.js"),
|
||||
importBuilt("domain/hopperValues.js"),
|
||||
importBuilt("ida/IdaConfiguration.js"),
|
||||
importBuilt("ida/IdaMcpConnection.js"),
|
||||
importBuilt("ida/IdaProtocolValues.js"),
|
||||
]);
|
||||
const registration = readIdaConfiguration(process.env.REA_IDA_MCP_CONFIG);
|
||||
if (!registration.ok) throw registration.error;
|
||||
const config = registration.value;
|
||||
if (
|
||||
config.protocol === "native" &&
|
||||
(values["second-procedure"] === undefined ||
|
||||
values["second-marker"] === undefined)
|
||||
)
|
||||
throw new Error(
|
||||
"Native IDA verification requires --second-procedure and --second-marker to verify distinct-function switching; see docs/ida-provider.md.",
|
||||
);
|
||||
const environment = Object.fromEntries(
|
||||
Object.entries({
|
||||
...process.env,
|
||||
@@ -57,9 +81,16 @@ const environment = Object.fromEntries(
|
||||
const report = {
|
||||
passed: false,
|
||||
mode: config.mode,
|
||||
protocol:
|
||||
config.protocol ?? (config.mode === "attached" ? "legacy" : "modern"),
|
||||
checks: [],
|
||||
observations: [],
|
||||
unverified: [],
|
||||
};
|
||||
const expectedXref =
|
||||
values["expected-xref"] === undefined
|
||||
? undefined
|
||||
: idaAddressSchema.parse(values["expected-xref"]);
|
||||
let phase = "target admission";
|
||||
const workspaces = new Set();
|
||||
const databases = new Set();
|
||||
@@ -75,6 +106,8 @@ const observe = (input) => {
|
||||
assert.equal(evidence.analysis_profile.parameters.cache_policy, "live");
|
||||
assert.equal(evidence.analysis_profile.parameters.engine_version, null);
|
||||
assert.ok(evidence.limitations.length > 0);
|
||||
if (config.protocol === "native" && evidence.operation === "analyze_function")
|
||||
assert.equal(evidence.relationship_coverage?.status, "unknown");
|
||||
assert.ok(
|
||||
evidence.locations.some((location) => location.kind === "artifact-path"),
|
||||
);
|
||||
@@ -156,17 +189,122 @@ const mcp = async (cliDossier) => {
|
||||
["procedure_address", { procedure: dossier.procedure.name }],
|
||||
["procedure_assembly", { procedure: dossier.procedure.address }],
|
||||
["procedure_callees", { procedure: dossier.procedure.address }],
|
||||
...(config.mode === "attached"
|
||||
...(config.mode === "attached" && config.protocol !== "native"
|
||||
? [["procedure_callers", { procedure: dossier.procedure.address }]]
|
||||
: []),
|
||||
["search_procedures", { pattern: dossier.procedure.name }],
|
||||
["procedure_pseudo_code", { procedure: dossier.procedure.address }],
|
||||
["read_function_instructions", { procedure: dossier.procedure.address }],
|
||||
["search_strings", { pattern: "a.b", mode: "literal" }],
|
||||
[
|
||||
"search_strings",
|
||||
{
|
||||
pattern: values["expected-string"] ?? "a.b",
|
||||
mode: "literal",
|
||||
case_sensitive: true,
|
||||
},
|
||||
],
|
||||
["xrefs", { address: dossier.procedure.address }],
|
||||
]) {
|
||||
const result = await call(name, args);
|
||||
observe(result);
|
||||
const value = observe(result);
|
||||
switch (name) {
|
||||
case "list_procedures":
|
||||
case "search_procedures":
|
||||
assert.ok(
|
||||
value.some(
|
||||
(item) =>
|
||||
item.address === dossier.procedure.address &&
|
||||
item.value === dossier.procedure.name,
|
||||
),
|
||||
`${name} omitted the resolved procedure.`,
|
||||
);
|
||||
break;
|
||||
case "procedure_address":
|
||||
assert.equal(value, dossier.procedure.address);
|
||||
break;
|
||||
case "procedure_assembly":
|
||||
assert.equal(value, dossier.assembly.join("\n"));
|
||||
break;
|
||||
case "procedure_pseudo_code":
|
||||
assert.equal(value, dossier.pseudocode);
|
||||
break;
|
||||
case "procedure_callers":
|
||||
case "procedure_callees": {
|
||||
const expected =
|
||||
name === "procedure_callers" ? dossier.callers : dossier.callees;
|
||||
assert.deepEqual(
|
||||
[...value].sort(),
|
||||
expected.map((item) => item.address).sort(),
|
||||
);
|
||||
break;
|
||||
}
|
||||
case "read_function_instructions":
|
||||
assert.deepEqual(value.procedure.address, dossier.procedure.address);
|
||||
assert.deepEqual(value.instructions, dossier.assembly);
|
||||
break;
|
||||
case "list_strings":
|
||||
case "search_strings":
|
||||
if (values["expected-string"] !== undefined)
|
||||
assert.ok(
|
||||
value.some((item) =>
|
||||
item.value.includes(values["expected-string"]),
|
||||
),
|
||||
`${name} omitted the expected literal.`,
|
||||
);
|
||||
break;
|
||||
case "xrefs":
|
||||
if (expectedXref !== undefined)
|
||||
assert.ok(
|
||||
value.includes(expectedXref),
|
||||
"xrefs omitted the expected source address.",
|
||||
);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (values["expected-string"] === undefined)
|
||||
report.unverified.push(
|
||||
"String inventory/search correctness: no independent expected literal supplied.",
|
||||
);
|
||||
else
|
||||
report.checks.push(
|
||||
"string inventory and literal search contain the expected literal",
|
||||
);
|
||||
if (expectedXref === undefined)
|
||||
report.unverified.push(
|
||||
"Xref correctness: no independent expected source address supplied.",
|
||||
);
|
||||
else report.checks.push("xrefs contain the expected source address");
|
||||
if (values["second-procedure"] !== undefined) {
|
||||
const secondAddress = observe(
|
||||
await call("procedure_address", {
|
||||
procedure: values["second-procedure"],
|
||||
}),
|
||||
);
|
||||
assert.notEqual(secondAddress, dossier.procedure.address);
|
||||
const secondCode = observe(
|
||||
await call("procedure_pseudo_code", {
|
||||
procedure: values["second-procedure"],
|
||||
}),
|
||||
);
|
||||
assert.equal(typeof secondCode, "string");
|
||||
assert.ok(secondCode.length > 0);
|
||||
assert.ok(
|
||||
!dossier.pseudocode.includes(values["second-marker"]),
|
||||
"The second marker also appears in the first function's pseudocode.",
|
||||
);
|
||||
assert.ok(
|
||||
secondCode.includes(values["second-marker"]),
|
||||
"The second function's pseudocode omitted its expected marker.",
|
||||
);
|
||||
const restored = observe(
|
||||
await call("procedure_pseudo_code", {
|
||||
procedure: dossier.procedure.address,
|
||||
}),
|
||||
);
|
||||
assert.equal(restored, dossier.pseudocode);
|
||||
report.checks.push(
|
||||
"second-function pseudocode identity and return to the original function",
|
||||
);
|
||||
}
|
||||
const invalid = await client.callTool({
|
||||
name: "xrefs",
|
||||
@@ -177,10 +315,10 @@ const mcp = async (cliDossier) => {
|
||||
await call("close_binary", {});
|
||||
opened = false;
|
||||
report.checks.push(
|
||||
"one MCP connection, target selection, analysis/search/xrefs, invalid input, and close",
|
||||
"one MCP connection, positive procedure inventory/search, contract-valid tool results, invalid input, and close",
|
||||
);
|
||||
report.checks.push(
|
||||
"CLI/MCP function identity, pseudocode, assembly, and raw Evidence parity",
|
||||
"CLI/MCP function identity, pseudocode, assembly, instructions, and relationship parity",
|
||||
);
|
||||
} finally {
|
||||
const completedPhase = phase;
|
||||
@@ -195,7 +333,10 @@ const cleanup = async () => {
|
||||
try {
|
||||
await upstream.connect();
|
||||
if (config.mode === "attached") {
|
||||
const metadata = await upstream.call("get_metadata", {});
|
||||
const metadata =
|
||||
config.protocol === "native"
|
||||
? await upstream.readResource("ida://idb/metadata")
|
||||
: await upstream.call("get_metadata", {});
|
||||
assert.equal(metadata.sha256.toLowerCase(), await digest());
|
||||
report.checks.push(
|
||||
"existing GUI target remains open with the original input identity",
|
||||
@@ -243,6 +384,7 @@ try {
|
||||
passed: report.passed,
|
||||
mode: report.mode,
|
||||
checks: report.checks,
|
||||
unverified: report.unverified,
|
||||
...(report.passed
|
||||
? {}
|
||||
: {
|
||||
|
||||
@@ -0,0 +1,271 @@
|
||||
#!/usr/bin/env node
|
||||
import assert from "node:assert/strict";
|
||||
import { execFile } from "node:child_process";
|
||||
import { createHash } from "node:crypto";
|
||||
import { readFile, writeFile, readdir } from "node:fs/promises";
|
||||
import { isAbsolute, join } from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import { promisify } from "node:util";
|
||||
import { Client } from "@modelcontextprotocol/client";
|
||||
import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
|
||||
import { Ajv2020 } from "ajv/dist/2020.js";
|
||||
import { PrivateRuntimeRoot } from "../dist/process/PrivateRuntimeRoot.js";
|
||||
import { parseEvidence } from "../dist/domain/evidence.js";
|
||||
import { createVerifierRun, completeVerifierRun } from "./lib/verifier-run.mjs";
|
||||
|
||||
if (process.platform !== "linux")
|
||||
throw new Error(
|
||||
"Real signal verification requires Linux with util-linux prlimit.",
|
||||
);
|
||||
if (!isAbsolute(process.env.REA_SIGROK_COMMAND ?? ""))
|
||||
throw new Error(
|
||||
"Supply an absolute REA_SIGROK_COMMAND for sigrok-cli 0.7.2.",
|
||||
);
|
||||
const entrypoint =
|
||||
process.argv[2] ?? fileURLToPath(new URL("./rea.mjs", import.meta.url));
|
||||
const run = createVerifierRun();
|
||||
const root = await PrivateRuntimeRoot.create({
|
||||
prefix: "rea-signal-verifier-",
|
||||
});
|
||||
const path = join(root.path, "recording with spaces.vcd");
|
||||
const pagedPath = join(root.path, "paged.vcd");
|
||||
const execute = promisify(execFile);
|
||||
const environment = {
|
||||
...process.env,
|
||||
TMPDIR: root.path,
|
||||
TMP: root.path,
|
||||
TEMP: root.path,
|
||||
};
|
||||
const client = new Client({ name: "signal-recording-verifier", version: "1" });
|
||||
const transport = new StdioClientTransport({
|
||||
command: process.execPath,
|
||||
args: [entrypoint, "mcp"],
|
||||
env: environment,
|
||||
stderr: "pipe",
|
||||
});
|
||||
// Independently synthesize 9600-baud 8N1 samples at 1 MHz: bytes 52 45 41.
|
||||
const lines = [
|
||||
"$timescale 1 us $end",
|
||||
"$scope module logic $end",
|
||||
"$var wire 1 ! RX $end",
|
||||
"$upscope $end",
|
||||
"$enddefinitions $end",
|
||||
"#0",
|
||||
"1!",
|
||||
];
|
||||
let tick = 1000;
|
||||
for (const byte of Buffer.from("REA")) {
|
||||
for (const bit of [
|
||||
0,
|
||||
...Array.from({ length: 8 }, (_, i) => (byte >> i) & 1),
|
||||
1,
|
||||
]) {
|
||||
lines.push(`#${tick}`, `${bit}!`);
|
||||
tick += 104;
|
||||
}
|
||||
tick += 208;
|
||||
}
|
||||
lines.push(`#${tick + 1000}`, "1!");
|
||||
const source = lines.join("\n") + "\n";
|
||||
let cases = 0;
|
||||
try {
|
||||
await writeFile(path, source);
|
||||
await client.connect(transport);
|
||||
const advertised = (await client.listTools()).tools.find(
|
||||
({ name }) => name === "decode_signal_recording",
|
||||
);
|
||||
assert.ok(advertised?.outputSchema);
|
||||
const ajv = new Ajv2020({ strict: false, validateFormats: false });
|
||||
assert.ok(ajv.validateSchema(advertised.inputSchema));
|
||||
assert.ok(ajv.validateSchema(advertised.outputSchema));
|
||||
for (const extra of [
|
||||
{ input_format: "vcd", annotations: "uart=rx-data" },
|
||||
{},
|
||||
]) {
|
||||
const input = { path, decoders: "uart:rx=RX:baudrate=9600", ...extra };
|
||||
const response = await client.callTool({
|
||||
name: advertised.name,
|
||||
arguments: input,
|
||||
});
|
||||
assert.notEqual(response.isError, true, JSON.stringify(response));
|
||||
assert.ok(
|
||||
ajv.validate(advertised.outputSchema, response.structuredContent),
|
||||
JSON.stringify(ajv.errors),
|
||||
);
|
||||
const evidence = parseEvidence(response.structuredContent);
|
||||
const report = evidence.normalized_result;
|
||||
for (const byte of ["52", "45", "41"])
|
||||
assert.match(
|
||||
report.annotations_text,
|
||||
new RegExp(`\\d+-\\d+ uart-1: ${byte}\\n`),
|
||||
);
|
||||
assert.equal(
|
||||
report.artifact.sha256,
|
||||
createHash("sha256").update(source).digest("hex"),
|
||||
);
|
||||
assert.equal(report.hardware_acquisition, "not-performed");
|
||||
assert.equal(report.limits.address_space_bytes, 1073741824);
|
||||
assert.equal(report.tool.configured_path, process.env.REA_SIGROK_COMMAND);
|
||||
assert.equal(
|
||||
report.resource_limiter.configured_path,
|
||||
process.env.REA_SIGROK_PRLIMIT_COMMAND ?? "/usr/bin/prlimit",
|
||||
);
|
||||
assert.ok(
|
||||
report.resource_limiter.arguments.includes("--as=1073741824:1073741824"),
|
||||
);
|
||||
assert.equal(report.diagnostics, "");
|
||||
const flags = Object.entries(input)
|
||||
.filter(([key]) => key !== "path")
|
||||
.flatMap(([key, value]) => [`--${key}`, value]);
|
||||
const cli = JSON.parse(
|
||||
(
|
||||
await execute(
|
||||
process.execPath,
|
||||
[
|
||||
entrypoint,
|
||||
"decode-signal-recording",
|
||||
path,
|
||||
...flags,
|
||||
"--format",
|
||||
"json",
|
||||
],
|
||||
{ env: environment, timeout: 60000, maxBuffer: 16 * 1024 * 1024 },
|
||||
)
|
||||
).stdout,
|
||||
);
|
||||
assert.equal(parseEvidence(cli).evidence_id, evidence.evidence_id);
|
||||
const bundle = await client.callTool({
|
||||
name: "get_evidence_bundle",
|
||||
arguments: {},
|
||||
});
|
||||
assert.ok(JSON.stringify(bundle).includes(evidence.evidence_id));
|
||||
assert.equal(await readFile(path, "utf8"), source);
|
||||
cases++;
|
||||
}
|
||||
const pagedLines = lines.slice(0, 7);
|
||||
let pagedTick = 1000;
|
||||
for (const byte of Array.from({ length: 120 }, (_, i) => i)) {
|
||||
for (const bit of [
|
||||
0,
|
||||
...Array.from({ length: 8 }, (_, i) => (byte >> i) & 1),
|
||||
1,
|
||||
]) {
|
||||
pagedLines.push(`#${pagedTick}`, `${bit}!`);
|
||||
pagedTick += 104;
|
||||
}
|
||||
pagedTick += 208;
|
||||
}
|
||||
pagedLines.push(`#${pagedTick + 1000}`, "1!");
|
||||
const pagedSource = pagedLines.join("\n") + "\n";
|
||||
await writeFile(pagedPath, pagedSource);
|
||||
for (const [options, first, count] of [
|
||||
[{}, 0, 50],
|
||||
[{ line_offset: 50, line_limit: 40 }, 50, 40],
|
||||
[{ line_limit: null }, 0, 120],
|
||||
]) {
|
||||
const input = {
|
||||
path: pagedPath,
|
||||
decoders: "uart:rx=RX:baudrate=9600",
|
||||
input_format: "vcd",
|
||||
annotations: "uart=rx-data",
|
||||
...options,
|
||||
};
|
||||
const response = await client.callTool({
|
||||
name: advertised.name,
|
||||
arguments: input,
|
||||
});
|
||||
assert.notEqual(response.isError, true, JSON.stringify(response));
|
||||
assert.ok(
|
||||
ajv.validate(advertised.outputSchema, response.structuredContent),
|
||||
JSON.stringify(ajv.errors),
|
||||
);
|
||||
const evidence = parseEvidence(response.structuredContent);
|
||||
const report = evidence.normalized_result;
|
||||
assert.deepEqual(report.output_window, {
|
||||
total_lines: 120,
|
||||
returned_lines: count,
|
||||
has_more: first + count < 120,
|
||||
});
|
||||
const observed = report.annotations_text
|
||||
.trimEnd()
|
||||
.split("\n")
|
||||
.map((line) => {
|
||||
const match = /^\d+-\d+ uart-1: ([0-9A-F]{2})$/.exec(line);
|
||||
assert.ok(match, line);
|
||||
return Number.parseInt(match[1], 16);
|
||||
});
|
||||
assert.deepEqual(
|
||||
observed,
|
||||
Array.from({ length: count }, (_, i) => first + i),
|
||||
);
|
||||
const flags = Object.entries(input)
|
||||
.filter(([key]) => key !== "path")
|
||||
.flatMap(([key, value]) =>
|
||||
key === "line_limit" && value === null
|
||||
? ["--all_lines"]
|
||||
: [`--${key}`, String(value)],
|
||||
);
|
||||
const cli = JSON.parse(
|
||||
(
|
||||
await execute(
|
||||
process.execPath,
|
||||
[
|
||||
entrypoint,
|
||||
"decode-signal-recording",
|
||||
pagedPath,
|
||||
...flags,
|
||||
"--format",
|
||||
"json",
|
||||
],
|
||||
{ env: environment, timeout: 60000, maxBuffer: 16 * 1024 * 1024 },
|
||||
)
|
||||
).stdout,
|
||||
);
|
||||
assert.equal(parseEvidence(cli).evidence_id, evidence.evidence_id);
|
||||
assert.equal(await readFile(pagedPath, "utf8"), pagedSource);
|
||||
cases++;
|
||||
}
|
||||
for (const input of [
|
||||
{ path, decoders: "no_such_decoder" },
|
||||
{ path: join(root.path, "absent.vcd"), decoders: "uart" },
|
||||
{ path, decoders: "uart", driver: "demo" },
|
||||
]) {
|
||||
const response = await client.callTool({
|
||||
name: advertised.name,
|
||||
arguments: input,
|
||||
});
|
||||
assert.equal(response.isError, true);
|
||||
await client.ping();
|
||||
cases++;
|
||||
}
|
||||
await writeFile(path, "not a recording");
|
||||
const invalid = await client.callTool({
|
||||
name: advertised.name,
|
||||
arguments: { path, decoders: "uart" },
|
||||
});
|
||||
assert.equal(invalid.isError, true);
|
||||
cases++;
|
||||
await client.close();
|
||||
assert.deepEqual((await readdir(root.path)).sort(), [
|
||||
"paged.vcd",
|
||||
"recording with spaces.vcd",
|
||||
]);
|
||||
} finally {
|
||||
await client.close();
|
||||
await transport.close();
|
||||
await root.close();
|
||||
}
|
||||
console.log(
|
||||
JSON.stringify(
|
||||
{
|
||||
status: "passed",
|
||||
cases,
|
||||
host: `${process.platform}/${process.arch}`,
|
||||
scope:
|
||||
"real sigrok UART VCD through compiled CLI/MCP; no physical acquisition",
|
||||
...(await completeVerifierRun(run)),
|
||||
},
|
||||
null,
|
||||
2,
|
||||
),
|
||||
);
|
||||
@@ -236,6 +236,8 @@ try {
|
||||
await exec("/usr/bin/xcrun", [
|
||||
"swiftc",
|
||||
"-emit-library",
|
||||
"-module-name",
|
||||
"ReaWitnessFixture",
|
||||
"-O",
|
||||
...mode.flags
|
||||
.map((flag) => flag.replace(/^-Wl,/u, "-Xlinker\0"))
|
||||
|
||||
@@ -10,7 +10,7 @@ import { finished } from "node:stream/promises";
|
||||
|
||||
import { Cli } from "incur";
|
||||
|
||||
import { createStreamedCliJsonOutput } from "../../../dist/cli/streamedJsonOutput.js";
|
||||
import { createCliResultOutput } from "../../../dist/cli/cliResultOutput.js";
|
||||
import { createEvidence } from "../../../dist/domain/evidence.js";
|
||||
|
||||
// This opt-in format-boundary check writes one temporary file larger than the
|
||||
@@ -79,7 +79,7 @@ try {
|
||||
|
||||
destination = createWriteStream(path, { flags: "wx", mode: 0o600 });
|
||||
const argv = [metadata.command, "--format", format, "--full-output"];
|
||||
const output = createStreamedCliJsonOutput(argv, destination);
|
||||
const output = createCliResultOutput(argv, destination);
|
||||
assert.ok(output);
|
||||
let unexpectedOutputBytes = 0;
|
||||
let exitCode = 0;
|
||||
|
||||
@@ -41,9 +41,10 @@ const cli = async (...args) => {
|
||||
return parseEvidence(JSON.parse(stdout));
|
||||
};
|
||||
const call = async (name, args) => {
|
||||
const result = await client.callTool({ name, arguments: args }, undefined, {
|
||||
timeout: 150000,
|
||||
});
|
||||
const result = await client.callTool(
|
||||
{ name, arguments: args },
|
||||
{ timeout: 150000 },
|
||||
);
|
||||
assert.notEqual(result.isError, true, mcpTextValue(result));
|
||||
return parseEvidence(JSON.parse(mcpTextValue(result)));
|
||||
};
|
||||
|
||||
+1
-1
@@ -16,9 +16,9 @@ from urllib.parse import quote, urlsplit
|
||||
SITE_ORIGIN = "https://rea.tools"
|
||||
NOTES_FIXTURES = {"examples/notes-electron/index.html", "examples/notes-web/index.html"}
|
||||
NAVIGATION = (
|
||||
("Get started", "get-started/"),
|
||||
("Showcases", "showcase/"),
|
||||
("Blog", "blog/"),
|
||||
("Get started", "get-started/"),
|
||||
("Guides", "guides/"),
|
||||
("FAQ", "faq/"),
|
||||
)
|
||||
|
||||
Reference in New Issue
Block a user