extension-from-store 0.1.1 → 0.2.0

package/dist/core.js

@@ -0,0 +1,222 @@
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class extensionFromStoreError extends Error {
+    constructor(code, message, cause){
+        super(message), _define_property(this, "code", void 0), _define_property(this, "cause", void 0);
+        this.code = code;
+        this.cause = cause;
+    }
+}
+function asExtensionFromStoreError(error, fallback) {
+    if (error instanceof extensionFromStoreError) return error;
+    return new extensionFromStoreError(fallback.code, fallback.message, error);
+}
+function createLogger(logger) {
+    return {
+        info: (message)=>{
+            var _logger_onInfo;
+            return null == logger ? void 0 : null == (_logger_onInfo = logger.onInfo) ? void 0 : _logger_onInfo.call(logger, message);
+        },
+        warn: (message)=>{
+            var _logger_onWarn;
+            return null == logger ? void 0 : null == (_logger_onWarn = logger.onWarn) ? void 0 : _logger_onWarn.call(logger, message);
+        },
+        error: (message, error)=>{
+            var _logger_onError;
+            return null == logger ? void 0 : null == (_logger_onError = logger.onError) ? void 0 : _logger_onError.call(logger, message, error);
+        }
+    };
+}
+function parseManifestInfo(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    } catch (error) {
+        throw new extensionFromStoreError('ExtractionFailed', 'manifest.json is not valid JSON', error);
+    }
+    if (!parsed || 'object' != typeof parsed || Array.isArray(parsed)) throw new extensionFromStoreError('ExtractionFailed', 'manifest.json must contain an object');
+    const manifest = parsed;
+    const manifestVersion = manifest.manifest_version;
+    const extensionVersion = manifest.version;
+    if (2 !== manifestVersion && 3 !== manifestVersion) throw new extensionFromStoreError('ExtractionFailed', 'manifest_version must be 2 or 3');
+    if (!extensionVersion || 'string' != typeof extensionVersion) throw new extensionFromStoreError('ExtractionFailed', 'manifest.json is missing a version');
+    return {
+        manifest,
+        manifestVersion,
+        extensionVersion
+    };
+}
+function normalizeChromePlatformInfo(platform) {
+    return {
+        os: platform.os,
+        arch: platform.arch,
+        naclArch: platform.naclArch || platform.arch
+    };
+}
+const DEFAULT_CHROME_PLATFORM = {
+    os: 'linux',
+    arch: 'x64'
+};
+function getChromeDownloadUrl(id, platformInfo = DEFAULT_CHROME_PLATFORM) {
+    const encoded = encodeURIComponent(id);
+    const platform = normalizeChromePlatformInfo(platformInfo);
+    const productId = 'chromiumcrx';
+    const productChannel = 'unknown';
+    const productVersion = '9999.0.9999.0';
+    return [
+        'https://clients2.google.com/service/update2/crx',
+        '?response=redirect',
+        `&os=${platform.os}`,
+        `&arch=${platform.arch}`,
+        `&os_arch=${platform.arch}`,
+        `&nacl_arch=${platform.naclArch}`,
+        `&prod=${productId}`,
+        `&prodchannel=${productChannel}`,
+        `&prodversion=${productVersion}`,
+        '&acceptformat=crx2,crx3',
+        `&x=id%3D${encoded}%26uc`
+    ].join('');
+}
+function getEdgeDownloadUrl(id) {
+    const encoded = encodeURIComponent(id);
+    return [
+        'https://edge.microsoft.com/extensionwebstorebase/v1/crx',
+        '?response=redirect',
+        '&prodversion=109.0.0.0',
+        `&x=id%3D${encoded}%26installsource%3Dondemand%26uc`
+    ].join('');
+}
+async function resolveFirefoxDownload(idOrSlug, versionHint, options) {
+    var _addon_current_version_file, _addon_current_version, _addon_current_version1;
+    const baseUrl = `https://addons.mozilla.org/api/v5/addons/addon/${encodeURIComponent(idOrSlug)}/`;
+    const addon = await options.requestJson(baseUrl, options);
+    const slugOrId = addon.slug || idOrSlug;
+    if (versionHint) {
+        var _version_file;
+        const versionUrl = `${baseUrl}versions/${encodeURIComponent(versionHint)}/`;
+        const version = await options.requestJson(versionUrl, options);
+        const downloadUrl = null == (_version_file = version.file) ? void 0 : _version_file.url;
+        if (!downloadUrl) throw new extensionFromStoreError('NotPublic', `Version ${versionHint} is not publicly downloadable`);
+        return {
+            downloadUrl,
+            version: version.version || versionHint,
+            slugOrId
+        };
+    }
+    const downloadUrl = null == (_addon_current_version = addon.current_version) ? void 0 : null == (_addon_current_version_file = _addon_current_version.file) ? void 0 : _addon_current_version_file.url;
+    const version = null == (_addon_current_version1 = addon.current_version) ? void 0 : _addon_current_version1.version;
+    if (!downloadUrl || !version) throw new extensionFromStoreError('NotPublic', 'Extension is not publicly downloadable');
+    return {
+        downloadUrl,
+        version,
+        slugOrId
+    };
+}
+const chromePattern = /^https?:\/\/(?:chrome\.google\.com\/webstore|chromewebstore\.google\.com)\/.+?\/([a-p]{32})(?=[\/#?]|$)/i;
+const chromeDownloadPattern = /^https?:\/\/clients2\.google\.com\/service\/update2\/crx\b.*?%3D([a-p]{32})%26uc/i;
+const edgePattern = /^https?:\/\/microsoftedge\.microsoft\.com\/addons\/.+?\/([a-z]{32})(?=[\/#?]|$)/i;
+const edgeDownloadPattern = /^https?:\/\/edge\.microsoft\.com\/extensionwebstorebase\/v1\/crx\b.*?%3D([a-z]{32})%26/i;
+const firefoxPattern = /^https?:\/\/((?:reviewers\.)?(?:addons\.mozilla\.org|addons(?:-dev)?\.allizom\.org))\/.*?(?:addon|review)\/([^/<>"'?#]+)/i;
+const firefoxDownloadPattern = /^https?:\/\/(addons\.mozilla\.org|addons(?:-dev)?\.allizom\.org)\/[^?#]*\/downloads\/latest\/([^/?#]+)/i;
+function detectStoreFromUrl(url) {
+    if (chromePattern.test(url) || chromeDownloadPattern.test(url)) return 'chrome';
+    if (edgePattern.test(url) || edgeDownloadPattern.test(url)) return 'edge';
+    if (firefoxPattern.test(url) || firefoxDownloadPattern.test(url)) return 'firefox';
+    return null;
+}
+function extractChromeIdFromUrl(url) {
+    const match = chromePattern.exec(url) || chromeDownloadPattern.exec(url);
+    return match ? match[1] : null;
+}
+function extractEdgeIdFromUrl(url) {
+    const match = edgePattern.exec(url) || edgeDownloadPattern.exec(url);
+    return match ? match[1] : null;
+}
+function extractFirefoxSlugFromUrl(url) {
+    const match = firefoxPattern.exec(url) || firefoxDownloadPattern.exec(url);
+    return match ? match[2] : null;
+}
+function validateInput(url) {
+    if (!url || 'string' != typeof url) throw new extensionFromStoreError('InvalidInput', 'URL is required');
+}
+function sanitizeSegment(value, label) {
+    const sanitized = value.replace(/[\\/]/g, '-').trim();
+    if (!sanitized) throw new extensionFromStoreError('InvalidInput', `${label} is not a valid path segment`);
+    return sanitized;
+}
+async function resolveDownload(url, options) {
+    const store = detectStoreFromUrl(url);
+    if (!store) throw new extensionFromStoreError('UnsupportedStore', 'URL does not match a supported store');
+    if ('chrome' === store) {
+        const downloadId = extractChromeIdFromUrl(url);
+        if (!downloadId) throw new extensionFromStoreError('NotFound', 'Chrome extension id not found in URL');
+        return {
+            store,
+            downloadUrl: getChromeDownloadUrl(downloadId, options.platform),
+            archiveType: 'crx',
+            downloadId,
+            slugOrId: downloadId
+        };
+    }
+    if ('edge' === store) {
+        const downloadId = extractEdgeIdFromUrl(url);
+        if (!downloadId) throw new extensionFromStoreError('NotFound', 'Edge extension id not found in URL');
+        return {
+            store,
+            downloadUrl: getEdgeDownloadUrl(downloadId),
+            archiveType: 'crx',
+            downloadId,
+            slugOrId: downloadId
+        };
+    }
+    const slug = extractFirefoxSlugFromUrl(url);
+    if (!slug) throw new extensionFromStoreError('NotFound', 'Firefox extension slug not found in URL');
+    const firefox = await resolveFirefoxDownload(slug, options.version, {
+        userAgent: options.userAgent,
+        logger: options.logger,
+        requestJson: options.requestJson
+    });
+    return {
+        store,
+        downloadUrl: firefox.downloadUrl,
+        archiveType: 'xpi',
+        versionHint: firefox.version,
+        slugOrId: firefox.slugOrId
+    };
+}
+function readUInt32LE(bytes, offset) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset + offset, Uint32Array.BYTES_PER_ELEMENT);
+    return view.getUint32(0, true);
+}
+function readMagic(bytes) {
+    let out = '';
+    const slice = bytes.subarray(0, 4);
+    for(let index = 0; index < slice.length; index += 1)out += String.fromCharCode(slice[index]);
+    return out;
+}
+function stripCrxHeader(buffer) {
+    if (buffer.length < 16) throw new extensionFromStoreError('ExtractionFailed', 'CRX file too small');
+    const magic = readMagic(buffer);
+    if ('Cr24' !== magic) throw new extensionFromStoreError('ExtractionFailed', 'Invalid CRX header');
+    const version = readUInt32LE(buffer, 4);
+    if (2 === version) {
+        const publicKeyLength = readUInt32LE(buffer, 8);
+        const signatureLength = readUInt32LE(buffer, 12);
+        const headerSize = 16 + publicKeyLength + signatureLength;
+        return buffer.subarray(headerSize);
+    }
+    if (3 === version) {
+        const headerSize = readUInt32LE(buffer, 8);
+        return buffer.subarray(12 + headerSize);
+    }
+    throw new extensionFromStoreError('ExtractionFailed', `Unsupported CRX version ${version}`);
+}
+export { asExtensionFromStoreError, createLogger, detectStoreFromUrl, extensionFromStoreError, extractChromeIdFromUrl, extractEdgeIdFromUrl, extractFirefoxSlugFromUrl, getChromeDownloadUrl, getEdgeDownloadUrl, normalizeChromePlatformInfo, parseManifestInfo, resolveDownload, resolveFirefoxDownload, sanitizeSegment, stripCrxHeader, validateInput };

package/dist/crx.d.ts

@@ -0,0 +1 @@
+export declare function stripCrxHeader(buffer: Uint8Array): Uint8Array;

package/dist/extract.d.ts

@@ -1,3 +1,3 @@
-export declare function stripCrxHeader(buffer: Buffer): Buffer;
+export { stripCrxHeader } from './crx';
 export declare function extractCrx(crxPath: string, extractDir: string, workDir: string): Promise<void>;
 export declare function extractZipArchive(zipPath: string, extractDir: string): Promise<void>;

package/dist/index.cjs

@@ -38,18 +38,10 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const promises_namespaceObject = require("node:fs/promises");
 var promises_default = /*#__PURE__*/ __webpack_require__.n(promises_namespaceObject);
-const external_node_path_namespaceObject = require("node:path");
-var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const external_node_os_namespaceObject = require("node:os");
 var external_node_os_default = /*#__PURE__*/ __webpack_require__.n(external_node_os_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_http_namespaceObject = require("node:http");
-var external_node_http_default = /*#__PURE__*/ __webpack_require__.n(external_node_http_namespaceObject);
-const external_node_https_namespaceObject = require("node:https");
-var external_node_https_default = /*#__PURE__*/ __webpack_require__.n(external_node_https_namespaceObject);
-const external_node_stream_promises_namespaceObject = require("node:stream/promises");
-const external_node_url_namespaceObject = require("node:url");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -67,6 +59,58 @@ class errors_extensionFromStoreError extends Error {
         this.cause = cause;
     }
 }
+const external_extract_zip_namespaceObject = require("extract-zip");
+var external_extract_zip_default = /*#__PURE__*/ __webpack_require__.n(external_extract_zip_namespaceObject);
+function readUInt32LE(bytes, offset) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset + offset, Uint32Array.BYTES_PER_ELEMENT);
+    return view.getUint32(0, true);
+}
+function readMagic(bytes) {
+    let out = '';
+    const slice = bytes.subarray(0, 4);
+    for(let index = 0; index < slice.length; index += 1)out += String.fromCharCode(slice[index]);
+    return out;
+}
+function stripCrxHeader(buffer) {
+    if (buffer.length < 16) throw new errors_extensionFromStoreError('ExtractionFailed', 'CRX file too small');
+    const magic = readMagic(buffer);
+    if ('Cr24' !== magic) throw new errors_extensionFromStoreError('ExtractionFailed', 'Invalid CRX header');
+    const version = readUInt32LE(buffer, 4);
+    if (2 === version) {
+        const publicKeyLength = readUInt32LE(buffer, 8);
+        const signatureLength = readUInt32LE(buffer, 12);
+        const headerSize = 16 + publicKeyLength + signatureLength;
+        return buffer.subarray(headerSize);
+    }
+    if (3 === version) {
+        const headerSize = readUInt32LE(buffer, 8);
+        return buffer.subarray(12 + headerSize);
+    }
+    throw new errors_extensionFromStoreError('ExtractionFailed', `Unsupported CRX version ${version}`);
+}
+async function extractCrx(crxPath, extractDir, workDir) {
+    const crxBuffer = await promises_default().readFile(crxPath);
+    const zipBuffer = Buffer.from(stripCrxHeader(crxBuffer));
+    const zipPath = external_node_path_default().join(workDir, 'payload.zip');
+    await promises_default().writeFile(zipPath, zipBuffer);
+    await external_extract_zip_default()(zipPath, {
+        dir: extractDir
+    });
+    await promises_default().unlink(zipPath).catch(()=>void 0);
+}
+async function extractZipArchive(zipPath, extractDir) {
+    await external_extract_zip_default()(zipPath, {
+        dir: extractDir
+    });
+}
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_http_namespaceObject = require("node:http");
+var external_node_http_default = /*#__PURE__*/ __webpack_require__.n(external_node_http_namespaceObject);
+const external_node_https_namespaceObject = require("node:https");
+var external_node_https_default = /*#__PURE__*/ __webpack_require__.n(external_node_https_namespaceObject);
+const external_node_stream_promises_namespaceObject = require("node:stream/promises");
+const external_node_url_namespaceObject = require("node:url");
 function createLogger(logger) {
     return {
         info: (message)=>{
@@ -97,7 +141,8 @@ function request(url, options) {
             hostname: target.hostname,
             port: target.port,
             path: `${target.pathname}${target.search}`,
-            headers
+            headers,
+            agent: false
         }, (res)=>{
             resolve({
                 statusCode: res.statusCode || 0,
@@ -148,77 +193,59 @@ async function requestJson(url, options, maxRedirects = 5) {
         throw new errors_extensionFromStoreError('StoreIncompatibility', `Invalid JSON response from ${url}`, error);
     }
 }
-const external_extract_zip_namespaceObject = require("extract-zip");
-var external_extract_zip_default = /*#__PURE__*/ __webpack_require__.n(external_extract_zip_namespaceObject);
-function stripCrxHeader(buffer) {
-    if (buffer.length < 16) throw new errors_extensionFromStoreError('ExtractionFailed', 'CRX file too small');
-    const magic = buffer.subarray(0, 4).toString('ascii');
-    if ('Cr24' !== magic) throw new errors_extensionFromStoreError('ExtractionFailed', 'Invalid CRX header');
-    const version = buffer.readUInt32LE(4);
-    if (2 === version) {
-        const publicKeyLength = buffer.readUInt32LE(8);
-        const signatureLength = buffer.readUInt32LE(12);
-        const headerSize = 16 + publicKeyLength + signatureLength;
-        return buffer.subarray(headerSize);
-    }
-    if (3 === version) {
-        const headerSize = buffer.readUInt32LE(8);
-        const offset = 12 + headerSize;
-        return buffer.subarray(offset);
-    }
-    throw new errors_extensionFromStoreError('ExtractionFailed', `Unsupported CRX version ${version}`);
-}
-async function extractCrx(crxPath, extractDir, workDir) {
-    const crxBuffer = await promises_default().readFile(crxPath);
-    const zipBuffer = stripCrxHeader(crxBuffer);
-    const zipPath = external_node_path_default().join(workDir, 'payload.zip');
-    await promises_default().writeFile(zipPath, zipBuffer);
-    await external_extract_zip_default()(zipPath, {
-        dir: extractDir
-    });
-    await promises_default().unlink(zipPath).catch(()=>void 0);
-}
-async function extractZipArchive(zipPath, extractDir) {
-    await external_extract_zip_default()(zipPath, {
-        dir: extractDir
-    });
-}
-async function readManifestInfo(manifestPath) {
-    let raw = '';
-    try {
-        raw = await promises_default().readFile(manifestPath, 'utf8');
-    } catch (error) {
-        throw new errors_extensionFromStoreError('ExtractionFailed', 'manifest.json was not found after extraction', error);
-    }
+function parseManifestInfo(raw) {
     let parsed;
     try {
         parsed = JSON.parse(raw);
     } catch (error) {
         throw new errors_extensionFromStoreError('ExtractionFailed', 'manifest.json is not valid JSON', error);
     }
-    const manifestVersion = null == parsed ? void 0 : parsed.manifest_version;
-    const extensionVersion = null == parsed ? void 0 : parsed.version;
+    if (!parsed || 'object' != typeof parsed || Array.isArray(parsed)) throw new errors_extensionFromStoreError('ExtractionFailed', 'manifest.json must contain an object');
+    const manifest = parsed;
+    const manifestVersion = manifest.manifest_version;
+    const extensionVersion = manifest.version;
     if (2 !== manifestVersion && 3 !== manifestVersion) throw new errors_extensionFromStoreError('ExtractionFailed', 'manifest_version must be 2 or 3');
     if (!extensionVersion || 'string' != typeof extensionVersion) throw new errors_extensionFromStoreError('ExtractionFailed', 'manifest.json is missing a version');
     return {
+        manifest,
         manifestVersion,
         extensionVersion
     };
 }
-function getPlatformInfo() {
-    const platform = process.platform;
-    const arch = process.arch;
-    const os = 'darwin' === platform ? 'mac' : 'win32' === platform ? 'win' : 'linux';
-    const archName = 'x64' === arch ? 'x64' : 'arm64' === arch ? 'arm64' : 'ia32' === arch ? 'x86' : 'x64';
+async function readManifestInfo(manifestPath) {
+    let raw = '';
+    try {
+        raw = await promises_default().readFile(manifestPath, 'utf8');
+    } catch (error) {
+        throw new errors_extensionFromStoreError('ExtractionFailed', 'manifest.json was not found after extraction', error);
+    }
+    return parseManifestInfo(raw);
+}
+function getNodeArch() {
+    if ('arm64' === process.arch) return 'arm64';
+    if ('ia32' === process.arch) return 'x86';
+    return 'x64';
+}
+function getNodeChromePlatformInfo() {
+    return {
+        os: 'darwin' === process.platform ? 'mac' : 'win32' === process.platform ? 'win' : 'linux',
+        arch: getNodeArch()
+    };
+}
+function normalizeChromePlatformInfo(platform) {
     return {
-        os,
-        arch: archName,
-        naclArch: archName
+        os: platform.os,
+        arch: platform.arch,
+        naclArch: platform.naclArch || platform.arch
     };
 }
-function getChromeDownloadUrl(id) {
+const DEFAULT_CHROME_PLATFORM = {
+    os: 'linux',
+    arch: 'x64'
+};
+function getChromeDownloadUrl(id, platformInfo = DEFAULT_CHROME_PLATFORM) {
     const encoded = encodeURIComponent(id);
-    const platform = getPlatformInfo();
+    const platform = normalizeChromePlatformInfo(platformInfo);
     const productId = 'chromiumcrx';
     const productChannel = 'unknown';
     const productVersion = '9999.0.9999.0';
@@ -248,12 +275,12 @@ function getEdgeDownloadUrl(id) {
 async function resolveFirefoxDownload(idOrSlug, versionHint, options) {
     var _addon_current_version_file, _addon_current_version, _addon_current_version1;
     const baseUrl = `https://addons.mozilla.org/api/v5/addons/addon/${encodeURIComponent(idOrSlug)}/`;
-    const addon = await requestJson(baseUrl, options);
+    const addon = await options.requestJson(baseUrl, options);
     const slugOrId = addon.slug || idOrSlug;
     if (versionHint) {
         var _version_file;
         const versionUrl = `${baseUrl}versions/${encodeURIComponent(versionHint)}/`;
-        const version = await requestJson(versionUrl, options);
+        const version = await options.requestJson(versionUrl, options);
         const downloadUrl = null == (_version_file = version.file) ? void 0 : _version_file.url;
         if (!downloadUrl) throw new errors_extensionFromStoreError('NotPublic', `Version ${versionHint} is not publicly downloadable`);
         return {
@@ -298,48 +325,20 @@ function extractFirefoxSlugFromUrl(url) {
 function validateInput(url) {
     if (!url || 'string' != typeof url) throw new errors_extensionFromStoreError('InvalidInput', 'URL is required');
 }
-function defaultOutputDir() {
-    return external_node_path_default().resolve(process.cwd(), 'extensions');
-}
 function sanitizeSegment(value, label) {
     const sanitized = value.replace(/[\\/]/g, '-').trim();
     if (!sanitized) throw new errors_extensionFromStoreError('InvalidInput', `${label} is not a valid path segment`);
     return sanitized;
 }
-async function ensureDirExists(dir) {
-    await promises_default().mkdir(dir, {
-        recursive: true
-    });
-}
-async function pathExists(target) {
-    try {
-        await promises_default().access(target);
-        return true;
-    } catch  {
-        return false;
-    }
-}
-async function moveDir(source, destination) {
-    try {
-        await promises_default().rename(source, destination);
-    } catch  {
-        await promises_default().cp(source, destination, {
-            recursive: true
-        });
-        await promises_default().rm(source, {
-            recursive: true,
-            force: true
-        });
-    }
-}
-async function resolveDownload(url, version, options) {
+async function resolveDownload(url, options) {
     const store = detectStoreFromUrl(url);
     if (!store) throw new errors_extensionFromStoreError('UnsupportedStore', 'URL does not match a supported store');
     if ('chrome' === store) {
         const downloadId = extractChromeIdFromUrl(url);
         if (!downloadId) throw new errors_extensionFromStoreError('NotFound', 'Chrome extension id not found in URL');
         return {
-            downloadUrl: getChromeDownloadUrl(downloadId),
+            store,
+            downloadUrl: getChromeDownloadUrl(downloadId, options.platform),
             archiveType: 'crx',
             downloadId,
             slugOrId: downloadId
@@ -349,6 +348,7 @@ async function resolveDownload(url, version, options) {
         const downloadId = extractEdgeIdFromUrl(url);
         if (!downloadId) throw new errors_extensionFromStoreError('NotFound', 'Edge extension id not found in URL');
         return {
+            store,
             downloadUrl: getEdgeDownloadUrl(downloadId),
             archiveType: 'crx',
             downloadId,
@@ -357,14 +357,48 @@ async function resolveDownload(url, version, options) {
     }
     const slug = extractFirefoxSlugFromUrl(url);
     if (!slug) throw new errors_extensionFromStoreError('NotFound', 'Firefox extension slug not found in URL');
-    const firefox = await resolveFirefoxDownload(slug, version, options);
+    const firefox = await resolveFirefoxDownload(slug, options.version, {
+        userAgent: options.userAgent,
+        logger: options.logger,
+        requestJson: options.requestJson
+    });
     return {
+        store,
         downloadUrl: firefox.downloadUrl,
         archiveType: 'xpi',
         versionHint: firefox.version,
         slugOrId: firefox.slugOrId
     };
 }
+function defaultOutputDir() {
+    return external_node_path_default().resolve(process.cwd(), 'extensions');
+}
+async function ensureDirExists(dir) {
+    await promises_default().mkdir(dir, {
+        recursive: true
+    });
+}
+async function pathExists(target) {
+    try {
+        await promises_default().access(target);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+async function moveDir(source, destination) {
+    try {
+        await promises_default().rename(source, destination);
+    } catch  {
+        await promises_default().cp(source, destination, {
+            recursive: true
+        });
+        await promises_default().rm(source, {
+            recursive: true,
+            force: true
+        });
+    }
+}
 function errorWithCode(code, message, cause) {
     return new errors_extensionFromStoreError(code, message, cause);
 }
@@ -373,7 +407,13 @@ async function fetchExtensionFromStore(url, options = {}) {
     const log = createLogger(options.logger);
     const outDir = options.outDir ? external_node_path_default().resolve(options.outDir) : defaultOutputDir();
     await ensureDirExists(outDir);
-    const resolved = await resolveDownload(url, options.version, options);
+    const resolved = await resolveDownload(url, {
+        version: options.version,
+        userAgent: options.userAgent,
+        logger: options.logger,
+        platform: getNodeChromePlatformInfo(),
+        requestJson: requestJson
+    });
     if (options.version && !url.includes('addons.mozilla.org')) log.warn('Version hints are best-effort and only supported on Firefox at the moment.');
     const workDir = await promises_default().mkdtemp(external_node_path_default().join(external_node_os_default().tmpdir(), 'extension-from-store-'));
     const archivePath = external_node_path_default().join(workDir, `archive.${resolved.archiveType}`);
@@ -408,7 +448,7 @@ async function fetchExtensionFromStore(url, options = {}) {
         await moveDir(extractDir, finalDir);
         const metaPath = external_node_path_default().join(finalDir, 'extension.meta.json');
         const meta = {
-            store: detectStoreFromUrl(url) || 'chrome',
+            store: resolved.store,
             identifier: resolved.slugOrId,
             version: resolvedVersion,
             manifestVersion: manifestInfo.manifestVersion