extension-from-store 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,12 +1,12 @@
 import * as __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__ from "node:fs/promises";
-import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
 import * as __WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__ from "node:os";
+import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE_extract_zip_c4acec5a__ from "extract-zip";
 import * as __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__ from "node:fs";
 import * as __WEBPACK_EXTERNAL_MODULE_node_http_2dc67212__ from "node:http";
 import * as __WEBPACK_EXTERNAL_MODULE_node_https_626f33a7__ from "node:https";
 import * as __WEBPACK_EXTERNAL_MODULE_node_stream_promises_5adae1f2__ from "node:stream/promises";
 import * as __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__ from "node:url";
-import * as __WEBPACK_EXTERNAL_MODULE_extract_zip_c4acec5a__ from "extract-zip";
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -24,6 +24,48 @@ class errors_extensionFromStoreError extends Error {
         this.cause = cause;
     }
 }
+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 __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].readFile(crxPath);
+    const zipBuffer = Buffer.from(stripCrxHeader(crxBuffer));
+    const zipPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(workDir, 'payload.zip');
+    await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(zipPath, zipBuffer);
+    await (0, __WEBPACK_EXTERNAL_MODULE_extract_zip_c4acec5a__["default"])(zipPath, {
+        dir: extractDir
+    });
+    await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].unlink(zipPath).catch(()=>void 0);
+}
+async function extractZipArchive(zipPath, extractDir) {
+    await (0, __WEBPACK_EXTERNAL_MODULE_extract_zip_c4acec5a__["default"])(zipPath, {
+        dir: extractDir
+    });
+}
 function createLogger(logger) {
     return {
         info: (message)=>{
@@ -54,7 +96,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,
@@ -105,75 +148,59 @@ async function requestJson(url, options, maxRedirects = 5) {
         throw new errors_extensionFromStoreError('StoreIncompatibility', `Invalid JSON response from ${url}`, error);
     }
 }
-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 __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].readFile(crxPath);
-    const zipBuffer = stripCrxHeader(crxBuffer);
-    const zipPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(workDir, 'payload.zip');
-    await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(zipPath, zipBuffer);
-    await (0, __WEBPACK_EXTERNAL_MODULE_extract_zip_c4acec5a__["default"])(zipPath, {
-        dir: extractDir
-    });
-    await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].unlink(zipPath).catch(()=>void 0);
-}
-async function extractZipArchive(zipPath, extractDir) {
-    await (0, __WEBPACK_EXTERNAL_MODULE_extract_zip_c4acec5a__["default"])(zipPath, {
-        dir: extractDir
-    });
-}
-async function readManifestInfo(manifestPath) {
-    let raw = '';
-    try {
-        raw = await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["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 __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["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,
-        arch: archName,
-        naclArch: archName
+        os: 'darwin' === process.platform ? 'mac' : 'win32' === process.platform ? 'win' : 'linux',
+        arch: getNodeArch()
     };
 }
-function getChromeDownloadUrl(id) {
+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 = getPlatformInfo();
+    const platform = normalizeChromePlatformInfo(platformInfo);
     const productId = 'chromiumcrx';
     const productChannel = 'unknown';
     const productVersion = '9999.0.9999.0';
@@ -203,12 +230,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 {
@@ -253,48 +280,20 @@ function extractFirefoxSlugFromUrl(url) {
 function validateInput(url) {
     if (!url || 'string' != typeof url) throw new errors_extensionFromStoreError('InvalidInput', 'URL is required');
 }
-function defaultOutputDir() {
-    return __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["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 __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].mkdir(dir, {
-        recursive: true
-    });
-}
-async function pathExists(target) {
-    try {
-        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].access(target);
-        return true;
-    } catch  {
-        return false;
-    }
-}
-async function moveDir(source, destination) {
-    try {
-        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].rename(source, destination);
-    } catch  {
-        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].cp(source, destination, {
-            recursive: true
-        });
-        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["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
@@ -304,6 +303,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,
@@ -312,14 +312,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 __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].resolve(process.cwd(), 'extensions');
+}
+async function ensureDirExists(dir) {
+    await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].mkdir(dir, {
+        recursive: true
+    });
+}
+async function pathExists(target) {
+    try {
+        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].access(target);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+async function moveDir(source, destination) {
+    try {
+        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].rename(source, destination);
+    } catch  {
+        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].cp(source, destination, {
+            recursive: true
+        });
+        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].rm(source, {
+            recursive: true,
+            force: true
+        });
+    }
+}
 function errorWithCode(code, message, cause) {
     return new errors_extensionFromStoreError(code, message, cause);
 }
