Files
reverse-engineering-anything/scripts/lib/verify-package-core.mjs
T
morluto 5a2a08a048 perf(ci): split lazy runtime chunks, cache Windows typecheck, and reuse test analysis workers (#11827)
* perf(runtime): eliminate static imports that defeat lazy provider and workflow chunk splitting

* perf(ci): cache Windows typecheck in Turbo, bound official compiler checkers, and reuse portable build cache in reverse-tools

* perf(package): batch staging file copies and extract packed metadata in one pass

* perf(tests): reuse parked JavaScript analysis workers and eliminate redundant CLI and Node spawns

* fix(tests): retain failed cleanup owners across non-isolated files and settle concurrent verifier copies

* fix(providers): propagate underlying cleanup release claims through DeferredAnalysisClient
2026-11-17 08:28:59 -05:00

119 lines
4.4 KiB
JavaScript

import { lstat } from "node:fs/promises";
import { Ajv2020 } from "ajv/dist/2020.js";
/**
* Verify canonical names, converted JSON Schemas, and session catalog metadata.
* Only this operation needs built contracts; path checks remain source-only.
*/
export const verifyCompleteToolCatalog = async (client, options) => {
const [
{ requireMcpLifecycleResult, sortVerifierNames },
{ TOOL_CONTRACTS },
dialect,
] = await Promise.all([
import("./mcp-verifier-results.mjs"),
import("../../dist/contracts/toolContracts.js"),
import("../../dist/contracts/advertisedDialect.js"),
]);
const listed = await client.listTools(undefined, options);
const canonical = sortVerifierNames(TOOL_CONTRACTS.map(({ name }) => name));
const observed = sortVerifierNames(listed.tools.map(({ name }) => name));
if (JSON.stringify(observed) !== JSON.stringify(canonical)) {
const canonicalNames = new Set(canonical);
const observedNames = new Set(observed);
const unknown = observed.filter((name) => !canonicalNames.has(name));
const missing = canonical.filter((name) => !observedNames.has(name));
const duplicates = observed.filter(
(name, index) => index > 0 && name === observed[index - 1],
);
throw new Error(
`packaged MCP exposed an invalid canonical tool catalog (${observed.length} tools, unknown: ${unknown.join(", ") || "none"}, missing: ${missing.join(", ") || "none"}, duplicates: ${duplicates.join(", ") || "none"})`,
);
}
const ajv = new Ajv2020({ strict: false, validateFormats: false });
for (const tool of listed.tools) {
for (const kind of ["inputSchema", "outputSchema"]) {
const schema = tool[kind];
if (schema !== undefined && !ajv.validateSchema(schema))
throw new Error(
`packaged MCP has invalid ${tool.name}.${kind}: ${ajv.errorsText(ajv.errors)}`,
);
}
}
// The compact input presentation is enforced at zero, like every output pattern.
const regressions = [
...dialect.advertisedDialectRegressions(
dialect.countAdvertisedDialectViolations(
listed.tools.flatMap(dialect.advertisedInputDialectViolations),
),
{},
),
...dialect.advertisedDialectRegressions(
dialect.countAdvertisedDialectViolations(
listed.tools.flatMap(dialect.advertisedOutputPatternViolations),
),
{},
),
];
if (regressions.length > 0)
throw new Error(
`packaged MCP advertises constructs outside the portable schema dialect: ${regressions.join("; ")}`,
);
const sessionDefinition = listed.tools.find(
({ name }) => name === "binary_session",
);
if (sessionDefinition === undefined)
throw new Error("packaged MCP omitted the binary_session definition");
const status = await client.callTool(
{ name: "binary_session", arguments: {} },
// The SDK otherwise compiles every listed output schema on the first call.
// Keep its default validation for the actual named tool being exercised.
{ ...options, toolDefinition: sessionDefinition },
);
const expanded = requireMcpLifecycleResult(status, "binary_session");
const availability = expanded.tool_availability;
const expected = sortVerifierNames(availability.map(({ name }) => name));
if (JSON.stringify(observed) !== JSON.stringify(expected))
throw new Error(
"packaged MCP tool inventory diverged from session metadata",
);
return observed;
};
/** Check whether a path exists on disk. */
export const pathExists = async (path) => {
try {
await lstat(path);
return true;
} catch (cause) {
if (cause instanceof Error && "code" in cause && cause.code === "ENOENT")
return false;
throw cause;
}
};
/**
* Run bounded concurrent work, stop taking new items after the first failure,
* and wait for every started worker to settle before propagating failures.
*/
export const runSettledConcurrent = async (items, concurrency, worker) => {
if (items.length === 0) return;
let index = 0;
const failures = [];
await Promise.allSettled(
Array.from({ length: Math.min(concurrency, items.length) }, async () => {
while (failures.length === 0 && index < items.length) {
const current = index++;
try {
await worker(items[current]);
} catch (cause) {
failures.push(cause);
}
}
}),
);
if (failures.length === 1) throw failures[0];
if (failures.length > 1)
throw new AggregateError(failures, "Concurrent verifier tasks failed");
};