rea-agents 4.1.0 → 6.0.0

package/dist/browser/history/HarCapture.js

@@ -0,0 +1,165 @@
+import { createHash } from "node:crypto";
+import { isSafeNumber, LosslessNumber } from "lossless-json";
+import { parseHarJson } from "./HarJson.js";
+import { WEB_NETWORK_CAPTURE_LIMITS, } from "../../domain/webNetworkCapture.js";
+import { CaptureFormatError } from "./CaptureFormatError.js";
+import { CaptureRedaction, captureObject, capturePointer, } from "./CaptureRedaction.js";
+import { createHarValidator } from "./HarSchema.js";
+import { HAR_CAPTURE_PROVIDER_IDENTITY } from "./CaptureRelease.js";
+/** Decode a retained HAR with exact numeric lexemes and unchanged upstream schema validation. */
+export const decodeHarCapture = (text, sensitiveValues) => {
+    const raw = parseHarJson(text);
+    const validation = projectHar(raw, [], false);
+    createHarValidator()(validation.reported);
+    if (!captureObject(raw) ||
+        !captureObject(raw.log) ||
+        !Array.isArray(raw.log.entries))
+        throw new CaptureFormatError("format", "HAR must contain log.entries.");
+    if (raw.log.version !== "1.2")
+        throw new CaptureFormatError("unsupported", "Only the pinned HAR 1.2 schema profile is supported.", "/log/version");
+    const entries = raw.log.entries;
+    const recordsExcluded = ["log", "entries"].some((key) => sensitiveValues.some((literal) => key.includes(literal)));
+    const container = projectHar({ ...raw, log: { ...raw.log, entries: null } }, sensitiveValues, true);
+    const records = entries.map((entry, ordinal) => {
+        // Validate each original record even when a structural ancestor excludes it.
+        const projected = projectHar(entry, sensitiveValues, true);
+        const projection = recordsExcluded
+            ? {
+                reported: null,
+                numeric_literals: [],
+                binary_fields: [],
+                redactions: [{ pointer: "", reason: "explicit-sensitive-value" }],
+            }
+            : projected;
+        return {
+            ordinal,
+            location: recordsExcluded
+                ? { kind: "unknown", reason: "explicit-sensitive-value" }
+                : { kind: "json-pointer", pointer: `/log/entries/${ordinal}` },
+            ...projection,
+            limitations: [
+                "HAR text is producer-decoded Unicode. Original body bytes remain unknown unless content explicitly uses valid base64; declared sizes are preserved independently of retained bytes. mitmproxy 12.2.3 SaveHar may report null optional postData.text; that null is retained and omitted only from the upstream validation copy.",
+                ...(recordsExcluded
+                    ? [
+                        "This record's payload and sidecars are excluded because its structural ancestor property was explicitly marked sensitive.",
+                    ]
+                    : []),
+            ],
+        };
+    });
+    return {
+        decoder: { ...HAR_CAPTURE_PROVIDER_IDENTITY },
+        container: {
+            reported: container.reported,
+            numeric_literals: container.numeric_literals,
+            redactions: container.redactions,
+            records_pointer: recordsExcluded ? null : "/log/entries",
+        },
+        total_records: records.length,
+        records,
+    };
+};
+const projectHar = (value, sensitiveValues, redact) => {
+    const redactor = new CaptureRedaction(sensitiveValues);
+    const numeric_literals = [];
+    const binary_fields = [];
+    const visit = (item, pointer, depth, parent) => {
+        if (depth > WEB_NETWORK_CAPTURE_LIMITS.depth)
+            throw new CaptureFormatError("input-limit", "HAR exceeds the 64-level complete-evidence nesting budget.", pointer);
+        if (redact &&
+            parent !== undefined &&
+            redactor.harCredential(pointer, parent))
+            return redactor.credential(pointer);
+        if (item instanceof LosslessNumber) {
+            if (redact && redactor.text(item.value, pointer) === null)
+                return null;
+            numeric_literals.push({
+                pointer,
+                producer_type: "json-number",
+                literal: item.value,
+            });
+            return isSafeNumber(item.value) ? Number(item.value) : null;
+        }
+        if (typeof item === "string") {
+            if (redact &&
+                pointer === "/response/content/text" &&
+                parent?.encoding === "base64") {
+                const bytes = decodeHarBase64(item, pointer);
+                const contentBase64 = bytes.toString("base64");
+                const sha256 = createHash("sha256").update(bytes).digest("hex");
+                const hidden = redactor.sensitiveBytes(bytes) ||
+                    sensitiveValues.some((literal) => item.includes(literal) ||
+                        contentBase64.includes(literal) ||
+                        sha256.includes(literal));
+                binary_fields.push(hidden
+                    ? {
+                        pointer,
+                        representation: "har-base64-content",
+                        state: "redacted",
+                        content_base64: null,
+                        bytes: null,
+                        sha256: null,
+                    }
+                    : {
+                        pointer,
+                        representation: "har-base64-content",
+                        state: "retained",
+                        content_base64: contentBase64,
+                        bytes: bytes.length,
+                        sha256,
+                    });
+                if (hidden) {
+                    redactor.redactions.push({
+                        pointer,
+                        reason: "explicit-sensitive-value",
+                    });
+                    return null;
+                }
+            }
+            return redact
+                ? redactor.text(item, pointer, redactor.harTransportUrl(pointer, parent))
+                : item;
+        }
+        if (item === null || typeof item === "boolean")
+            return item;
+        if (Array.isArray(item))
+            return item.map((child, index) => visit(child, capturePointer(pointer, String(index)), depth + 1));
+        if (captureObject(item))
+            return Object.fromEntries(Object.entries(item).flatMap(([key, child]) => {
+                if (redact &&
+                    sensitiveValues.some((literal) => key.includes(literal))) {
+                    const beforeNumbers = numeric_literals.length;
+                    const beforeBinaries = binary_fields.length;
+                    const beforeRedactions = redactor.redactions.length;
+                    visit(child, capturePointer(pointer, key), depth + 1, item);
+                    numeric_literals.splice(beforeNumbers);
+                    binary_fields.splice(beforeBinaries);
+                    redactor.redactions.splice(beforeRedactions);
+                    redactor.redactions.push({
+                        pointer,
+                        reason: "explicit-sensitive-value",
+                        scope: "property-name",
+                    });
+                    return [];
+                }
+                return [
+                    [key, visit(child, capturePointer(pointer, key), depth + 1, item)],
+                ];
+            }));
+        throw new CaptureFormatError("format", "HAR parser returned a non-JSON value.", pointer);
+    };
+    return {
+        reported: visit(value, "", 0),
+        numeric_literals,
+        binary_fields,
+        redactions: redactor.redactions,
+    };
+};
+const decodeHarBase64 = (value, pointer) => {
+    const compact = value.replace(/[\t\n\r ]/g, "");
+    const bytes = Buffer.from(compact, "base64");
+    if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(compact) ||
+        bytes.toString("base64") !== compact)
+        throw new CaptureFormatError("format", "HAR content declares base64 but its text is not valid canonical base64 (ASCII whitespace is allowed).", pointer);
+    return bytes;
+};

