extension-install 3.7.0-canary.172.1e95d6a

package/README.md

@@ -0,0 +1,25 @@
+# extension-install
+
+Managed browser installer/uninstaller runtime for Extension.js CLI.
+
+This package powers:
+
+- `extension install --browser <browser>`
+- `extension install --where`
+- `extension uninstall <browser>`
+- `extension uninstall --all`
+- `extension uninstall --where`
+
+When `--where` is used together with `--browser` (or `--all` on uninstall), Extension.js prints the resolved managed install path(s) for those target browsers. Without a target, it prints the managed cache root.
+
+Uninstall scope is limited to the Extension.js managed cache root (or `EXT_BROWSERS_CACHE_DIR` when set). It does not remove browser installations outside that managed location.
+
+Linux note for `edge`: Playwright channel installs may require a privileged interactive session (`sudo` prompt). If channel install cannot proceed but a system Edge binary is already present, Extension.js will use that existing binary. Otherwise, install Edge system-wide first and then run Extension.js with `--browser=edge` (or use `chromium`).
+
+Default managed cache locations are stable and human-readable:
+- macOS: `~/Library/Caches/extension.js/browsers`
+- Linux: `~/.cache/extension.js/browsers` (or `$XDG_CACHE_HOME/extension.js/browsers`)
+- Windows: `%LOCALAPPDATA%\\extension.js\\browsers`
+
+Custom path override example:
+- `EXT_BROWSERS_CACHE_DIR=/tmp/extension.js/browsers-dev`

package/dist/lib/browser-target.d.ts

@@ -0,0 +1,2 @@
+export type InstallBrowserTarget = 'chrome' | 'chromium' | 'edge' | 'firefox';
+export declare function normalizeBrowserName(input: string): InstallBrowserTarget;

package/dist/lib/cache-root.d.ts

@@ -0,0 +1,7 @@
+import { InstallBrowserTarget } from './browser-target';
+export declare function resolveBrowsersCacheRoot(): string;
+export declare function resolveBrowserInstallDir(browser: InstallBrowserTarget): string;
+export declare function removeBrowserDir(browser: InstallBrowserTarget): {
+    path: string;
+    removed: boolean;
+};

package/dist/lib/messages.d.ts

@@ -0,0 +1,10 @@
+import { InstallBrowserTarget } from './browser-target';
+export declare function installingBrowser(browser: InstallBrowserTarget, destination: string): string;
+export declare function installSucceeded(browser: InstallBrowserTarget, destination: string): string;
+export declare function installFailed(browser: InstallBrowserTarget, command: string, args: string[], code: number | null, stderr: string): string;
+export declare function edgeInstallNeedsInteractivePrivilegedSession(): string;
+export declare function edgeInstallUsingSystemBinary(path: string): string;
+export declare function uninstallRequiresTarget(): string;
+export declare function uninstallingBrowsers(cacheRoot: string, browsers: InstallBrowserTarget[]): string;
+export declare function uninstallSucceeded(browser: InstallBrowserTarget, removedPath: string): string;
+export declare function uninstallNoop(browser: InstallBrowserTarget, checkedPath: string): string;

package/dist/lib/runner.d.ts

@@ -0,0 +1,15 @@
+import { InstallBrowserTarget } from './browser-target';
+export declare function browserInstallCommand(_target: InstallBrowserTarget): string;
+export declare function browserInstallArgs(target: InstallBrowserTarget, destination: string): string[];
+export declare function browserInstallEnv(target: InstallBrowserTarget, destination: string): NodeJS.ProcessEnv;
+export declare function runCommand(command: string, args: string[], opts: {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}): Promise<{
+    code: number | null;
+    stdout: string;
+    stderr: string;
+}>;
+export declare function edgeInstallNeedsInteractivePrivilegedSession(): boolean;
+export declare function isEdgePrivilegeEscalationFailure(stderr: string): boolean;
+export declare function detectSystemEdgeBinary(): string | null;

package/dist/module.cjs

