arn-browser 0.0.2 → 0.0.3

package/dist/utils.js

@@ -0,0 +1,500 @@
+// from browserforge.fingerprints import Fingerprint, Screen
+// from screeninfo import get_monitors
+// from ua_parser import user_agent_parser
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { UAParser } from "ua-parser-js";
+import { addDefaultAddons, confirmPaths, } from "./addons.js";
+import { InvalidOS, InvalidPropertyType, NonFirefoxFingerprint, UnknownProperty, } from "./exceptions.js";
+import { fromBrowserforge, generateFingerprint, SUPPORTED_OS, } from "./fingerprints.js";
+import { publicIP, validIPv4, validIPv6 } from "./ip.js";
+import { geoipAllowed, getGeolocation, handleLocales } from "./locale.js";
+import FONTS from "./mappings/fonts.config.js";
+import { getPath, installedVerStr, launchPath, OS_NAME } from "./pkgman.js";
+import { LeakWarning } from "./warnings.js";
+import { sampleWebGL } from "./webgl/sample.js";
+// Camoufox preferences to cache previous pages and requests
+const CACHE_PREFS = {
+    "browser.sessionhistory.max_entries": 10,
+    "browser.sessionhistory.max_total_viewers": -1,
+    "browser.cache.memory.enable": true,
+    "browser.cache.disk_cache_ssl": true,
+    "browser.cache.disk.smart_size.enabled": true,
+};
+function getEnvVars(configMap, userAgentOS) {
+    const envVars = {};
+    let updatedConfigData;
+    try {
+        updatedConfigData = new TextEncoder().encode(JSON.stringify(configMap));
+    }
+    catch (e) {
+        console.error(`Error updating config: ${e}`);
+        process.exit(1);
+    }
+    const chunkSize = OS_NAME === "win" ? 2047 : 32767;
+    const configStr = new TextDecoder().decode(updatedConfigData);
+    for (let i = 0; i < configStr.length; i += chunkSize) {
+        const chunk = configStr.slice(i, i + chunkSize);
+        const envName = `CAMOU_CONFIG_${Math.floor(i / chunkSize) + 1}`;
+        try {
+            envVars[envName] = chunk;
+        }
+        catch (e) {
+            console.error(`Error setting ${envName}: ${e}`);
+            process.exit(1);
+        }
+    }
+    if (OS_NAME === "lin") {
+        const fontconfigPath = getPath(path.join("fontconfig", userAgentOS));
+        envVars.FONTCONFIG_PATH = fontconfigPath;
+    }
+    return envVars;
+}
+export function getAsBooleanFromENV(name, defaultValue) {
+    const value = process.env[name];
+    if (value === "false" || value === "0")
+        return false;
+    if (value)
+        return true;
+    return !!defaultValue;
+}
+function loadProperties(filePath) {
+    let propFile;
+    filePath = filePath?.toString();
+    if (filePath) {
+        propFile = path.join(path.dirname(filePath), "properties.json");
+    }
+    else {
+        propFile = getPath("properties.json");
+    }
+    const propData = readFileSync(propFile).toString();
+    const propDict = JSON.parse(propData);
+    return propDict.reduce((acc, prop) => {
+        acc[prop.property] = prop.type;
+        return acc;
+    }, {});
+}
+function validateConfig(configMap, path) {
+    const propertyTypes = loadProperties(path);
+    for (const [key, value] of Object.entries(configMap)) {
+        const expectedType = propertyTypes[key];
+        if (!expectedType) {
+            throw new UnknownProperty(`Unknown property ${key} in config`);
+        }
+        if (!validateType(value, expectedType)) {
+            throw new InvalidPropertyType(`Invalid type for property ${key}. Expected ${expectedType}, got ${typeof value}`);
+        }
+    }
+}
+function validateType(value, expectedType) {
+    switch (expectedType) {
+        case "str":
+            return typeof value === "string";
+        case "int":
+            return Number.isInteger(value);
+        case "uint":
+            return Number.isInteger(value) && value >= 0;
+        case "double":
+            return typeof value === "number";
+        case "bool":
+            return typeof value === "boolean";
+        case "array":
+            return Array.isArray(value);
+        case "dict":
+            return (typeof value === "object" && value !== null && !Array.isArray(value));
+        default:
+            return false;
+    }
+}
+function getTargetOS(config) {
+    if (config["navigator.userAgent"]) {
+        return determineUAOS(config["navigator.userAgent"]);
+    }
+    return OS_NAME;
+}
+function determineUAOS(userAgent) {
+    const parser = new UAParser(userAgent);
+    const parsedUA = parser.getOS().name;
+    if (!parsedUA) {
+        throw new Error("Could not determine OS from user agent");
+    }
+    if (parsedUA.startsWith("macOS")) {
+        return "mac";
+    }
+    if (parsedUA.startsWith("Windows")) {
+        return "win";
+    }
+    return "lin";
+}
+function getScreenCons(headless) {
+    if (headless === false) {
+        return undefined;
+    }
+    // TODO - Implement getMonitors
+    // try {
+    //     const monitors = getMonitors();
+    //     if (!monitors.length) {
+    //         return undefined;
+    //     }
+    //     const monitor = monitors.reduce((prev, curr) => (prev.width * prev.height > curr.width * curr.height ? prev : curr));
+    //     return { maxWidth: monitor.width, maxHeight: monitor.height };
+    // } catch {
+    //     return undefined;
+    // }
+    return undefined;
+}
+function updateFonts(config, targetOS) {
+    const fonts = FONTS[targetOS];
+    if (config.fonts) {
+        config.fonts = Array.from(new Set([...fonts, ...config.fonts]));
+    }
+    else {
+        config.fonts = fonts;
+    }
+}
+function checkCustomFingerprint(fingerprint) {
+    const parser = new UAParser(fingerprint.navigator.userAgent);
+    const browserName = parser.getBrowser().name || "Non-Firefox";
+    if (browserName !== "Firefox") {
+        throw new NonFirefoxFingerprint(`"${browserName}" fingerprints are not supported in Camoufox. Using fingerprints from a browser other than Firefox WILL lead to detection. If this is intentional, pass i_know_what_im_doing=True.`);
+    }
+    LeakWarning.warn("custom_fingerprint", false);
+}
+function validateOS(os) {
+    if (!os)
+        return undefined;
+    if (Array.isArray(os)) {
+        os.every(validateOS);
+        return [...os];
+    }
+    if (!SUPPORTED_OS.includes(os)) {
+        throw new InvalidOS(`Camoufox does not support the OS: '${os}'`);
+    }
+    return [os];
+}
+function _cleanLocals(data) {
+    delete data.playwright;
+    delete data.persistentContext;
+    return data;
+}
+function mergeInto(target, source) {
+    Object.entries(source).forEach(([key, value]) => {
+        if (!(key in target)) {
+            target[key] = value;
+        }
+    });
+}
+function setInto(target, key, value) {
+    if (!(key in target)) {
+        target[key] = value;
+    }
+}
+function isDomainSet(config, ...properties) {
+    return properties.some((prop) => {
+        if (prop.endsWith(".") || prop.endsWith(":")) {
+            return Object.keys(config).some((key) => key.startsWith(prop));
+        }
+        return prop in config;
+    });
+}
+function warnManualConfig(config) {
+    if (isDomainSet(config, "navigator.language", "navigator.languages", "headers.Accept-Language", "locale:")) {
+        LeakWarning.warn("locale", false);
+    }
+    if (isDomainSet(config, "geolocation:", "timezone")) {
+        LeakWarning.warn("geolocation", false);
+    }
+    if (isDomainSet(config, "headers.User-Agent")) {
+        LeakWarning.warn("header-ua", false);
+    }
+    if (isDomainSet(config, "navigator.")) {
+        LeakWarning.warn("navigator", false);
+    }
+    if (isDomainSet(config, "screen.", "window.", "document.body.")) {
+        LeakWarning.warn("viewport", false);
+    }
+}
+async function _asyncAttachVD(browser, virtualDisplay) {
+    if (!virtualDisplay) {
+        return browser;
+    }
+    const originalClose = browser.close;
+    browser.close = async (...args) => {
+        await originalClose.apply(browser, ...args);
+        if (virtualDisplay) {
+            virtualDisplay.kill();
+        }
+    };
+    browser._virtualDisplay = virtualDisplay;
+    return browser;
+}
+export function syncAttachVD(browser, virtualDisplay) {
+    /**
+     * Attaches the virtual display to the sync browser cleanup
+     */
+    if (!virtualDisplay) {
+        // Skip if no virtual display is provided
+        return browser;
+    }
+    const originalClose = browser.close;
+    browser.close = (...args) => {
+        originalClose.apply(browser, ...args);
+        if (virtualDisplay) {
+            virtualDisplay.kill();
+        }
+    };
+    browser._virtualDisplay = virtualDisplay;
+    return browser;
+}
+/**
+ * Convert a Playwright proxy string to a URL object.
+ *
+ * Implementation from https://github.com/microsoft/playwright/blob/3873b72ac1441ca691f7594f0ed705bd84518f93/packages/playwright-core/src/server/browserContext.ts#L737-L747
+ */
+function getProxyUrl(proxy) {
+    if (!proxy)
+        return null;
+    if (typeof proxy === "string") {
+        return new URL(proxy);
+    }
+    const { server, username, password } = proxy;
+    let url;
+    try {
+        // new URL('127.0.0.1:8080') throws
+        // new URL('localhost:8080') fails to parse host or protocol
+        // In both of these cases, we need to try re-parse URL with `http://` prefix.
+        url = new URL(server);
+        if (!url.host || !url.protocol)
+            url = new URL(`http://${server}`);
+    }
+    catch (_e) {
+        url = new URL(`http://${server}`);
+    }
+    if (username)
+        url.username = username;
+    if (password)
+        url.password = password;
+    return url;
+}
+export async function launchOptions({ config, os, block_images, block_webrtc, block_webgl, disable_coop, webgl_config, geoip, humanize, locale, addons, fonts, custom_fonts_only, exclude_addons, screen, window, fingerprint, ff_version, headless, main_world_eval, executable_path, firefox_user_prefs, proxy, enable_cache, args, env, i_know_what_im_doing, debug, virtual_display, ...launch_options }) {
+    // Build the config
+    if (!config) {
+        config = {};
+    }
+    // Set default values for optional arguments
+    if (headless === undefined) {
+        headless = false;
+    }
+    if (!addons) {
+        addons = [];
+    }
+    if (!args) {
+        args = [];
+    }
+    if (!firefox_user_prefs) {
+        firefox_user_prefs = {};
+    }
+    if (custom_fonts_only === undefined) {
+        custom_fonts_only = false;
+    }
+    if (i_know_what_im_doing === undefined) {
+        i_know_what_im_doing = false;
+    }
+    if (!env) {
+        env = process.env;
+    }
+    if (typeof executable_path === "string") {
+        // Convert executable path to a Path object
+        executable_path = path.resolve(executable_path);
+    }
+    // Handle virtual display
+    if (virtual_display) {
+        env.DISPLAY = virtual_display;
+    }
+    // Warn the user for manual config settings
+    if (!i_know_what_im_doing) {
+        warnManualConfig(config);
+    }
+    const operatingSystems = validateOS(os);
+    // webgl_config requires OS to be set
+    if (!operatingSystems && webgl_config) {
+        throw new Error("OS must be set when using webgl_config");
+    }
+    // Add the default addons
+    addDefaultAddons(addons, exclude_addons);
+    // Confirm all addon paths are valid
+    if (addons.length > 0) {
+        confirmPaths(addons);
+        config.addons = addons;
+    }
+    // Get the Firefox version
+    let ff_version_str;
+    if (ff_version) {
+        ff_version_str = ff_version.toString();
+        LeakWarning.warn("ff_version", i_know_what_im_doing);
+    }
+    else {
+        ff_version_str = installedVerStr().split(".", 1)[0];
+    }
+    // Generate a fingerprint
+    if (!fingerprint) {
+        fingerprint = generateFingerprint(window, {
+            screen: screen || getScreenCons(headless || "DISPLAY" in env),
+            operatingSystems,
+        });
+    }
+    else {
+        // Or use the one passed by the user
+        if (!i_know_what_im_doing) {
+            checkCustomFingerprint(fingerprint);
+        }
+    }
+    // Inject the fingerprint into the config
+    mergeInto(config, fromBrowserforge(fingerprint, ff_version_str));
+    const targetOS = getTargetOS(config);
+    // Set a random window.history.length
+    setInto(config, "window.history.length", Math.floor(Math.random() * 5) + 1);
+    // Update fonts list
+    if (fonts) {
+        config.fonts = fonts;
+    }
+    if (custom_fonts_only) {
+        firefox_user_prefs["gfx.bundled-fonts.activate"] = 0;
+        if (fonts) {
+            // The user has passed their own fonts, and OS fonts are disabled.
+            LeakWarning.warn("custom_fonts_only");
+        }
+        else {
+            // OS fonts are disabled, and the user has not passed their own fonts either.
+            throw new Error("No custom fonts were passed, but `custom_fonts_only` is enabled.");
+        }
+    }
+    else {
+        updateFonts(config, targetOS);
+    }
+    // Set a fixed font spacing seed
+    setInto(config, "fonts:spacing_seed", Math.floor(Math.random() * 1_073_741_824));
+    // Handle proxy
+    const proxyUrl = getProxyUrl(proxy);
+    // Set geolocation
+    if (geoip) {
+        geoipAllowed();
+        // Find the user's IP address
+        geoip = await publicIP(proxyUrl?.href);
+        // Spoof WebRTC if not blocked
+        if (!block_webrtc) {
+            if (validIPv4(geoip)) {
+                setInto(config, "webrtc:ipv4", geoip);
+                firefox_user_prefs["network.dns.disableIPv6"] = true;
+            }
+            else if (validIPv6(geoip)) {
+                setInto(config, "webrtc:ipv6", geoip);
+            }
+        }
+        const geolocation = await getGeolocation(geoip);
+        config = { ...config, ...geolocation.asConfig() };
+    }
+    // Raise a warning when a proxy is being used without spoofing geolocation.
+    // This is a very bad idea; the warning cannot be ignored with i_know_what_im_doing.
+    if (proxyUrl &&
+        !proxyUrl.hostname.includes("localhost") &&
+        !isDomainSet(config, "geolocation:")) {
+        LeakWarning.warn("proxy_without_geoip");
+    }
+    // Set locale
+    if (locale) {
+        handleLocales(locale, config);
+    }
+    // Pass the humanize option
+    if (humanize) {
+        setInto(config, "humanize", true);
+        if (typeof humanize === "number") {
+            setInto(config, "humanize:maxTime", humanize);
+        }
+    }
+    // Enable the main world context creation
+    if (main_world_eval) {
+        setInto(config, "allowMainWorld", true);
+    }
+    // Set Firefox user preferences
+    if (block_images) {
+        LeakWarning.warn("block_images", i_know_what_im_doing);
+        firefox_user_prefs["permissions.default.image"] = 2;
+    }
+    if (block_webrtc) {
+        firefox_user_prefs["media.peerconnection.enabled"] = false;
+    }
+    if (disable_coop) {
+        LeakWarning.warn("disable_coop", i_know_what_im_doing);
+        firefox_user_prefs["browser.tabs.remote.useCrossOriginOpenerPolicy"] =
+            false;
+    }
+    // Allow allow_webgl parameter for backwards compatibility
+    if (block_webgl || launch_options.allow_webgl === false) {
+        firefox_user_prefs["webgl.disabled"] = true;
+        LeakWarning.warn("block_webgl", i_know_what_im_doing);
+    }
+    else {
+        // If the user has provided a specific WebGL vendor/renderer pair, use it
+        let webgl_fp;
+        if (webgl_config) {
+            webgl_fp = await sampleWebGL(targetOS, ...webgl_config);
+        }
+        else {
+            webgl_fp = await sampleWebGL(targetOS);
+        }
+        const { webGl2Enabled, ...webGlConfig } = webgl_fp;
+        // Merge the WebGL fingerprint into the config
+        mergeInto(config, webGlConfig);
+        // Set the WebGL preferences
+        mergeInto(firefox_user_prefs, {
+            "webgl.enable-webgl2": webGl2Enabled,
+            "webgl.force-enabled": true,
+        });
+    }
+    // Canvas anti-fingerprinting
+    mergeInto(config, {
+        "canvas:aaOffset": Math.floor(Math.random() * 101) - 50, // nosec
+        "canvas:aaCapOffset": true,
+    });
+    // Cache previous pages, requests, etc (uses more memory)
+    if (enable_cache) {
+        mergeInto(firefox_user_prefs, CACHE_PREFS);
+    }
+    // Print the config if debug is enabled
+    if (debug) {
+        console.debug("[DEBUG] Config:");
+        console.debug(config);
+    }
+    // Validate the config
+    validateConfig(config, executable_path);
+    //Prepare environment variables to pass to Camoufox
+    const env_vars = {
+        ...getEnvVars(config, targetOS),
+        ...process.env,
+    };
+    // Prepare the executable path
+    if (executable_path) {
+        executable_path = executable_path.toString();
+    }
+    else {
+        executable_path = launchPath();
+    }
+    const out = {
+        executablePath: executable_path,
+        args: args,
+        env: env_vars,
+        firefoxUserPrefs: firefox_user_prefs,
+        proxy: proxyUrl
+            ? {
+                server: proxyUrl.origin,
+                username: proxyUrl.username,
+                password: proxyUrl.password,
+                bypass: typeof proxy === "string" ? undefined : proxy?.bypass,
+            }
+            : undefined,
+        headless: headless,
+        ...launch_options,
+    };
+    return out;
+}