package/dist/browser/history/HarCaptureAdapter.js

@@ -0,0 +1,20 @@
+import { fileURLToPath } from "node:url";
+import { HAR_CAPTURE_PROVIDER_IDENTITY } from "./CaptureRelease.js";
+/** HAR's parser/schema packages run in one bounded Node heap, without network or target execution. */
+export class HarCaptureAdapter {
+    format = "har";
+    identity = HAR_CAPTURE_PROVIDER_IDENTITY;
+    async command(requestPath) {
+        return {
+            command: process.execPath,
+            arguments: [
+                "--max-old-space-size=192",
+                "--max-semi-space-size=8",
+                "--v8-pool-size=1",
+                "--single-threaded",
+                fileURLToPath(new URL("./HarCaptureProcess.js", import.meta.url)),
+                requestPath,
+            ],
+        };
+    }
+}

package/dist/browser/history/HarCaptureProcess.js

@@ -0,0 +1,57 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { TextDecoder } from "node:util";
+import { z } from "zod";
+import { readStableArtifact } from "../../artifacts/readStableArtifact.js";
+import { WEB_NETWORK_CAPTURE_LIMITS } from "../../domain/webNetworkCapture.js";
+import { CaptureFormatError } from "./CaptureFormatError.js";
+import { decodeHarCapture } from "./HarCapture.js";
+const requestSchema = z.strictObject({
+    snapshot_path: z.string(),
+    reply_path: z.string(),
+    sensitive_values: z.array(z.string().min(1)),
+});
+/** Decode untrusted HAR in an owned, bounded heap rather than the long-lived MCP process. */
+const main = async () => {
+    const request = requestSchema.parse(JSON.parse(await readFile(process.argv[2] ?? "", "utf8")));
+    let reply;
+    try {
+        const snapshot = await readStableArtifact(request.snapshot_path, WEB_NETWORK_CAPTURE_LIMITS.inputBytes);
+        let text;
+        try {
+            text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(snapshot.bytes);
+        }
+        catch {
+            throw new CaptureFormatError("format", "HAR is not valid UTF-8 JSON.");
+        }
+        reply = {
+            ok: true,
+            value: decodeHarCapture(text, request.sensitive_values),
+        };
+    }
+    catch (cause) {
+        reply =
+            cause instanceof CaptureFormatError
+                ? {
+                    ok: false,
+                    reason: cause.reason,
+                    message: cause.message,
+                    pointer: cause.pointer,
+                }
+                : {
+                    ok: false,
+                    reason: "decoder",
+                    message: `HAR decoder failed unexpectedly (${cause instanceof Error ? cause.name : "unknown exception"}).`,
+                    pointer: "",
+                };
+    }
+    let text = JSON.stringify(reply);
+    if (Buffer.byteLength(text) > WEB_NETWORK_CAPTURE_LIMITS.outputBytes)
+        text = JSON.stringify({
+            ok: false,
+            reason: "limit",
+            message: "HAR reply exceeds the complete-evidence output budget.",
+            pointer: "",
+        });
+    await writeFile(request.reply_path, text, { flag: "wx", mode: 0o600 });
+};
+await main();

