mirror of
https://github.com/morluto/rea.git
synced 2026-10-12 02:19:24 +00:00
12c416005f
* feat(javascript): recover code-split bundles from multiple inputs recover_javascript_sources accepted a single path, and validateModuleSet bound every module's provenance to that one snapshot. A code-split app (runtime + chunks, or an Electron main/preload/renderer set) had to be recovered one file per call, and modules recovered alone could not resolve imports across chunks: cross-chunk require(id) references stayed as numeric ids with property reads. Add an optional additional_paths input. The listed files are concatenated, in order after path, into the single engine snapshot, so one Wakaru run sees every module and cross-chunk imports resolve. validateModuleSet's single-snapshot binding is unchanged. Module provenance is attributed back to the input file its first extraction range starts in, with byte ranges rebased to that file's own offsets; a module whose ranges cross an input boundary keeps the concatenated snapshot identity and offsets, recorded as an explicit limitation. Single-path behavior is byte-for-byte unchanged (one segment, offset 0). Fixes #1605 * fix(javascript): preserve source identity in multi-input recovery --------- Co-authored-by: JingHao-Leon <[email protected]> Co-authored-by: morluto <[email protected]>
86 lines
3.3 KiB
TypeScript
86 lines
3.3 KiB
TypeScript
import { Client, InMemoryTransport } from "@modelcontextprotocol/client";
|
|
import { writeFile } from "node:fs/promises";
|
|
import { join } from "node:path";
|
|
import { Ajv2020 } from "ajv/dist/2020.js";
|
|
import { expect, it, onTestFinished } from "vitest";
|
|
import { toolContract } from "../../../src/contracts/toolContracts.js";
|
|
import { parseEvidence } from "../../../src/domain/evidence.js";
|
|
import { createServer } from "../../../src/server/createServer.js";
|
|
import { createTestBinarySession } from "../../fixtures/binarySession.js";
|
|
import {
|
|
assertRecoveryCleanup,
|
|
recoveryFixture,
|
|
} from "../../fixtures/javascript-recovery/provider.js";
|
|
|
|
it
|
|
.skipIf(process.platform !== "linux" || process.arch !== "x64")
|
|
.each([false, true])(
|
|
"advertises and executes recovery through the named SDK contract (multiple inputs: %s)",
|
|
async (multiple) => {
|
|
const fixture = await recoveryFixture();
|
|
const session = createTestBinarySession(() => {
|
|
throw new Error("no binary provider should start");
|
|
});
|
|
const server = createServer(
|
|
{ kind: "session", session },
|
|
{
|
|
javascriptRecovery: fixture.provider,
|
|
},
|
|
);
|
|
const client = new Client({ name: "recovery-contract", version: "1" });
|
|
onTestFinished(async () => {
|
|
await client.close();
|
|
await server.close();
|
|
await session.close();
|
|
});
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
await server.connect(serverTransport);
|
|
await client.connect(clientTransport);
|
|
const tools = await client.listTools();
|
|
const advertised = tools.tools.find(
|
|
(tool) => tool.name === "recover_javascript_sources",
|
|
);
|
|
if (advertised === undefined || advertised.outputSchema === undefined)
|
|
throw new Error("recovery tool must advertise both schemas");
|
|
const ajv = new Ajv2020({ strict: false, validateFormats: false });
|
|
const inputSchema: Record<string, unknown> = advertised.inputSchema;
|
|
const outputSchema: Record<string, unknown> = advertised.outputSchema;
|
|
expect(ajv.validateSchema(inputSchema)).toBe(true);
|
|
expect(ajv.validateSchema(outputSchema)).toBe(true);
|
|
const additional = join(fixture.root, "chunk.js");
|
|
if (multiple) await writeFile(additional, "export const chunk = 1;");
|
|
const args = {
|
|
path: fixture.path,
|
|
output_directory: fixture.output,
|
|
...(multiple ? { additional_paths: [additional] } : {}),
|
|
};
|
|
expect(ajv.validate(inputSchema, args)).toBe(true);
|
|
const response = await client.callTool({
|
|
name: "recover_javascript_sources",
|
|
arguments: args,
|
|
});
|
|
expect(response.isError, JSON.stringify(response)).not.toBe(true);
|
|
expect(
|
|
ajv.validate(outputSchema, response.structuredContent),
|
|
JSON.stringify(ajv.errors),
|
|
).toBe(true);
|
|
const parsed = toolContract(
|
|
"recover_javascript_sources",
|
|
).outputSchema.parse(response.structuredContent);
|
|
const evidence = parseEvidence(parsed);
|
|
expect(evidence).toMatchObject({
|
|
operation: "recover_javascript_sources",
|
|
confidence: "derived",
|
|
authority: "shipped-artifact",
|
|
parameters: {
|
|
...args,
|
|
extraction_mode: "structural",
|
|
rewrite_level: "standard",
|
|
},
|
|
});
|
|
expect(session.evidenceById(evidence.evidence_id)).toEqual(evidence);
|
|
await assertRecoveryCleanup(fixture.launches);
|
|
},
|
|
);
|