@@ -0,0 +1,302 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getManagedBrowserInstallDir: ()=>getManagedBrowserInstallDir,
+    extensionInstall: ()=>extensionInstall,
+    extensionUninstall: ()=>extensionUninstall,
+    getManagedBrowsersCacheRoot: ()=>getManagedBrowsersCacheRoot
+});
+const external_pintor_namespaceObject = require("pintor");
+var external_pintor_default = /*#__PURE__*/ __webpack_require__.n(external_pintor_namespaceObject);
+const statusPrefix = external_pintor_default().brightBlue('►►►');
+function titleCase(value) {
+    return value.length ? value[0].toUpperCase() + value.slice(1) : value;
+}
+function installingBrowser(browser, destination) {
+    return `${statusPrefix} Installing ${external_pintor_default().blue(titleCase(browser))} into ${external_pintor_default().underline(destination)}...`;
+}
+function installSucceeded(browser, destination) {
+    return `${statusPrefix} ${external_pintor_default().green('Installed')} ${external_pintor_default().blue(titleCase(browser))} in ${external_pintor_default().underline(destination)}`;
+}
+function installFailed(browser, command, args, code, stderr) {
+    const details = String(stderr || '').trim();
+    const detailSuffix = details ? `\n${external_pintor_default().red(details)}` : '';
+    return `${external_pintor_default().red('Error')} Failed to install ${external_pintor_default().blue(titleCase(browser))}.\nCommand: ${external_pintor_default().yellow(command)} ${external_pintor_default().yellow(args.join(' '))}\nExit code: ${external_pintor_default().yellow(String(code))}` + detailSuffix;
+}
+function edgeInstallNeedsInteractivePrivilegedSession() {
+    return `${external_pintor_default().red('Error')} Edge installation on Linux requires a privileged interactive session.\nRun this command in a terminal session where sudo can prompt for credentials, or install Edge system-wide with your package manager.\nExamples:\n- Ubuntu/Debian: ${external_pintor_default().blue('sudo apt install microsoft-edge-stable')}\n- Fedora: ${external_pintor_default().blue('sudo dnf install microsoft-edge-stable')}\nThen run Extension.js with ${external_pintor_default().blue('--browser=edge')} (or use ${external_pintor_default().blue('chromium')} when privileged install is unavailable).`;
+}
+function edgeInstallUsingSystemBinary(path) {
+    return `${statusPrefix} ${external_pintor_default().yellow('Edge channel install was skipped due privilege requirements.')}\n${statusPrefix} Using existing system Edge binary at ${external_pintor_default().underline(path)}.`;
+}
+function uninstallRequiresTarget() {
+    return `${external_pintor_default().red('Error')} Missing browser target. Use --browser <name> or --all.`;
+}
+function uninstallingBrowsers(cacheRoot, browsers) {
+    return `${statusPrefix} Removing browser binaries (${browsers.join(', ')}) from ${external_pintor_default().underline(cacheRoot)}...`;
+}
+function uninstallSucceeded(browser, removedPath) {
+    return `${statusPrefix} ${external_pintor_default().green('Removed')} ${external_pintor_default().blue(titleCase(browser))} from ${external_pintor_default().underline(removedPath)}`;
+}
+function uninstallNoop(browser, checkedPath) {
+    return `${statusPrefix} ${external_pintor_default().gray(`${titleCase(browser)} is already absent`)} (${external_pintor_default().underline(checkedPath)})`;
+}
+const BROWSER_ALIASES = {
+    chrome: 'chrome',
+    chromium: 'chromium',
+    edge: 'edge',
+    firefox: 'firefox',
+    'chromium-based': 'chromium',
+    'gecko-based': 'firefox',
+    'firefox-based': 'firefox'
+};
+function normalizeBrowserName(input) {
+    const value = String(input || '').trim().toLowerCase();
+    const resolved = BROWSER_ALIASES[value];
+    if (resolved) return resolved;
+    throw new Error(`Unsupported browser "${value}". Supported values: ${Object.keys(BROWSER_ALIASES).join(', ')}`);
+}
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_cross_spawn_namespaceObject = require("cross-spawn");
+function buildExecEnv(base) {
+    if ('win32' !== process.platform) return base;
+    const nodeDir = external_node_path_default().dirname(process.execPath);
+    const pathSep = external_node_path_default().delimiter;
+    const existing = base.PATH || base.Path || '';
+    if (existing.includes(nodeDir)) return base;
+    const updated = `${nodeDir}${pathSep}${existing}`.trim();
+    return {
+        ...base,
+        PATH: updated,
+        Path: updated
+    };
+}
+function browserInstallCommand(_target) {
+    return 'win32' === process.platform ? 'npx.cmd' : 'npx';
+}
+function browserInstallArgs(target, destination) {
+    if ('edge' === target) return [
+        '-y',
+        'playwright@latest',
+        'install',
+        'msedge'
+    ];
+    const browserRef = 'chrome' === target ? 'chrome@stable' : target;
+    return [
+        '-y',
+        '@puppeteer/browsers@latest',
+        'install',
+        browserRef,
+        '--path',
+        destination
+    ];
+}
+function browserInstallEnv(target, destination) {
+    if ('edge' === target) return {
+        ...process.env,
+        PLAYWRIGHT_BROWSERS_PATH: destination
+    };
+    return {
+        ...process.env
+    };
+}
+async function runCommand(command, args, opts) {
+    const child = (0, external_cross_spawn_namespaceObject.spawn)(command, args, {
+        cwd: opts.cwd,
+        env: buildExecEnv(opts.env),
+        stdio: 'pipe'
+    });
+    let stdout = '';
+    let stderr = '';
+    if (child.stdout) child.stdout.on('data', (chunk)=>{
+        stdout += chunk.toString();
+        process.stdout.write(chunk);
+    });
+    if (child.stderr) child.stderr.on('data', (chunk)=>{
+        stderr += chunk.toString();
+        process.stderr.write(chunk);
+    });
+    return new Promise((resolve, reject)=>{
+        child.on('close', (code)=>resolve({
+                code,
+                stdout,
+                stderr
+            }));
+        child.on('error', (error)=>reject(error));
+    });
+}
+function runner_edgeInstallNeedsInteractivePrivilegedSession() {
+    return 'linux' === process.platform && !Boolean(process.stdin?.isTTY);
+}
+function isEdgePrivilegeEscalationFailure(stderr) {
+    const text = String(stderr || '');
+    return /switching to root user to install dependencies/i.test(text) || /sudo:\s+a password is required/i.test(text) || /sudo:\s+a terminal is required/i.test(text);
+}
+function detectSystemEdgeBinary() {
+    if ('darwin' === process.platform) {
+        const macPath = '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge';
+        return external_node_fs_default().existsSync(macPath) ? macPath : null;
+    }
+    if ('win32' === process.platform) {
+        const result = (0, external_node_child_process_namespaceObject.spawnSync)('where', [
+            'msedge'
+        ], {
+            stdio: 'pipe',
+            encoding: 'utf8'
+        });
+        result.status;
+        return null;
+    }
+    const candidates = [
+        'microsoft-edge-stable',
+        'microsoft-edge',
+        'msedge'
+    ];
+    for (const cmd of candidates){
+        const result = (0, external_node_child_process_namespaceObject.spawnSync)('which', [
+            cmd
+        ], {
+            stdio: 'pipe',
+            encoding: 'utf8'
+        });
+        result.status;
+    }
+    return null;
+}
+function resolveBrowsersCacheRoot() {
+    const explicit = String(process.env.EXT_BROWSERS_CACHE_DIR || '').trim();
+    if (explicit) return external_node_path_default().resolve(explicit);
+    const isWin = 'win32' === process.platform;
+    const isMac = 'darwin' === process.platform;
+    if (isWin) {
+        const local = String(process.env.LOCALAPPDATA || '').trim();
+        if (local) return external_node_path_default().join(local, 'extension.js', 'browsers');
+        const userProfile = String(process.env.USERPROFILE || '').trim();
+        if (userProfile) return external_node_path_default().join(userProfile, 'AppData', 'Local', 'extension.js', 'browsers');
+        return external_node_path_default().resolve(process.cwd(), '.cache', 'extension.js', 'browsers');
+    }
+    if (isMac) {
+        const home = String(process.env.HOME || '').trim();
+        if (home) return external_node_path_default().join(home, 'Library', 'Caches', 'extension.js', 'browsers');
+        return external_node_path_default().resolve(process.cwd(), '.cache', 'extension.js', 'browsers');
+    }
+    const xdg = String(process.env.XDG_CACHE_HOME || '').trim();
+    if (xdg) return external_node_path_default().join(xdg, 'extension.js', 'browsers');
+    const home = String(process.env.HOME || '').trim();
+    if (home) return external_node_path_default().join(home, '.cache', 'extension.js', 'browsers');
+    return external_node_path_default().resolve(process.cwd(), '.cache', 'extension.js', 'browsers');
+}
+function resolveBrowserInstallDir(browser) {
+    return external_node_path_default().join(resolveBrowsersCacheRoot(), browser);
+}
+function removeBrowserDir(browser) {
+    const installDir = resolveBrowserInstallDir(browser);
+    if (!external_node_fs_default().existsSync(installDir)) return {
+        path: installDir,
+        removed: false
+    };
+    external_node_fs_default().rmSync(installDir, {
+        recursive: true,
+        force: true
+    });
+    return {
+        path: installDir,
+        removed: true
+    };
+}
+function getManagedBrowsersCacheRoot() {
+    return resolveBrowsersCacheRoot();
+}
+function getManagedBrowserInstallDir(browser) {
+    const target = normalizeBrowserName(browser);
+    return resolveBrowserInstallDir(target);
+}
+async function extensionInstall({ browser }) {
+    const target = normalizeBrowserName(browser);
+    const destination = resolveBrowserInstallDir(target);
+    if ('edge' === target && runner_edgeInstallNeedsInteractivePrivilegedSession()) throw new Error(edgeInstallNeedsInteractivePrivilegedSession());
+    console.log(installingBrowser(target, destination));
+    const cmd = browserInstallCommand(target);
+    const args = browserInstallArgs(target, destination);
+    const env = browserInstallEnv(target, destination);
+    const result = await runCommand(cmd, args, {
+        cwd: process.cwd(),
+        env
+    });
+    if (0 !== result.code) {
+        if ('edge' === target && isEdgePrivilegeEscalationFailure(result.stderr)) {
+            const systemEdge = detectSystemEdgeBinary();
+            if (systemEdge) return void console.log(edgeInstallUsingSystemBinary(systemEdge));
+            throw new Error(edgeInstallNeedsInteractivePrivilegedSession());
+        }
+        throw new Error(installFailed(target, cmd, args, result.code, result.stderr));
+    }
+    console.log(installSucceeded(target, destination));
+}
+async function extensionUninstall({ browser, all }) {
+    const cacheRoot = resolveBrowsersCacheRoot();
+    if (!all && !browser) throw new Error(uninstallRequiresTarget());
+    const targets = all ? [
+        'chrome',
+        'chromium',
+        'edge',
+        'firefox'
+    ] : [
+        normalizeBrowserName(String(browser || ''))
+    ];
+    console.log(uninstallingBrowsers(cacheRoot, targets));
+    for (const target of targets){
+        const result = removeBrowserDir(target);
+        if (result.removed) console.log(uninstallSucceeded(target, result.path));
+        else console.log(uninstallNoop(target, result.path));
+    }
+}
+exports.extensionInstall = __webpack_exports__.extensionInstall;
+exports.extensionUninstall = __webpack_exports__.extensionUninstall;
+exports.getManagedBrowserInstallDir = __webpack_exports__.getManagedBrowserInstallDir;
+exports.getManagedBrowsersCacheRoot = __webpack_exports__.getManagedBrowsersCacheRoot;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "extensionInstall",
+    "extensionUninstall",
+    "getManagedBrowserInstallDir",
+    "getManagedBrowsersCacheRoot"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/module.d.ts