package/dist/virtdisplay.d.ts

@@ -0,0 +1,20 @@
+export declare class VirtualDisplay {
+    private debug;
+    private proc;
+    private _display;
+    constructor(debug?: boolean);
+    private get xvfb_args();
+    private get xvfb_path();
+    private get xvfb_cmd();
+    private execute_xvfb;
+    get(): string;
+    kill(): void;
+    /**
+     * Get list of lock files in /tmp
+     * @returns List of lock file paths
+     */
+    static _get_lock_files(): string[];
+    private static _free_display;
+    private get display();
+    private static assert_linux;
+}

package/dist/virtdisplay.js

@@ -0,0 +1,123 @@
+import { execFileSync, spawn } from "node:child_process";
+import { randomInt } from "node:crypto";
+import { existsSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { globSync } from "glob";
+import { CannotExecuteXvfb, CannotFindXvfb, VirtualDisplayNotSupported, } from "./exceptions.js";
+import { OS_NAME } from "./pkgman.js";
+export class VirtualDisplay {
+    debug;
+    proc = null;
+    _display = null;
+    // private _lock = new Lock();
+    constructor(debug = false) {
+        this.debug = debug;
+    }
+    get xvfb_args() {
+        return [
+            "-screen",
+            "0",
+            "1x1x24",
+            "-ac",
+            "-nolisten",
+            "tcp",
+            "-extension",
+            "RENDER",
+            "+extension",
+            "GLX",
+            "-extension",
+            "COMPOSITE",
+            "-extension",
+            "XVideo",
+            "-extension",
+            "XVideo-MotionCompensation",
+            "-extension",
+            "XINERAMA",
+            "-shmem",
+            "-fp",
+            "built-ins",
+            "-nocursor",
+            "-br",
+        ];
+    }
+    get xvfb_path() {
+        const path = execFileSync("which", ["Xvfb"]).toString().trim();
+        if (!path) {
+            throw new CannotFindXvfb("Please install Xvfb to use headless mode.");
+        }
+        if (!existsSync(path) || !execFileSync("test", ["-x", path])) {
+            throw new CannotExecuteXvfb(`I do not have permission to execute Xvfb: ${path}`);
+        }
+        return path;
+    }
+    get xvfb_cmd() {
+        return [this.xvfb_path, `:${this.display}`, ...this.xvfb_args];
+    }
+    execute_xvfb() {
+        if (this.debug) {
+            console.log("Starting virtual display:", this.xvfb_cmd.join(" "));
+        }
+        this.proc = spawn(this.xvfb_cmd[0], this.xvfb_cmd.slice(1), {
+            stdio: this.debug ? "inherit" : "ignore",
+            detached: true,
+        });
+    }
+    get() {
+        VirtualDisplay.assert_linux();
+        // this._lock.runExclusive(() => {
+        if (!this.proc) {
+            this.execute_xvfb();
+        }
+        else if (this.debug) {
+            console.log(`Using virtual display: ${this.display}`);
+        }
+        // });
+        return `:${this.display}`;
+    }
+    kill() {
+        // this._lock.runExclusive(() => {
+        if (this.proc && !this.proc.killed) {
+            if (this.debug) {
+                console.log("Terminating virtual display:", this.display);
+            }
+            this.proc.kill();
+        }
+        // });
+    }
+    /**
+     * Get list of lock files in /tmp
+     * @returns List of lock file paths
+     */
+    static _get_lock_files() {
+        const tmpd = process.env.TMPDIR || tmpdir();
+        try {
+            return globSync(path.join(tmpd, ".X*-lock")).filter((p) => {
+                try {
+                    return statSync(p).isFile();
+                }
+                catch {
+                    return false;
+                }
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    static _free_display() {
+        const ls = VirtualDisplay._get_lock_files().map((x) => parseInt(x.split("X")[1].split("-")[0], 10));
+        return ls.length ? Math.max(99, Math.max(...ls) + randomInt(3, 20)) : 99;
+    }
+    get display() {
+        if (this._display === null) {
+            this._display = VirtualDisplay._free_display();
+        }
+        return this._display;
+    }
+    static assert_linux() {
+        if (OS_NAME !== "lin") {
+            throw new VirtualDisplayNotSupported("Virtual display is only supported on Linux.");
+        }
+    }
+}

package/dist/warnings.d.ts

@@ -0,0 +1,4 @@
+export declare class LeakWarning extends Error {
+    constructor(message: string);
+    static warn(warningKey: string, iKnowWhatImDoing?: boolean): void;
+}

package/dist/warnings.js

@@ -0,0 +1,30 @@
+import WARNINGS_DATA from "./mappings/warnings.config.js";
+export class LeakWarning extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "LeakWarning";
+    }
+    static warn(warningKey, iKnowWhatImDoing) {
+        let warning = WARNINGS_DATA[warningKey];
+        if (iKnowWhatImDoing) {
+            return;
+        }
+        if (iKnowWhatImDoing !== undefined) {
+            warning += "\nIf this is intentional, pass `iKnowWhatImDoing=true`.";
+        }
+        const currentModule = import.meta.dirname;
+        const originalStackTrace = Error.prepareStackTrace;
+        Error.prepareStackTrace = (_, stack) => stack;
+        const err = new Error();
+        const stack = err.stack;
+        Error.prepareStackTrace = originalStackTrace;
+        for (const frame of stack) {
+            const frameFileName = frame.getFileName();
+            if (frameFileName && !frameFileName.startsWith(currentModule)) {
+                console.warn(`${warning} at ${frameFileName}:${frame.getLineNumber()}`);
+                return;
+            }
+        }
+        console.warn(warning);
+    }
+}

package/dist/webgl/db-compat.d.ts

@@ -0,0 +1,9 @@
+interface DatabaseWrapper {
+    prepare(sql: string): StatementWrapper;
+    close(): void;
+}
+interface StatementWrapper {
+    all(...params: any[]): any[];
+}
+export declare function openDatabase(dbPath: string): DatabaseWrapper;
+export {};