@@ -328,7 +362,13 @@ async function fetchExtensionFromStore(url, options = {}) {
     const log = createLogger(options.logger);
     const outDir = options.outDir ? __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["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 __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].mkdtemp(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(__WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__["default"].tmpdir(), 'extension-from-store-'));
     const archivePath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(workDir, `archive.${resolved.archiveType}`);
@@ -363,7 +403,7 @@ async function fetchExtensionFromStore(url, options = {}) {
         await moveDir(extractDir, finalDir);
         const metaPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(finalDir, 'extension.meta.json');
         const meta = {
-            store: detectStoreFromUrl(url) || 'chrome',
+            store: resolved.store,
             identifier: resolved.slugOrId,
             version: resolvedVersion,
             manifestVersion: manifestInfo.manifestVersion

package/dist/manifest.d.ts

@@ -0,0 +1,7 @@
+export type ExtensionManifest = Record<string, unknown>;
+export type ManifestInfo = {
+    extensionVersion: string;
+    manifestVersion: 2 | 3;
+    manifest: ExtensionManifest;
+};
+export declare function parseManifestInfo(raw: string): ManifestInfo;

package/dist/meta.d.ts

@@ -1,5 +1,2 @@
-export type ManifestInfo = {
-    extensionVersion: string;
-    manifestVersion: 2 | 3;
-};
+import { type ManifestInfo } from './manifest';
 export declare function readManifestInfo(manifestPath: string): Promise<ManifestInfo>;

package/dist/node-platform.d.ts

@@ -0,0 +1,2 @@
+import type { ChromePlatformInfo } from './platform';
+export declare function getNodeChromePlatformInfo(): ChromePlatformInfo;

package/dist/platform.d.ts

@@ -0,0 +1,8 @@
+export type ChromePlatformOs = 'mac' | 'win' | 'linux';
+export type ChromePlatformArch = 'x64' | 'arm64' | 'x86';
+export type ChromePlatformInfo = {
+    os: ChromePlatformOs;
+    arch: ChromePlatformArch;
+    naclArch?: ChromePlatformArch;
+};
+export declare function normalizeChromePlatformInfo(platform: ChromePlatformInfo): Required<ChromePlatformInfo>;

package/dist/resolve.d.ts

@@ -0,0 +1,21 @@
+import type { Logger } from './logger';
+import type { ChromePlatformInfo } from './platform';
+import { type JsonRequester } from './stores/firefox';
+export type ResolvedDownload = {
+    store: 'chrome' | 'edge' | 'firefox';
+    downloadUrl: string;
+    archiveType: 'crx' | 'xpi';
+    versionHint?: string;
+    downloadId?: string;
+    slugOrId: string;
+};
+export type ResolveDownloadOptions = {
+    version?: string;
+    userAgent?: string;
+    logger?: Logger;
+    platform?: ChromePlatformInfo;
+    requestJson: JsonRequester;
+};
+export declare function validateInput(url: string): void;
+export declare function sanitizeSegment(value: string, label: string): string;
+export declare function resolveDownload(url: string, options: ResolveDownloadOptions): Promise<ResolvedDownload>;

package/dist/stores/chrome.d.ts

@@ -1 +1,2 @@
-export declare function getChromeDownloadUrl(id: string): string;
+import { type ChromePlatformInfo } from '../platform';
+export declare function getChromeDownloadUrl(id: string, platformInfo?: ChromePlatformInfo): string;

package/dist/stores/firefox.d.ts

@@ -1,7 +1,12 @@
 import type { Logger } from '../logger';
+export type JsonRequester = <T>(url: string, options: {
+    userAgent?: string;
+    logger?: Logger;
+}) => Promise<T>;
 export declare function resolveFirefoxDownload(idOrSlug: string, versionHint: string | undefined, options: {
     userAgent?: string;
     logger?: Logger;
+    requestJson: JsonRequester;
 }): Promise<{
     downloadUrl: string;
     version: string;

package/package.json

@@ -9,7 +9,7 @@
   },
   "engineStrict": false,
   "name": "extension-from-store",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Download public browser extensions from official stores",
   "homepage": "https://www.npmjs.com/package/extension-from-store",
   "type": "module",
@@ -18,6 +18,16 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.js",
+      "require": "./dist/browser.cjs"
+    },
+    "./core": {
+      "types": "./dist/core.d.ts",
+      "import": "./dist/core.js",
+      "require": "./dist/core.cjs"
     }
   },
   "main": "./dist/index.cjs",
@@ -32,6 +42,7 @@
   },
   "scripts": {
     "build": "rslib build",
+    "typecheck": "tsc --noEmit",
     "check": "pnpm dlx @biomejs/biome@1.9.4 check --write",
     "dev": "rslib build --watch",
     "format": "pnpm dlx @biomejs/biome@1.9.4 format --write",
@@ -69,7 +80,8 @@
     "extension-download"
   ],
   "dependencies": {
-    "extract-zip": "^2.0.1"
+    "extract-zip": "^2.0.1",
+    "fflate": "^0.8.2"
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",