arn-browser 0.0.2 → 0.0.3

package/dist/__main__.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/__main__.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+import { existsSync, rmSync } from "node:fs";
+import { Command } from "commander";
+import { DefaultAddons, maybeDownloadAddons } from "./addons.js";
+import { ALLOW_GEOIP, downloadMMDB, removeMMDB } from "./locale.js";
+import { CamoufoxFetcher, INSTALL_DIR, installedVerStr } from "./pkgman.js";
+import { launchServer } from "./server.js";
+import { Camoufox } from "./sync_api.js";
+import { getAsBooleanFromENV } from "./utils.js";
+class CamoufoxUpdate extends CamoufoxFetcher {
+    currentVerStr;
+    constructor() {
+        super();
+        this.currentVerStr = null;
+        try {
+            this.currentVerStr = installedVerStr();
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "FileNotFoundError") {
+                this.currentVerStr = null;
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    static async create() {
+        const updater = new CamoufoxUpdate();
+        await updater.init();
+        return updater;
+    }
+    isUpdateNeeded() {
+        if (getAsBooleanFromENV("PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD", false)) {
+            console.log("Skipping browser download / update check due to PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD set!");
+            return false;
+        }
+        return this.currentVerStr === null || this.currentVerStr !== this.verstr;
+    }
+    async update() {
+        if (!this.isUpdateNeeded()) {
+            console.log("Camoufox binaries up to date!");
+            console.log(`Current version: v${this.currentVerStr}`);
+            return;
+        }
+        if (this.currentVerStr !== null) {
+            console.log(`Updating Camoufox binaries from v${this.currentVerStr} => v${this.verstr}`, "yellow");
+        }
+        else {
+            console.log(`Fetching Camoufox binaries...`);
+        }
+        await this.install();
+    }
+    async cleanup() {
+        if (!existsSync(INSTALL_DIR)) {
+            return false;
+        }
+        await rmSync(INSTALL_DIR, { recursive: true, force: true });
+        console.log("Camoufox binaries removed!");
+        return true;
+    }
+}
+const program = new Command();
+program.command("fetch").action(async () => {
+    const updater = await CamoufoxUpdate.create();
+    await updater.update();
+    if (ALLOW_GEOIP) {
+        downloadMMDB();
+    }
+    maybeDownloadAddons(DefaultAddons);
+});
+program.command("remove").action(async () => {
+    const updater = await CamoufoxUpdate.create();
+    if (!(await updater.cleanup())) {
+        console.log("Camoufox binaries not found!", "red");
+    }
+    removeMMDB();
+});
+program
+    .command("test")
+    .argument("[url]", "URL to open", null)
+    .action(async (url) => {
+    const browser = await Camoufox({
+        headless: false,
+        env: process.env,
+        config: { showcursor: true },
+        humanize: 0.5,
+        geoip: true,
+    });
+    const page = await browser.newPage();
+    if (url) {
+        await page.goto(url);
+    }
+    await page.pause();
+});
+program.command("server").action(async () => {
+    const server = await launchServer({});
+    console.log(`Camoufox server started at ${server.wsEndpoint()}`);
+    console.log();
+    console.log(`You can connect to it using Playwright's BrowserType.connect() method.`);
+    console.log(`To stop the server, press Ctrl+C or close this terminal.`);
+});
+program.command("path").action(() => {
+    console.log(INSTALL_DIR);
+});
+program.command("version").action(async () => {
+    try {
+        const pkgVersion = require("pkg-version");
+        console.log(`Pip package:\tv${pkgVersion("camoufox")}`);
+    }
+    catch (_error) {
+        console.log("Pip package:\tNot installed!", "red");
+    }
+    const updater = await CamoufoxUpdate.create();
+    const binVer = updater.currentVerStr;
+    if (!binVer) {
+        console.log("Camoufox:\tNot downloaded!", "red");
+        return;
+    }
+    console.log(`Camoufox:\tv${binVer} `, "green", false);
+    if (updater.isUpdateNeeded()) {
+        console.log(`(Latest supported: v${updater.verstr})`, "red");
+    }
+    else {
+        console.log("(Up to date!)", "yellow");
+    }
+});
+program.parse(process.argv);

package/dist/__version__.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Camoufox version constants.
+ */
+export declare class CONSTRAINTS {
+    /**
+     * The minimum and maximum supported versions of the Camoufox browser.
+     */
+    static readonly MIN_VERSION: string;
+    static readonly MAX_VERSION: string;
+    static asRange(): string;
+}

package/dist/__version__.js

@@ -0,0 +1,16 @@
+/**
+ * Camoufox version constants.
+ */
+export class CONSTRAINTS {
+    /**
+     * The minimum and maximum supported versions of the Camoufox browser.
+     */
+    static MIN_VERSION = "beta.19";
+    static MAX_VERSION = "1";
+    static asRange() {
+        /**
+         * Returns the version range as a string.
+         */
+        return `>=${CONSTRAINTS.MIN_VERSION}, <${CONSTRAINTS.MAX_VERSION}`;
+    }
+}

package/dist/addons.d.ts

@@ -0,0 +1,17 @@
+export declare const DefaultAddons: {
+    /**
+     * Default addons to be downloaded
+     */
+    UBO: string;
+};
+export declare function confirmPaths(paths: string[]): void;
+export declare function addDefaultAddons(_addonsList: string[], _excludeList?: (keyof typeof DefaultAddons)[]): void;
+/**
+ * Downloads and extracts an addon from a given URL to a specified path
+ */
+export declare function downloadAndExtract(url: string, extractPath: string, name: string): Promise<void>;
+/**
+ * Downloads and extracts addons from a given dictionary to a specified list
+ * Skips downloading if the addon is already downloaded
+ */
+export declare function maybeDownloadAddons(addons: Record<string, string>, addonsList?: string[]): void;

package/dist/addons.js

@@ -0,0 +1,70 @@
+import fs from "node:fs";
+import { join } from "node:path";
+import { InvalidAddonPath } from "./exceptions.js";
+import { getPath, unzip, webdl } from "./pkgman.js";
+import { getAsBooleanFromENV } from "./utils.js";
+export const DefaultAddons = {
+    /**
+     * Default addons to be downloaded
+     */
+    UBO: "https://addons.mozilla.org/firefox/downloads/latest/ublock-origin/latest.xpi",
+};
+export function confirmPaths(paths) {
+    /**
+     * Confirms that the addon paths are valid
+     */
+    for (const path of paths) {
+        if (!fs.existsSync(path) || !fs.lstatSync(path).isDirectory()) {
+            throw new InvalidAddonPath(path);
+        }
+        if (!fs.existsSync(join(path, "manifest.json"))) {
+            throw new InvalidAddonPath("manifest.json is missing. Addon path must be a path to an extracted addon.");
+        }
+    }
+}
+export function addDefaultAddons(_addonsList, _excludeList = []) {
+    // TODO - enable addons
+    /**
+     * Adds default addons, minus any specified in excludeList, to addonsList
+     */
+    // const addons = Object.values(DefaultAddons).filter(addon => !excludeList.includes(addon as keyof typeof DefaultAddons));
+    // maybeDownloadAddons(addons, addonsList);
+}
+/**
+ * Downloads and extracts an addon from a given URL to a specified path
+ */
+export async function downloadAndExtract(url, extractPath, name) {
+    const buffer = await webdl(url, `Downloading addon (${name})`, false);
+    unzip(buffer, extractPath, `Extracting addon (${name})`, false);
+}
+/**
+ * Returns a path to the addon
+ */
+function getAddonPath(addonName) {
+    return getPath(join("addons", addonName));
+}
+/**
+ * Downloads and extracts addons from a given dictionary to a specified list
+ * Skips downloading if the addon is already downloaded
+ */
+export function maybeDownloadAddons(addons, addonsList = []) {
+    if (getAsBooleanFromENV("PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD", false)) {
+        console.log("Skipping addon download due to PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD set!");
+        return;
+    }
+    for (const addonName in addons) {
+        const addonPath = getAddonPath(addonName);
+        if (fs.existsSync(addonPath)) {
+            addonsList.push(addonPath);
+            continue;
+        }
+        try {
+            fs.mkdirSync(addonPath, { recursive: true });
+            downloadAndExtract(addons[addonName], addonPath, addonName);
+            addonsList.push(addonPath);
+        }
+        catch (e) {
+            console.error(`Failed to download and extract ${addonName}: ${e}`);
+        }
+    }
+}