camoufox-mcp-server/dist/diagnostics.js

MCP server for browser automation using Camoufox - a privacy-focused Firefox fork with advanced anti-detection features

import { MAX_DIAGNOSTIC_ENTRIES } from "./config.js";
import { describeError, redactUrl, sanitizeDiagnosticText } from "./utils.js";
export function createDiagnosticsCollector(page, input, rawUrls, secrets) {
    const consoleEntries = [];
    const networkEntries = [];
    const networkByRequest = new WeakMap();
    let consoleTruncated = false;
    let networkTruncated = false;
    if (input.includeConsole) {
        page.on("console", (message) => {
            if (consoleEntries.length >= MAX_DIAGNOSTIC_ENTRIES) {
                consoleTruncated = true;
                return;
            }
            const location = message.location();
            consoleEntries.push({
                type: message.type(),
                text: sanitizeDiagnosticText(message.text(), rawUrls, secrets),
                location: {
                    url: location.url ? redactUrl(location.url) : undefined,
                    lineNumber: location.lineNumber,
                    columnNumber: location.columnNumber,
                },
            });
        });
        page.on("pageerror", (error) => {
            if (consoleEntries.length >= MAX_DIAGNOSTIC_ENTRIES) {
                consoleTruncated = true;
                return;
            }
            consoleEntries.push({
                type: "pageerror",
                text: sanitizeDiagnosticText(describeError(error), rawUrls, secrets),
            });
        });
    }
    if (input.includeNetwork) {
        page.on("request", (request) => {
            if (networkEntries.length >= MAX_DIAGNOSTIC_ENTRIES) {
                networkTruncated = true;
                return;
            }
            const entry = {
                url: redactUrl(request.url()),
                method: request.method(),
                resourceType: request.resourceType(),
            };
            networkEntries.push(entry);
            networkByRequest.set(request, entry);
        });
        page.on("response", (response) => {
            const entry = networkByRequest.get(response.request());
            if (!entry) {
                return;
            }
            entry.status = response.status();
            entry.contentType = response.headers()["content-type"];
        });
        page.on("requestfailed", (request) => {
            const entry = networkByRequest.get(request);
            if (!entry) {
                return;
            }
            entry.failed = true;
            entry.errorText = sanitizeDiagnosticText(request.failure()?.errorText ?? "request failed", rawUrls, secrets);
        });
    }
    return {
        payload() {
            const payload = {};
            if (input.includeConsole) {
                payload.console = consoleEntries;
                if (consoleTruncated) {
                    payload.consoleTruncated = true;
                }
            }
            if (input.includeNetwork) {
                payload.network = networkEntries;
                if (networkTruncated) {
                    payload.networkTruncated = true;
                }
            }
            return input.includeConsole || input.includeNetwork ? payload : undefined;
        },
    };
}
export function appendDiagnostics(payload, diagnostics) {
    if (diagnostics) {
        payload.diagnostics = diagnostics;
    }
    return payload;
}