package/dist/browser/history/HarJson.js

@@ -0,0 +1,91 @@
+import { visit } from "jsonc-parser";
+import { LosslessNumber } from "lossless-json";
+import { WEB_NETWORK_CAPTURE_LIMITS } from "../../domain/webNetworkCapture.js";
+import { CaptureFormatError } from "./CaptureFormatError.js";
+/** Materialize upstream JSON events without duplicate folding, prototype setters or numeric rounding. */
+export const parseHarJson = (text) => {
+    const frames = [];
+    let result;
+    const valuePointer = () => {
+        const parent = frames.at(-1);
+        if (parent === undefined)
+            return "";
+        if (parent.kind === "array")
+            return `${parent.pointer}/${parent.items.length}`;
+        return parent.pendingKey === undefined
+            ? parent.pointer
+            : `${parent.pointer}/${parent.pendingKey.replaceAll("~", "~0").replaceAll("/", "~1")}`;
+    };
+    const checkDepth = () => {
+        if (frames.length > WEB_NETWORK_CAPTURE_LIMITS.depth)
+            throw new CaptureFormatError("input-limit", "HAR exceeds the 64-level complete-evidence nesting budget.", valuePointer());
+    };
+    const append = (value) => {
+        const parent = frames.at(-1);
+        if (parent === undefined)
+            result = value;
+        else if (parent.kind === "array")
+            parent.items.push(value);
+        else {
+            if (parent.pendingKey === undefined)
+                throw new TypeError("JSON visitor omitted an object property identity.");
+            parent.members.set(parent.pendingKey, value);
+            delete parent.pendingKey;
+        }
+    };
+    visit(text, {
+        onObjectBegin: () => {
+            checkDepth();
+            frames.push({
+                kind: "object",
+                pointer: valuePointer(),
+                members: new Map(),
+            });
+        },
+        onObjectProperty: (key) => {
+            if (key === "__proto__")
+                throw new CaptureFormatError("unsupported", "HAR object contains a __proto__ member that the current JSON schema boundary cannot preserve.");
+            const frame = frames.at(-1);
+            if (frame?.kind !== "object")
+                throw new TypeError("JSON visitor emitted a property outside an object.");
+            if (frame.members.has(key))
+                throw new CaptureFormatError("format", "HAR JSON contains duplicate object members.");
+            frame.pendingKey = key;
+        },
+        onObjectEnd: () => {
+            const frame = frames.pop();
+            if (frame?.kind !== "object")
+                throw new TypeError("JSON visitor ended an unexpected object.");
+            append(Object.fromEntries(frame.members));
+        },
+        onArrayBegin: () => {
+            checkDepth();
+            frames.push({ kind: "array", pointer: valuePointer(), items: [] });
+        },
+        onArrayEnd: () => {
+            const frame = frames.pop();
+            if (frame?.kind !== "array")
+                throw new TypeError("JSON visitor ended an unexpected array.");
+            append(frame.items);
+        },
+        onLiteralValue: (value, offset, length) => {
+            checkDepth();
+            if (typeof value === "number")
+                append(new LosslessNumber(text.slice(offset, offset + length)));
+            else if (value === null ||
+                typeof value === "boolean" ||
+                typeof value === "string")
+                append(value);
+            else
+                throw new TypeError("JSON visitor emitted an unsupported literal.");
+        },
+        onError: () => {
+            throw new CaptureFormatError("format", "HAR is malformed JSON.");
+        },
+    }, {
+        disallowComments: true,
+        allowTrailingComma: false,
+        allowEmptyContent: false,
+    });
+    return result;
+};

