rea-agents 3.2.1 → 4.0.1

package/dist/application/JavaScriptReplayPlanning.js

@@ -1,207 +0,0 @@
-import canonicalize from "canonicalize";
-import { createHash } from "node:crypto";
-const REPLAY_POLICY_VERSION = "linux-bwrap-systemd-v1";
-const REPLAY_POLICY_DOCUMENT = Object.freeze({
-    version: REPLAY_POLICY_VERSION,
-    namespaces: ["user", "pid", "network", "ipc", "uts", "cgroup"],
-    capabilities: "drop-all",
-    network: "none",
-    filesystem: "minimal-read-only-runtime-plus-private-tmpfs",
-    seccomp: "rea-linux-x86_64-v1",
-    resource_manager: "systemd-user-cgroup-v2",
-    nested_user_namespaces: false,
-});
-const assertReplayManifestWithinProtocolLimit = (input) => {
-    if (new TextEncoder().encode(JSON.stringify(input)).byteLength >
-        input.limits.protocol_bytes)
-        throw new RangeError("Replay plan input exceeds its protocol byte limit");
-};
-/** Read, normalize, and content-address every input to one replay experiment. */
-export const prepareReplayPlan = async (input, policy, host) => {
-    assertReplayManifestWithinProtocolLimit(input);
-    const cases = replayCases(input).map((item) => ({
-        ...item,
-        sha256: digestJson(item.arguments),
-    }));
-    if (new TextEncoder().encode(JSON.stringify(cases.map(({ arguments: args }) => args))).byteLength > input.limits.input_bytes)
-        throw new RangeError("Replay case inputs exceed the aggregate byte limit");
-    await host.probe(policy);
-    const [runtime, bubblewrap, systemdRun, systemctl, shell, worker, runtimeFiles, left, right,] = await Promise.all([
-        host.identifyExecutable(policy.nodePath, ["--version"]),
-        host.identifyExecutable(policy.bubblewrapPath, ["--version"]),
-        host.identifyExecutable(policy.systemdRunPath, ["--version"]),
-        host.identifyExecutable(policy.systemctlPath, ["--version"]),
-        host.identifyExecutable(policy.shellPath, ["--version"]),
-        host.identifyWorker(),
-        host.identifyRuntimeClosure(policy.nodePath),
-        prepareSide(input.left, input.limits.module_bytes, host),
-        input.right === undefined
-            ? Promise.resolve(undefined)
-            : prepareSide(input.right, input.limits.module_bytes, host),
-    ]);
-    const withoutDigest = {
-        policy_version: REPLAY_POLICY_VERSION,
-        policy_sha256: digestJson(REPLAY_POLICY_DOCUMENT),
-        network: "none",
-        filesystem: {
-            host_writes: false,
-            private_tmpfs_bytes: input.limits.tmpfs_bytes,
-        },
-        runtime: {
-            executable: runtime,
-            worker,
-            read_only_files: runtimeFiles.map((item) => ({
-                source_path: item.sourcePath,
-                destination_path: item.destinationPath,
-                sha256: item.sha256,
-            })),
-        },
-        sandbox: {
-            bubblewrap,
-            systemd_run: systemdRun,
-            systemctl,
-            shell,
-            seccomp_sha256: host.seccompDigest(),
-        },
-        left: left.commitment,
-        ...(right === undefined ? {} : { right: right.commitment }),
-        cases,
-        determinism: input.determinism,
-        limits: input.limits,
-        effects: [
-            "Execute selected extracted modules in a disposable Linux OS sandbox",
-            "Create and remove one private cgroup and mount namespace",
-            "Retain bounded return, exception, termination, and diagnostic evidence",
-            "Perform no host filesystem writes and expose no host or external network",
-            ...(input.reproducer_export === undefined
-                ? []
-                : ["Write one reproducer after sandbox cleanup"]),
-        ],
-        reproducer_export: input.reproducer_export === undefined
-            ? null
-            : {
-                path: input.reproducer_export.path,
-                include_sources: input.reproducer_export.include_sources,
-            },
-    };
-    const publicPlan = {
-        ...withoutDigest,
-        plan_digest: digestJson(withoutDigest),
-    };
-    return {
-        publicPlan,
-        leftSources: left.sources,
-        ...(right === undefined ? {} : { rightSources: right.sources }),
-    };
-};
-const prepareSide = async (side, maximumBytes, host) => {
-    const aliases = new Set(side.modules.map(({ alias }) => alias));
-    if (aliases.size !== side.modules.length || !aliases.has(side.entry_alias))
-        throw new TypeError("Replay manifest aliases or entry alias are invalid");
-    for (const module of side.modules)
-        for (const dependency of Object.values(module.dependencies))
-            if (!aliases.has(dependency))
-                throw new TypeError(`Undeclared replay dependency alias: ${dependency}`);
-    const loaded = [];
-    let totalBytes = 0;
-    for (const module of side.modules) {
-        const remaining = maximumBytes - totalBytes;
-        if (remaining <= 0)
-            throw new RangeError("Replay module bytes exceed the aggregate limit");
-        const source = await host.readSource(module.path, remaining);
-        if (source.bytes.byteLength > remaining)
-            throw new RangeError("Replay module bytes exceed the aggregate limit");
-        totalBytes += source.bytes.byteLength;
-        loaded.push({ module, source });
-    }
-    return {
-        commitment: {
-            modules: loaded.map(({ module, source }) => ({
-                alias: module.alias,
-                canonical_path: source.canonicalPath,
-                format: module.format,
-                role: module.role,
-                byte_count: source.bytes.byteLength,
-                sha256: digestBytes(source.bytes),
-                dependencies: module.dependencies,
-            })),
-            entry_alias: side.entry_alias,
-            entry_export: side.entry_export,
-        },
-        sources: Object.fromEntries(loaded.map(({ module, source }) => [
-            module.alias,
-            new TextDecoder("utf-8", { fatal: true }).decode(source.bytes),
-        ])),
-    };
-};
-const replayCases = (input) => {
-    const explicit = input.cases.map((item) => ({
-        case_id: item.case_id,
-        arguments: item.arguments,
-    }));
-    if (input.generator === undefined)
-        return uniqueCases(explicit);
-    let state = input.generator.seed || 0x9e37_79b9;
-    const next = () => {
-        state ^= state << 13;
-        state ^= state >>> 17;
-        state ^= state << 5;
-        return state >>> 0;
-    };
-    const corpus = boundaryCorpus(input.generator.preset);
-    const generated = Array.from({ length: input.generator.count }, (_, index) => ({
-        case_id: `generated-${input.generator?.preset ?? "boundary"}-${String(index)}`,
-        arguments: [corpus[next() % corpus.length] ?? ""],
-    }));
-    return uniqueCases([...explicit, ...generated]);
-};
-const uniqueCases = (cases) => {
-    const ids = new Set();
-    for (const item of cases) {
-        if (ids.has(item.case_id))
-            throw new TypeError(`Duplicate replay case ID: ${item.case_id}`);
-        ids.add(item.case_id);
-    }
-    return cases;
-};
-const boundaryCorpus = (preset) => {
-    if (preset === "sanitizer-boundaries")
-        return [
-            "",
-            "<script>alert(1)</script>",
-            "<img src=x onerror=alert(1)>",
-            "javascript:alert(1)",
-            "<b>ok</b>",
-            "\u0000",
-        ];
-    if (preset === "clipboard-boundaries")
-        return [
-            "",
-            "plain",
-            "a\r\nb",
-            "a\nb",
-            "\t",
-            "😀",
-            "text/html",
-            "text/plain",
-        ];
-    return [
-        "",
-        " ",
-        "\n",
-        "# heading",
-        "**bold**",
-        "[x](javascript:y)",
-        "`code`",
-        "😀",
-        "\u0000",
-        "a".repeat(1024),
-    ];
-};
-export const digestBytes = (value) => createHash("sha256").update(value).digest("hex");
-export const digestJson = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("Replay commitment is not canonical JSON");
-    return createHash("sha256").update(encoded).digest("hex");
-};

