mirror of
https://github.com/morluto/rea.git
synced 2026-11-18 04:34:13 +00:00
* 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
119 lines
4.4 KiB
JavaScript
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");
|
|
};
|