package/dist/browser/history/HarSchema.js

@@ -0,0 +1,72 @@
+import { createRequire } from "node:module";
+import { Ajv } from "ajv";
+import { z } from "zod";
+import { CaptureFormatError } from "./CaptureFormatError.js";
+/** Validate using the unchanged, pinned upstream HAR 1.2 draft-06 schemas. */
+export const createHarValidator = () => {
+    const require = createRequire(import.meta.url);
+    const schemas = z
+        .record(z.string(), z.record(z.string(), z.unknown()))
+        .parse(require("har-schema"));
+    const ajv = new Ajv({ strict: false, allErrors: false, ownProperties: true });
+    ajv.addMetaSchema(require("ajv/dist/refs/json-schema-draft-06.json"));
+    const plugin = require("ajv-formats");
+    if (typeof plugin !== "function")
+        throw new Error("Pinned AJV formats plugin is unavailable");
+    plugin(ajv);
+    for (const schema of Object.values(schemas))
+        ajv.addSchema(schema);
+    const validate = ajv.getSchema("har.json#");
+    if (validate === undefined)
+        throw new Error("Pinned HAR root schema is unavailable");
+    return (value) => {
+        allowMitmproxyAbsentPostData(value);
+        if (!validate(value)) {
+            const error = validate.errors?.[0];
+            throw new CaptureFormatError("format", `HAR schema validation failed: ${error?.keyword ?? "unknown constraint"}.`, error?.instancePath ?? "");
+        }
+    };
+};
+/** Observed SaveHar 12.2.3 compatibility: validate omitted optional text while retaining reported null. */
+const allowMitmproxyAbsentPostData = (value) => {
+    const parsed = z
+        .object({
+        log: z.object({
+            creator: z.object({
+                name: z.literal("mitmproxy"),
+                version: z.literal("12.2.3"),
+            }),
+            entries: z.array(z.unknown()),
+        }),
+    })
+        .safeParse(value);
+    if (!parsed.success ||
+        typeof value !== "object" ||
+        value === null ||
+        !("log" in value))
+        return;
+    const log = value.log;
+    if (typeof log !== "object" ||
+        log === null ||
+        !("entries" in log) ||
+        !Array.isArray(log.entries))
+        return;
+    for (const entry of log.entries) {
+        const candidate = entry;
+        if (typeof candidate !== "object" ||
+            candidate === null ||
+            !("request" in candidate))
+            continue;
+        const request = candidate.request;
+        if (typeof request !== "object" ||
+            request === null ||
+            !("postData" in request))
+            continue;
+        const body = request.postData;
+        if (typeof body === "object" &&
+            body !== null &&
+            "text" in body &&
+            body.text === null)
+            delete body.text;
+    }
+};