package/dist/application/JavaScriptReplayService.js

@@ -1,274 +0,0 @@
-import { projectPermissionFailure } from "./PermissionFailure.js";
-import { z } from "zod";
-import writeFileAtomic from "write-file-atomic";
-import { controlledReplayInputSchema, replayExecutionResultSchema, controlledReplayOutputSchema, replayEvidenceSchema, } from "../domain/javascriptReplay.js";
-import { AnalysisCapabilityUnavailableError, AnalysisCancelledError, AnalysisInputError, AnalysisProtocolError, ReplayPlanStaleError, } from "../domain/errors.js";
-import { createEvidence } from "../domain/evidence.js";
-import { projectInputIssues } from "../domain/inputIssueProjection.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-import { err, ok } from "../domain/result.js";
-import { replayPermissionRequest } from "./JavaScriptReplayPermission.js";
-import { digestBytes, prepareReplayPlan, } from "./JavaScriptReplayPlanning.js";
-const OPERATION = "run_controlled_replay";
-const isAborted = (signal) => signal?.aborted === true;
-/** Plan or execute one content-bound extracted-module replay experiment. */
-export const runControlledReplay = async (dependencies, rawInput, options = {}) => {
-    const parsed = controlledReplayInputSchema.safeParse(rawInput);
-    if (!parsed.success)
-        return err(new AnalysisInputError(OPERATION, { cause: parsed.error }, projectInputIssues(parsed.error.issues, rawInput)));
-    return runControlledReplayValidated(dependencies, parsed.data, options);
-};
-/** Plan or execute replay input already parsed by a trusted adapter. */
-export const runControlledReplayValidated = async (dependencies, input, options = {}) => {
-    const authorized = await authorizeReplay(dependencies, dependencies.policy(), input, options.signal);
-    if (!authorized.ok)
-        return authorized;
-    const prepared = await prepareValidatedReplay(dependencies, authorized.value, input, options.signal);
-    if (!prepared.ok)
-        return prepared;
-    if (isAborted(options.signal))
-        return err(new AnalysisCancelledError(OPERATION));
-    if (input.mode === "plan")
-        return ok(asJson({
-            phase: "plan",
-            plan: prepared.value.publicPlan,
-            source_evidence: [],
-            evidence: null,
-        }));
-    if (input.plan_digest !== prepared.value.publicPlan.plan_digest)
-        return err(new ReplayPlanStaleError(input.plan_digest, prepared.value.publicPlan.plan_digest));
-    const exportContext = await authorizeReproducerExport(input);
-    if (!exportContext.ok)
-        return exportContext;
-    const executed = await executeValidatedReplay({
-        runner: dependencies.runner,
-        policy: authorized.value,
-        prepared: prepared.value,
-        exportContext: exportContext.value,
-        options,
-    });
-    if (!executed.ok)
-        return executed;
-    try {
-        return ok(buildReplayOutput(prepared.value, executed.value.executed, executed.value.sourceEvidence));
-    }
-    catch (cause) {
-        return err(new AnalysisProtocolError(cause instanceof z.ZodError
-            ? "Controlled replay produced an invalid bounded result"
-            : "Controlled replay could not establish or clean up its sandbox", { cause }));
-    }
-};
-const authorizeReplay = async (dependencies, policy, input, signal) => {
-    if (policy.status === "disabled")
-        return err(new AnalysisCapabilityUnavailableError("rea-javascript-replay", OPERATION, "controlled replay is disabled; configure exact roots and executables before enabling it"));
-    if (dependencies.authority === undefined)
-        return err(new AnalysisCapabilityUnavailableError("rea-javascript-replay", OPERATION, "JavaScript replay permission policy is not configured"));
-    if (isAborted(signal))
-        return err(new AnalysisCancelledError(OPERATION));
-    const request = replayPermissionRequest(input, policy);
-    const authorized = input.mode === "plan"
-        ? await dependencies.authority.explain(request, "read")
-        : await dependencies.authority.authorize(request, "read");
-    if (!authorized.ok)
-        return err(projectPermissionFailure(authorized.error));
-    return ok(policy);
-};
-const prepareValidatedReplay = async (dependencies, policy, input, signal) => {
-    if (isAborted(signal))
-        return err(new AnalysisCancelledError(OPERATION));
-    try {
-        return ok(await prepareReplayPlan(input, policy, dependencies.host));
-    }
-    catch (cause) {
-        return err(new AnalysisCapabilityUnavailableError("rea-javascript-replay", OPERATION, cause instanceof Error ? cause.message : "replay planning failed"));
-    }
-};
-const authorizeReproducerExport = (input) => {
-    if (input.reproducer_export === undefined)
-        return ok(undefined);
-    return ok({
-        path: input.reproducer_export.path,
-        includeSources: input.reproducer_export.include_sources === true,
-    });
-};
-const executeValidatedReplay = async (context) => {
-    const { runner, policy, prepared, exportContext, options } = context;
-    await options.progress?.report({
-        phase: OPERATION,
-        completed: 0,
-        total: 1,
-        message: "Admitting approved modules into the isolated replay worker",
-    });
-    if (isAborted(options.signal))
-        return err(new AnalysisCancelledError(OPERATION));
-    try {
-        let executed = replayExecutionResultSchema.parse(await runner.execute(prepared, policy, options.signal));
-        await options.progress?.report({
-            phase: OPERATION,
-            completed: 1,
-            total: 1,
-            message: "Controlled replay stopped and sandbox cleanup was observed",
-            terminal: true,
-        });
-        if (executed.termination === "cancelled")
-            return err(new AnalysisCancelledError(OPERATION));
-        executed = await applyReproducerExport(executed, exportContext, prepared);
-        const sourceEvidence = buildSourceEvidence(prepared, executed);
-        return ok({ executed, sourceEvidence });
-    }
-    catch (cause) {
-        return err(new AnalysisProtocolError(cause instanceof z.ZodError
-            ? "Controlled replay produced an invalid bounded result"
-            : "Controlled replay could not establish or clean up its sandbox", { cause }));
-    }
-};
-const applyReproducerExport = async (executed, exportContext, prepared) => {
-    if (exportContext === undefined || executed.cleanup.state !== "complete")
-        return executed;
-    const manifest = {
-        plan: prepared.publicPlan,
-        result: executed,
-        sources: exportContext.includeSources
-            ? {
-                left: prepared.leftSources,
-                ...(prepared.rightSources === undefined
-                    ? {}
-                    : { right: prepared.rightSources }),
-            }
-            : null,
-    };
-    const encoded = Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`);
-    try {
-        await writeFileAtomic(exportContext.path, encoded, {
-            mode: 0o600,
-        });
-        return replayExecutionResultSchema.parse({
-            ...executed,
-            reproducer: {
-                state: "written",
-                path: exportContext.path,
-                sha256: digestBytes(encoded),
-            },
-        });
-    }
-    catch (cause) {
-        return replayExecutionResultSchema.parse({
-            ...executed,
-            limitations: [
-                ...executed.limitations,
-                "Replay completed, but the separately approved reproducer export failed.",
-            ],
-            reproducer: {
-                state: "failed",
-                path: exportContext.path,
-                error: cause instanceof Error
-                    ? cause.message
-                    : "unknown reproducer export failure",
-            },
-        });
-    }
-};
-const buildSourceEvidence = (prepared, executed) => {
-    const leftCount = prepared.publicPlan.cases.length;
-    return [
-        createReplayEvidence(prepared, executed, "left", executed.outcomes.slice(0, leftCount)),
-        ...(prepared.publicPlan.right === undefined
-            ? []
-            : [
-                createReplayEvidence(prepared, executed, "right", executed.outcomes.slice(leftCount)),
-            ]),
-    ];
-};
-const buildReplayOutput = (prepared, executed, sourceEvidence) => {
-    const subject = prepared.publicPlan.left.modules[0];
-    const evidence = createEvidence(subject === undefined
-        ? undefined
-        : {
-            path: subject.canonical_path,
-            sha256: subject.sha256,
-            format: "javascript",
-        }, {
-        id: "rea-javascript-replay",
-        name: "REA isolated JavaScript replay",
-        version: "1",
-    }, {
-        predicateType: "javascript-controlled-replay",
-        operation: OPERATION,
-        parameters: {
-            replay_plan: jsonValueSchema.parse(JSON.parse(JSON.stringify(prepared.publicPlan))),
-        },
-        result: jsonValueSchema.parse(JSON.parse(JSON.stringify(executed))),
-        rawResult: jsonValueSchema.parse(JSON.parse(JSON.stringify({
-            cases: prepared.publicPlan.cases,
-            outcomes: executed.outcomes,
-            stderr: executed.stderr,
-        }))),
-        confidence: executed.comparison === undefined ? "observed" : "derived",
-        authority: "controlled-replay",
-        environment: {
-            id: prepared.publicPlan.plan_digest,
-            platform: process.platform,
-            architecture: process.arch,
-            isolation: "container",
-        },
-        limitations: executed.limitations,
-        locations: prepared.publicPlan.left.modules.map((module) => ({
-            kind: "artifact-path",
-            path: module.canonical_path,
-        })),
-        evidenceLinks: sourceEvidence.map(({ evidence_id: id }) => id),
-    });
-    return asJson({
-        phase: "execute",
-        plan: null,
-        source_evidence: sourceEvidence.map((item) => replayEvidenceSchema.parse(item)),
-        evidence: replayEvidenceSchema.parse(evidence),
-    });
-};
-const createReplayEvidence = (prepared, executed, side, outcomes) => {
-    const manifest = side === "left" ? prepared.publicPlan.left : prepared.publicPlan.right;
-    const subject = manifest?.modules[0];
-    const result = replayExecutionResultSchema.parse({
-        ...executed,
-        outcomes,
-        comparison: undefined,
-        reproducer: null,
-    });
-    return createEvidence(subject === undefined
-        ? undefined
-        : {
-            path: subject.canonical_path,
-            sha256: subject.sha256,
-            format: "javascript",
-        }, {
-        id: "rea-javascript-replay",
-        name: "REA isolated JavaScript replay",
-        version: "1",
-    }, {
-        predicateType: "javascript-controlled-replay-observation",
-        operation: OPERATION,
-        parameters: {
-            replay_plan: jsonValueSchema.parse(JSON.parse(JSON.stringify(prepared.publicPlan))),
-            side,
-        },
-        result: jsonValueSchema.parse(JSON.parse(JSON.stringify(result))),
-        rawResult: jsonValueSchema.parse(JSON.parse(JSON.stringify({ cases: prepared.publicPlan.cases, outcomes }))),
-        confidence: "observed",
-        authority: "controlled-replay",
-        environment: {
-            id: prepared.publicPlan.plan_digest,
-            platform: process.platform,
-            architecture: process.arch,
-            isolation: "container",
-        },
-        limitations: executed.limitations,
-        locations: (manifest?.modules ?? []).map((module) => ({
-            kind: "artifact-path",
-            path: module.canonical_path,
-        })),
-    });
-};
-const asJson = (value) => {
-    const serialized = JSON.parse(JSON.stringify(controlledReplayOutputSchema.parse(value)));
-    return jsonValueSchema.parse(serialized);
-};