@@ -0,0 +1,11 @@
+export interface InstallOptions {
+    browser: string;
+}
+export interface UninstallOptions {
+    browser?: string;
+    all?: boolean;
+}
+export declare function getManagedBrowsersCacheRoot(): string;
+export declare function getManagedBrowserInstallDir(browser: string): string;
+export declare function extensionInstall({ browser }: InstallOptions): Promise<void>;
+export declare function extensionUninstall({ browser, all }: UninstallOptions): Promise<void>;

package/dist/rslib.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@rslib/core").RslibConfig;
+export default _default;

package/dist/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/package.json

@@ -0,0 +1,67 @@
+{
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/extension-js/extension.js.git",
+    "directory": "programs/install"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "exports": {
+    ".": {
+      "development": "./module.ts",
+      "types": "./dist/module.d.ts",
+      "import": "./dist/module.cjs",
+      "require": "./dist/module.cjs"
+    }
+  },
+  "main": "./dist/module.cjs",
+  "types": "./dist/module.d.ts",
+  "files": [
+    "dist"
+  ],
+  "name": "extension-install",
+  "version": "3.7.0-canary.172.1e95d6a",
+  "description": "Managed browser installer/uninstaller for Extension.js",
+  "author": {
+    "name": "Cezar Augusto",
+    "email": "boss@cezaraugusto.net",
+    "url": "https://cezaraugusto.com"
+  },
+  "homepage": "https://github.com/extension-js/extension.js/tree/main/programs/install#readme",
+  "bugs": {
+    "url": "https://github.com/extension-js/extension.js/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "watch": "rslib build --watch",
+    "compile": "rslib build",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "webextension",
+    "browser-extension",
+    "extensionjs",
+    "browser-installer",
+    "chrome",
+    "chromium",
+    "edge",
+    "firefox"
+  ],
+  "dependencies": {
+    "cross-spawn": "^7.0.6",
+    "pintor": "0.3.0"
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.19.4",
+    "@types/node": "^25.2.0",
+    "tsconfig": "*",
+    "typescript": "5.9.3",
+    "vitest": "^4.0.17"
+  }
+}