package/dist/browser/history/HistoricalCaptureDecoder.js

@@ -0,0 +1,186 @@
+import { historicalCaptureFailure } from "./CaptureFailures.js";
+import { projectAnalysisError } from "../../domain/analysisErrorProjection.js";
+import { randomUUID } from "node:crypto";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+import { readStableArtifact } from "../../artifacts/readStableArtifact.js";
+import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
+import { AnalysisCapabilityUnavailableError, AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
+import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
+import { ProviderCleanupError } from "../../domain/providerCleanupError.js";
+import { err, ok } from "../../domain/result.js";
+import { WEB_NETWORK_CAPTURE_LIMITS, webNetworkCaptureSchema, } from "../../domain/webNetworkCapture.js";
+import { runOwnedCommand } from "../../process/OwnedCommand.js";
+import { PrivateRuntimeRoot } from "../../process/PrivateRuntimeRoot.js";
+import { redactExplicitFailure } from "../../domain/explicitSensitiveFailure.js";
+const OPERATION = "inspect_web_network_capture";
+const decodedSchema = webNetworkCaptureSchema.omit({
+    artifact: true,
+    format: true,
+    runtime_attribution: true,
+    limitations: true,
+});
+const replySchema = z.discriminatedUnion("ok", [
+    z.strictObject({ ok: z.literal(true), value: decodedSchema }),
+    z.strictObject({
+        ok: z.literal(false),
+        reason: z.enum([
+            "format",
+            "unsupported",
+            "input-limit",
+            "resource-limit",
+            "decoder",
+            "limit",
+        ]),
+        message: z.string(),
+        pointer: z.string(),
+    }),
+]);
+/** One owned snapshot/process/root lifecycle for replaceable historical format decoders. */
+export class HistoricalCaptureDecoder {
+    adapters;
+    environment;
+    createRuntime;
+    constructor(adapters, environment, createRuntime = () => PrivateRuntimeRoot.create({ prefix: "rea-web-capture-" })) {
+        this.adapters = adapters;
+        this.environment = environment;
+        this.createRuntime = createRuntime;
+    }
+    /** Snapshot the selected artifact, decode it offline, and release private credentials and processes. */
+    async inspect(input, options) {
+        let runtime;
+        let result;
+        let phase = "capture-read";
+        try {
+            const adapter = this.adapters.find((candidate) => candidate.format === input.format);
+            if (adapter === undefined)
+                throw new AnalysisCapabilityUnavailableError(input.format, OPERATION, "No adapter is configured for the selected capture format.");
+            const snapshot = await readStableArtifact(input.capture_path, WEB_NETWORK_CAPTURE_LIMITS.inputBytes, options?.signal);
+            phase = "decoder";
+            runtime = await this.createRuntime();
+            const snapshotPath = join(runtime.path, "capture.snapshot");
+            const requestPath = join(runtime.path, "request.json");
+            const replyPath = join(runtime.path, "reply.json");
+            await writeFile(snapshotPath, snapshot.bytes, {
+                mode: 0o600,
+                flag: "wx",
+                ...(options?.signal === undefined ? {} : { signal: options.signal }),
+            });
+            await writeFile(requestPath, JSON.stringify({
+                snapshot_path: snapshotPath,
+                reply_path: replyPath,
+                sensitive_values: input.sensitive_values,
+            }), { mode: 0o600, flag: "wx" });
+            const command = await adapter.command(requestPath, runtime.path);
+            const environment = {
+                ...this.environment,
+                UV_THREADPOOL_SIZE: "1",
+            };
+            delete environment.NODE_OPTIONS;
+            await runOwnedCommand({
+                ...command,
+                runId: `rea-web-capture-${randomUUID()}`,
+                cwd: runtime.path,
+                hostEnvironment: environment,
+            }, {
+                timeoutMs: WEB_NETWORK_CAPTURE_LIMITS.timeoutMs,
+                diagnosticBytes: 1024 * 1024,
+            }, options?.signal === undefined ? {} : { signal: options.signal });
+            let reply;
+            try {
+                const replyFile = await readStableArtifact(replyPath, WEB_NETWORK_CAPTURE_LIMITS.outputBytes, options?.signal);
+                reply = replySchema.parse(JSON.parse(replyFile.bytes.toString("utf8")));
+            }
+            catch (cause) {
+                if (options?.signal?.aborted)
+                    throw new AnalysisCancelledError(OPERATION);
+                throw new AnalysisOutputError(OPERATION, `Owned capture decoder reply failed for ${input.capture_path}: ${replyFailureReason(cause)}`, { cause });
+            }
+            if (!reply.ok) {
+                if (reply.reason === "format")
+                    throw new AnalysisInputError(OPERATION, undefined, [
+                        {
+                            path: ["capture_path", reply.pointer],
+                            reason: "invalid_format",
+                            message: reply.message,
+                        },
+                    ]);
+                if (reply.reason === "input-limit")
+                    throw new AnalysisInputError(OPERATION, undefined, [
+                        {
+                            path: ["capture_path", reply.pointer],
+                            reason: "out_of_range",
+                            message: reply.message,
+                            expected: {
+                                maximum_capture_nesting: WEB_NETWORK_CAPTURE_LIMITS.depth,
+                            },
+                        },
+                    ]);
+                if (reply.reason === "decoder" || reply.reason === "resource-limit")
+                    throw new ProviderAdapterError(input.format, OPERATION, {
+                        diagnostics: {
+                            phase: "decoder",
+                            failure_kind: reply.reason,
+                            reason: reply.message,
+                            pointer: reply.pointer,
+                        },
+                    });
+                if (reply.reason === "unsupported")
+                    throw new AnalysisCapabilityUnavailableError(input.format, OPERATION, reply.message);
+                throw new AnalysisOutputError(OPERATION, reply.message);
+            }
+            if (reply.value.decoder.id !== adapter.identity.id ||
+                reply.value.decoder.name !== adapter.identity.name ||
+                reply.value.decoder.version !== adapter.identity.version)
+                throw new AnalysisOutputError(OPERATION, "Capture decoder changed the selected upstream profile identity.");
+            result = ok({
+                ...reply.value,
+                artifact: {
+                    path: input.capture_path,
+                    sha256: snapshot.sha256,
+                    bytes: snapshot.bytes.length,
+                },
+                format: input.format,
+                runtime_attribution: "unknown",
+                limitations: [
+                    "This is retained producer evidence, without live browser transaction IDs, scenario provenance, execution attribution or deployment authenticity. Recorded URLs are never fetched.",
+                    "Every record is decoded before selection; no partial success is returned on malformed input or a resource limit.",
+                    "Known authentication headers/cookies and explicitly marked literal values are excluded. Unknown extension names do not establish sensitivity.",
+                    "A 32 MiB input, 96 MiB reply and 64-level nesting budget bound complete evidence. HAR uses a 192 MiB Node old-generation heap; native decoding uses a 768 MiB Linux address-space limit. Each owned command has a 30-second deadline with independent cleanup.",
+                ],
+            });
+        }
+        catch (cause) {
+            result = err(redactExplicitFailure(historicalCaptureFailure(input, cause, phase, options), input.sensitive_values));
+        }
+        if (runtime !== undefined) {
+            try {
+                await runtime.close();
+            }
+            catch (cause) {
+                return err(redactExplicitFailure(new ProviderCleanupError(input.format, [runtime.path], {
+                    capture_path: input.capture_path,
+                    previous_error: result.ok
+                        ? null
+                        : projectAnalysisError(result.error),
+                    reason: cause instanceof Error ? cause.message : String(cause),
+                }, { operation: OPERATION }), input.sensitive_values));
+            }
+        }
+        return result.ok && options?.signal?.aborted
+            ? err(new AnalysisCancelledError(OPERATION))
+            : result;
+    }
+}
+const replyFailureReason = (cause) => {
+    if (cause instanceof ArtifactReaderFailure)
+        return cause.message;
+    if (cause instanceof z.ZodError)
+        return `Reply violates its schema at ${cause.issues[0]?.path.map(String).join(".") ?? "root"}.`;
+    if (cause instanceof SyntaxError)
+        return "Reply is malformed JSON.";
+    if (cause instanceof Error && "code" in cause)
+        return `Reply file could not be read (${String(cause.code)}).`;
+    return "Reply could not be validated.";
+};

package/dist/browser/history/HistoricalCaptureFormatAdapter.js

@@ -0,0 +1 @@
+export {};

package/dist/browser/history/MitmproxyCaptureAdapter.js

@@ -0,0 +1,42 @@
+import { access } from "node:fs/promises";
+import { constants } from "node:fs";
+import { isAbsolute } from "node:path";
+import { fileURLToPath } from "node:url";
+import { AnalysisCapabilityUnavailableError } from "../../domain/analysisErrorCore.js";
+import { MITMPROXY_CAPTURE_PROVIDER_IDENTITY } from "./CaptureRelease.js";
+const OPERATION = "inspect_web_network_capture";
+/** Native mitmproxy decoding is offline and uses only an explicitly configured Linux tool. */
+export class MitmproxyCaptureAdapter {
+    environment;
+    format = "mitmproxy";
+    identity = MITMPROXY_CAPTURE_PROVIDER_IDENTITY;
+    constructor(environment) {
+        this.environment = environment;
+    }
+    async command(requestPath, runtimePath) {
+        const command = this.environment.REA_MITMDUMP_COMMAND;
+        if (process.platform !== "linux" ||
+            command === undefined ||
+            !isAbsolute(command))
+            throw new AnalysisCapabilityUnavailableError("mitmproxy", OPERATION, "Native capture decoding requires Linux and an absolute REA_MITMDUMP_COMMAND path to caller-supplied mitmdump 12.2.3; HAR needs no external engine.");
+        try {
+            await access(command, constants.R_OK | constants.X_OK);
+        }
+        catch (cause) {
+            throw new AnalysisCapabilityUnavailableError("mitmproxy", OPERATION, `Configured mitmdump executable is unavailable: ${command}.`, { cause });
+        }
+        return {
+            command,
+            arguments: [
+                "--no-server",
+                "-q",
+                "--set",
+                `confdir=${runtimePath}`,
+                "--set",
+                `rea_request_path=${requestPath}`,
+                "-s",
+                fileURLToPath(new URL("../../../bridge/mitmproxy/capture.py", import.meta.url)),
+            ],
+        };
+    }
+}