crxpull 1.0.1

package/README.md

@@ -0,0 +1,228 @@
+# crxpull
+
+Download Chrome extensions as `.zip` + extracted source folder — by ID or Chrome Web Store URL.
+
+```bash
+npx crxpull cjpalhdlnbpafiamejdnhcphjbkeiagm
+# saves a .zip and extracts source files, ready to inspect
+```
+
+> **Disclaimer:** crxpull uses an unofficial Google endpoint to fetch CRX files. Intended for legitimate personal use — security research, extension auditing, offline backup, and developer tooling. Ensure your usage complies with the [Chrome Web Store Terms of Service](https://chromewebstore.google.com/tos). Do not redistribute extensions without the original author's permission.
+
+---
+
+<!-- screenshot -->
+
+---
+
+## Install
+
+```bash
+npm install -g crxpull
+```
+
+```bash
+bun add -g crxpull
+```
+
+Or run without installing:
+
+```bash
+npx crxpull <id-or-url>
+bunx crxpull <id-or-url>
+```
+
+---
+
+## Usage
+
+```
+crxpull <id-or-url> [options]
+crxpull -f extensions.txt [options]
+```
+
+### Options
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `-o, --output <dir>` | Output directory | Current directory |
+| `-n, --name <filename>` | Custom filename (no extension) | Extension ID |
+| `--crx` | Also keep the raw `.crx` file | `false` |
+| `--info` | Show metadata from the Chrome Web Store | — |
+| `-f, --file <path>` | Read IDs/URLs from a text file (one per line) | — |
+| `-c, --concurrency <n>` | Parallel downloads in batch mode | `3` |
+| `--json` | Output results as JSON | `false` |
+| `-v, --version` | Show version | — |
+| `-h, --help` | Show help | — |
+
+---
+
+## Examples
+
+```bash
+# Download by extension ID
+crxpull mihcahmgecmbnbcchbopgniflfhgnkff
+
+# Download from a Chrome Web Store URL
+crxpull https://chromewebstore.google.com/detail/ublock-origin/cjpalhdlnbpafiamejdnhcphjbkeiagm
+
+# Save to a custom directory with a custom filename
+crxpull cjpalhdlnbpafiamejdnhcphjbkeiagm -o ./extensions -n ublock
+
+# Also keep the raw .crx file
+crxpull cjpalhdlnbpafiamejdnhcphjbkeiagm --crx
+
+# Show extension metadata without downloading
+crxpull cjpalhdlnbpafiamejdnhcphjbkeiagm --info
+
+# Batch download from a file
+crxpull -f my-extensions.txt -o ./extensions -c 5
+
+# JSON output — great for scripting
+crxpull cjpalhdlnbpafiamejdnhcphjbkeiagm --json
+```
+
+### Batch file format
+
+Lines starting with `#` are treated as comments and ignored.
+
+```
+# my-extensions.txt
+cjpalhdlnbpafiamejdnhcphjbkeiagm
+mihcahmgecmbnbcchbopgniflfhgnkff
+https://chromewebstore.google.com/detail/dark-reader/eimadpbcbfnmbkopoojfekhnkhdbieeh
+```
+
+---
+
+## Programmatic API
+
+```js
+import { download, downloadBatch, fetchExtensionInfo, extractId } from 'crxpull'
+```
+
+### `download(input, options?)`
+
+Downloads a single extension. Returns `{ id, zipPath, folderPath, crxPath? }`.
+
+```js
+const result = await download('cjpalhdlnbpafiamejdnhcphjbkeiagm', {
+  outputDir: './extensions',
+  name: 'ublock',
+  crx: false,         // set true to also keep the raw .crx
+  onProgress: (bytes, total) => {
+    process.stdout.write(`\r${Math.round(bytes / total * 100)}%`)
+  }
+})
+
+console.log(result.zipPath)     // ./extensions/ublock.zip
+console.log(result.folderPath)  // ./extensions/ublock/
+```
+
+### `downloadBatch(inputs, options?)`
+
+Downloads multiple extensions in parallel. Always resolves — failed items include an `error` field.
+
+```js
+const results = await downloadBatch([
+  'cjpalhdlnbpafiamejdnhcphjbkeiagm',
+  'mihcahmgecmbnbcchbopgniflfhgnkff',
+], {
+  outputDir: './extensions',
+  concurrency: 5,
+})
+
+for (const r of results) {
+  if (r.error) console.error(`${r.id} failed: ${r.error}`)
+  else console.log(`${r.id} → ${r.zipPath}`)
+}
+```
+
+### `fetchExtensionInfo(id)`
+
+Fetches extension metadata from the Chrome Web Store.
+
+```js
+const info = await fetchExtensionInfo('cjpalhdlnbpafiamejdnhcphjbkeiagm')
+
+console.log(info.name)         // "uBlock Origin"
+console.log(info.version)      // "1.59.0"
+console.log(info.users)        // "10,000,000+"
+console.log(info.rating)       // 4.8
+console.log(info.storeUrl)     // https://chromewebstore.google.com/...
+```
+
+### `extractId(input)`
+
+Parses a 32-character extension ID from a raw ID string or any Chrome Web Store URL.
+
+```js
+extractId('cjpalhdlnbpafiamejdnhcphjbkeiagm')
+// => 'cjpalhdlnbpafiamejdnhcphjbkeiagm'
+
+extractId('https://chromewebstore.google.com/detail/ublock-origin/cjpalhdlnbpafiamejdnhcphjbkeiagm')
+// => 'cjpalhdlnbpafiamejdnhcphjbkeiagm'
+```
+
+---
+
+## How it works
+
+crxpull fetches the extension from Google's CRX update service endpoint. The raw `.crx` file is downloaded to a temp path, then crxpull strips the CRX binary header (CRX2 or CRX3 format) to expose the embedded ZIP. It then:
+
+1. Saves a clean **`.zip`** file — portable, shareable, openable anywhere
+2. Extracts a **folder** with all source files ready to edit — `manifest.json`, scripts, assets, locales
+
+The temporary `.crx` is deleted automatically. Use `--crx` if you want to keep it.
+
+---
+
+## Publishing
+
+A PowerShell publish script is included for Windows. It handles token management, version bumping, and retries.
+
+```powershell
+# First time — save your npm token
+.\publish.ps1 -Token npm_xxxx -Save
+
+# Bump patch and publish
+.\publish.ps1
+
+# Bump minor version
+.\publish.ps1 -Minor
+
+# Dry run — preview without publishing
+.\publish.ps1 -DryRun
+```
+
+Token resolution order: `-Token` param → `NPM_TOKEN` env var → `.npmtoken` file (gitignored).
+
+---
+
+## Disclaimer
+
+crxpull relies on an unofficial, undocumented Google endpoint. There is no guarantee it will remain available or stable. Intended for legitimate personal use only — security research, auditing, developer workflows, and offline backup. Always respect the rights of extension authors and the [Chrome Web Store Terms of Service](https://chromewebstore.google.com/tos).
+
+---
+
+## Requirements
+
+- Node.js 18 or later
+
+---
+
+## Contributing
+
+Issues and pull requests are welcome. Feel free to fork, improve, and share.
+
+---
+
+## Credits
+
+Built in collaboration with **[Claude](https://claude.ai)** by Anthropic.
+
+---
+
+## License
+
+MIT

package/bin/crxpull.js

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+import chalk from 'chalk'
+import { readFileSync, existsSync } from 'fs'
+import path from 'path'
+import { download, downloadBatch, fetchExtensionInfo, extractId } from '../index.js'
+
+const log = {
+  info:    (msg) => console.log(chalk.blue('INFO'),    chalk.white(msg)),
+  success: (msg) => console.log(chalk.green('SUCCESS'), chalk.white(msg)),
+  error:   (msg) => console.log(chalk.red('ERROR'),    chalk.white(msg)),
+  warning: (msg) => console.log(chalk.yellow('WARNING'), chalk.white(msg)),
+  detail:  (label, val) => console.log(chalk.gray('  ') + chalk.gray(label.padEnd(14)) + chalk.white(val)),
+}
+
+function renderProgress(downloaded, total) {
+  const pct = Math.floor((downloaded / total) * 100)
+  const filled = Math.floor(pct / 5)
+  const bar = '█'.repeat(filled) + '░'.repeat(20 - filled)
+  const kb = (downloaded / 1024).toFixed(1)
+  const totalKb = (total / 1024).toFixed(1)
+  process.stdout.write(`\r${chalk.blue('DOWN')}    [${chalk.cyan(bar)}] ${pct}% (${kb} / ${totalKb} KB)`)
+  if (downloaded >= total) process.stdout.write('\n')
+}
+
+function parseArgs(argv) {
+  const args = argv.slice(2)
+  const opts = {
+    inputs: [],
+    outputDir: process.cwd(),
+    name: null,
+    crx: false,
+    info: false,
+    file: null,
+    concurrency: 3,
+    help: false,
+    version: false,
+    json: false,
+  }
+
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]
+    if (a === '-h' || a === '--help')                        opts.help = true
+    else if (a === '-v' || a === '--version')                opts.version = true
+    else if (a === '--json')                                  opts.json = true
+    else if (a === '--crx')                                   opts.crx = true
+    else if (a === '--info')                                  opts.info = true
+    else if ((a === '-o' || a === '--output') && args[i+1])  opts.outputDir = path.resolve(args[++i])
+    else if ((a === '-n' || a === '--name') && args[i+1])    opts.name = args[++i]
+    else if ((a === '-f' || a === '--file') && args[i+1])    opts.file = args[++i]
+    else if ((a === '-c' || a === '--concurrency') && args[i+1]) opts.concurrency = parseInt(args[++i])
+    else if (!a.startsWith('-'))                              opts.inputs.push(a)
+  }
+
+  return opts
+}
+
+function printHelp() {
+  console.log(`
+${chalk.bold.white('crxpull')} ${chalk.gray('\u2014')} ${chalk.white('Download Chrome extensions as .crx files from your terminal')}
+
+${chalk.bold('USAGE')}
+  crxpull <id-or-url> [options]
+  crxpull -f extensions.txt [options]
+
+${chalk.bold('OPTIONS')}
+  ${chalk.cyan('-o, --output <dir>')}       Output directory ${chalk.gray('(default: current directory)')}
+  ${chalk.cyan('-n, --name <name>')}        Custom filename without extension
+  ${chalk.cyan('    --crx')}                 Also keep the raw .crx file
+  ${chalk.cyan('    --info')}               Show extension metadata from Chrome Web Store
+  ${chalk.cyan('-f, --file <path>')}        Read extension IDs/URLs from a file ${chalk.gray('(one per line)')}
+  ${chalk.cyan('-c, --concurrency <n>')}    Parallel downloads when using --file ${chalk.gray('(default: 3)')}
+  ${chalk.cyan('    --json')}               Output results as JSON
+  ${chalk.cyan('-v, --version')}            Show version
+  ${chalk.cyan('-h, --help')}               Show this help message
+
+${chalk.bold('EXAMPLES')}
+  ${chalk.gray('# Download by ID')}
+  crxpull mihcahmgecmbnbcchbopgniflfhgnkff
+
+  ${chalk.gray('# Download from Chrome Web Store URL')}
+  crxpull https://chromewebstore.google.com/detail/ublock-origin/cjpalhdlnbpafiamejdnhcphjbkeiagm
+
+  ${chalk.gray('# Save to custom directory with custom name')}
+  crxpull cjpalhdlnbpafiamejdnhcphjbkeiagm -o ./extensions -n ublock
+
+  ${chalk.gray('# Keep the raw .crx file alongside zip + folder')}
+  crxpull cjpalhdlnbpafiamejdnhcphjbkeiagm --crx
+
+  ${chalk.gray('# Show extension info without downloading')}
+  crxpull cjpalhdlnbpafiamejdnhcphjbkeiagm --info
+
+  ${chalk.gray('# Batch download from a text file')}
+  crxpull -f my-extensions.txt -o ./extensions -c 5
+
+  ${chalk.gray('# Output as JSON (great for scripting)')}
+  crxpull cjpalhdlnbpafiamejdnhcphjbkeiagm --json
+`)
+}
+
+async function handleInfo(input, json) {
+  const id = extractId(input)
+  log.info(`Fetching info for ${id}`)
+  const info = await fetchExtensionInfo(id)
+
+  if (json) {
+    console.log(JSON.stringify(info, null, 2))
+    return
+  }
+
+  console.log()
+  console.log('  ' + chalk.bold.white(info.name))
+  if (info.version)     log.detail('Version', info.version)
+  if (info.users)       log.detail('Users', info.users)
+  if (info.rating)      log.detail('Rating', `${info.rating} (${info.ratingCount} reviews)`)
+  if (info.description) log.detail('Description', info.description.slice(0, 120) + (info.description.length > 120 ? '...' : ''))
+  log.detail('Store URL', info.storeUrl)
+  console.log()
+}
+
+async function handleSingle(input, opts) {
+  const id = extractId(input)
+  log.info(`Downloading ${id}`)
+
+  const result = await download(input, {
+    outputDir: opts.outputDir,
+    name: opts.name,
+    crx: opts.crx,
+    onProgress: opts.json ? null : renderProgress,
+  })
+
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2))
+    return
+  }
+
+  log.success(`ZIP saved to ${result.zipPath}`)
+  log.success(`Extracted to ${result.folderPath}`)
+  if (result.crxPath) log.detail('CRX kept', result.crxPath)
+}
+
+async function handleBatch(inputs, opts) {
+  log.info(`Downloading ${inputs.length} extensions with concurrency ${opts.concurrency}`)
+
+  const results = await downloadBatch(inputs, {
+    outputDir: opts.outputDir,
+    crx: opts.crx,
+    concurrency: opts.concurrency,
+  })
+
+  if (opts.json) {
+    console.log(JSON.stringify(results, null, 2))
+    return
+  }
+
+  const ok = results.filter(r => !r.error)
+  const failed = results.filter(r => r.error)
+
+  for (const r of ok) {
+    log.success(r.id)
+    log.detail('ZIP', r.zipPath)
+    log.detail('Folder', r.folderPath)
+    if (r.crxPath) log.detail('CRX kept', r.crxPath)
+  }
+
+  for (const r of failed) {
+    log.error(`${r.id} — ${r.error}`)
+  }
+
+  console.log()
+  log.info(`${ok.length} succeeded, ${failed.length} failed`)
+}
+
+async function main() {
+  const opts = parseArgs(process.argv)
+
+  if (opts.version) {
+    const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'))
+    console.log(pkg.version)
+    return
+  }
+
+  if (opts.help) {
+    printHelp()
+    return
+  }
+
+  if (opts.file) {
+    if (!existsSync(opts.file)) {
+      log.error(`File not found: ${opts.file}`)
+      process.exit(1)
+    }
+    const lines = readFileSync(opts.file, 'utf8')
+      .split('\n')
+      .map(l => l.trim())
+      .filter(l => l && !l.startsWith('#'))
+
+    if (lines.length === 0) {
+      log.warning('File is empty or has no valid entries')
+      return
+    }
+
+    await handleBatch(lines, opts)
+    return
+  }
+
+  if (opts.inputs.length === 0) {
+    printHelp()
+    process.exit(1)
+  }
+
+  if (opts.info) {
+    for (const input of opts.inputs) {
+      await handleInfo(input, opts.json)
+    }
+    return
+  }
+
+  if (opts.inputs.length === 1) {
+    await handleSingle(opts.inputs[0], opts)
+  } else {
+    await handleBatch(opts.inputs, opts)
+  }
+}
+
+main().catch(err => {
+  log.error(err.message)
+  process.exit(1)
+})

package/index.js

@@ -0,0 +1,75 @@
+import path from 'path'
+import { extractId } from './src/utils.js'
+import { downloadCrx } from './src/download.js'
+import { extractCrx } from './src/extract.js'
+import { fetchExtensionInfo } from './src/info.js'
+
+export { extractId, fetchExtensionInfo }
+
+/**
+ * Download a Chrome extension, save as .zip and extract to folder.
+ *
+ * @param {string} input - Extension ID or Chrome Web Store URL
+ * @param {object} [options]
+ * @param {string} [options.outputDir='.'] - Directory to save output
+ * @param {string} [options.name] - Custom filename (without extension)
+ * @param {boolean} [options.crx=false] - Also keep the raw .crx file
+ * @param {function} [options.onProgress] - Progress callback (bytesDownloaded, totalBytes)
+ * @returns {Promise<{id, zipPath, folderPath, crxPath?}>}
+ */
+export async function download(input, options = {}) {
+  const {
+    outputDir = process.cwd(),
+    name = null,
+    crx = false,
+    onProgress = null
+  } = options
+
+  const id = extractId(input)
+  const filename = (name || id) + '.crx'
+  const crxPath = path.resolve(outputDir, filename)
+
+  await downloadCrx(id, crxPath, { onProgress })
+
+  const { zipPath, folderPath } = await extractCrx(crxPath, outputDir)
+
+  const result = { id, zipPath, folderPath }
+
+  if (crx) {
+    // Re-download raw .crx and save it alongside the zip/folder
+    await downloadCrx(id, crxPath, {})
+    result.crxPath = crxPath
+  }
+
+  return result
+}
+
+/**
+ * Download multiple Chrome extensions in parallel.
+ *
+ * @param {string[]} inputs - Array of extension IDs or Chrome Web Store URLs
+ * @param {object} [options] - Same options as download(), applied to all
+ * @param {number} [options.concurrency=3] - Max simultaneous downloads
+ * @returns {Promise<Array<{id, zipPath, folderPath, crxPath?, error?}>>}
+ */
+export async function downloadBatch(inputs, options = {}) {
+  const { concurrency = 3, ...rest } = options
+  const results = []
+  const queue = [...inputs]
+
+  async function worker() {
+    while (queue.length > 0) {
+      const input = queue.shift()
+      try {
+        const result = await download(input, rest)
+        results.push(result)
+      } catch (err) {
+        const id = (() => { try { return extractId(input) } catch { return input } })()
+        results.push({ id, zipPath: null, folderPath: null, error: err.message })
+      }
+    }
+  }
+
+  await Promise.all(Array.from({ length: Math.min(concurrency, inputs.length) }, worker))
+  return results
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "crxpull",
+  "version": "1.0.1",
+  "description": "Download Chrome extensions as .crx files from the terminal",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js"
+  },
+  "bin": {
+    "crxpull": "./bin/crxpull.js"
+  },
+  "keywords": [
+    "chrome",
+    "extension",
+    "crx",
+    "download",
+    "cli",
+    "chromium",
+    "webstore",
+    "browser-extension",
+    "devtools",
+    "chrome-extension-downloader"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "adm-zip": "^0.5.16",
+    "chalk": "^5.3.0"
+  },
+  "files": [
+    "index.js",
+    "bin/",
+    "src/"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/crxpull"
+  },
+  "license": "MIT",
+  "scripts": {
+    "test": "node test/run.js",
+    "test:unit": "node test/run.js --unit",
+    "test:network": "node test/run.js --network",
+    "preflight": "node test/run.js"
+  }
+}

package/src/download.js

@@ -0,0 +1,96 @@
+import { createWriteStream, mkdirSync } from 'fs'
+import { get as httpsGet }             from 'https'
+import { Transform }                   from 'stream'
+import { pipeline }                    from 'stream/promises'
+import path                            from 'path'
+
+// The `x` query parameter must be URL-encoded — its value is itself a
+// key=value string. Passing `&x=id=${id}&uc` is wrong: `&uc` gets treated as
+// a separate top-level query param and the server ignores it, returning 204.
+// Correct form: `&x=${encodeURIComponent(`id=${id}&uc`)}`
+//
+// `acceptformat=crx2,crx3` is also required — omitting it causes 204 for any
+// extension that is CRX3-only (all modern extensions).
+//
+// Reference: https://stackoverflow.com/a/7184792
+//            https://github.com/Rob--W/crxviewer/blob/master/src/cws_pattern.js
+const CRX_URL = (id) =>
+  `https://clients2.google.com/service/update2/crx` +
+  `?response=redirect` +
+  `&prodversion=138.0.7204.51` +
+  `&acceptformat=crx2,crx3` +
+  `&x=${encodeURIComponent(`id=${id}&uc`)}`
+
+const HEADERS = {
+  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36',
+  'Accept':     '*/*',
+}
+
+// Node's native fetch has known issues with certain redirect chains
+// (body can be null on the final response). Using https.get directly gives
+// full stream control and reliable manual redirect following.
+function httpsGetFollow(url, maxRedirects = 10) {
+  return new Promise((resolve, reject) => {
+    let redirects = 0
+
+    function request(currentUrl) {
+      httpsGet(currentUrl, { headers: HEADERS }, (res) => {
+        const { statusCode, headers } = res
+
+        if (statusCode >= 300 && statusCode < 400 && headers.location) {
+          if (++redirects > maxRedirects) {
+            res.resume()
+            return reject(new Error('Too many redirects'))
+          }
+          res.resume() // drain and discard redirect body
+          return request(headers.location)
+        }
+
+        if (statusCode !== 200) {
+          res.resume()
+          return reject(new Error(`HTTP ${statusCode} — ${res.statusMessage ?? 'Error'}`))
+        }
+
+        resolve(res)
+      }).on('error', reject)
+    }
+
+    request(url)
+  })
+}
+
+async function fetchWithRetry(url, retries = 3, delay = 1000) {
+  let lastError
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      return await httpsGetFollow(url)
+    } catch (err) {
+      lastError = err
+      if (attempt < retries) await new Promise(r => setTimeout(r, delay * attempt))
+    }
+  }
+  throw lastError
+}
+
+export async function downloadCrx(id, outputPath, { onProgress } = {}) {
+  mkdirSync(path.dirname(outputPath), { recursive: true })
+
+  const res   = await fetchWithRetry(CRX_URL(id))
+  const total = parseInt(res.headers['content-length'] || '0', 10)
+  let downloaded = 0
+
+  if (onProgress && total > 0) {
+    const tracker = new Transform({
+      transform(chunk, _enc, cb) {
+        downloaded += chunk.length
+        onProgress(downloaded, total)
+        cb(null, chunk)
+      }
+    })
+    await pipeline(res, tracker, createWriteStream(outputPath))
+  } else {
+    await pipeline(res, createWriteStream(outputPath))
+  }
+
+  return outputPath
+}

package/src/extract.js

@@ -0,0 +1,61 @@
+import { readFileSync, mkdirSync, unlinkSync } from 'fs'
+import { join, basename } from 'path'
+
+function findZipStart(buf) {
+  if (buf[0] === 0x43 && buf[1] === 0x72 && buf[2] === 0x32 && buf[3] === 0x34) {
+    const version = buf.readUInt32LE(4)
+    if (version === 3) {
+      const headerSize = buf.readUInt32LE(8)
+      return 12 + headerSize
+    }
+    if (version === 2) {
+      const pubKeyLen = buf.readUInt32LE(8)
+      const sigLen = buf.readUInt32LE(12)
+      return 16 + pubKeyLen + sigLen
+    }
+  }
+  for (let i = 0; i < buf.length - 4; i++) {
+    if (buf[i] === 0x50 && buf[i + 1] === 0x4b && buf[i + 2] === 0x03 && buf[i + 3] === 0x04) {
+      return i
+    }
+  }
+  throw new Error('Could not find ZIP data in CRX file')
+}
+
+export async function crxToZip(crxPath, outputDir) {
+  const AdmZip = (await import('adm-zip')).default
+  const buf = readFileSync(crxPath)
+  const zipStart = findZipStart(buf)
+  const zipData = buf.slice(zipStart)
+
+  const name = basename(crxPath, '.crx')
+  const zipPath = join(outputDir, `${name}.zip`)
+
+  const zip = new AdmZip(zipData)
+  zip.writeZip(zipPath)
+
+  return zipPath
+}
+
+export async function crxToFolder(crxPath, outputDir) {
+  const AdmZip = (await import('adm-zip')).default
+  const buf = readFileSync(crxPath)
+  const zipStart = findZipStart(buf)
+  const zipData = buf.slice(zipStart)
+
+  const name = basename(crxPath, '.crx')
+  const folderPath = join(outputDir, name)
+  mkdirSync(folderPath, { recursive: true })
+
+  const zip = new AdmZip(zipData)
+  zip.extractAllTo(folderPath, true)
+
+  return folderPath
+}
+
+export async function extractCrx(crxPath, outputDir) {
+  const zipPath = await crxToZip(crxPath, outputDir)
+  const folderPath = await crxToFolder(crxPath, outputDir)
+  unlinkSync(crxPath)
+  return { zipPath, folderPath }
+}

package/src/info.js

@@ -0,0 +1,41 @@
+import { buildStoreUrl } from './utils.js'
+
+export async function fetchExtensionInfo(id) {
+  const url = buildStoreUrl(id)
+  const res = await fetch(url, {
+    headers: {
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/130.0.0.0 Safari/537.36'
+    }
+  })
+
+  if (!res.ok) throw new Error(`Could not fetch extension page (HTTP ${res.status})`)
+
+  const html = await res.text()
+
+  const meta = (property) => {
+    const match = html.match(new RegExp(`<meta[^>]+(?:name|property)="${property}"[^>]+content="([^"]*)"`, 'i'))
+      || html.match(new RegExp(`<meta[^>]+content="([^"]*)"[^>]+(?:name|property)="${property}"`, 'i'))
+    return match ? match[1].replace(/&#(\d+);/g, (_, n) => String.fromCharCode(n)) : null
+  }
+
+  const name = meta('og:title') || meta('twitter:title')
+  const description = meta('og:description') || meta('description')
+  const image = meta('og:image') || meta('twitter:image')
+
+  const ratingMatch = html.match(/"ratingValue"\s*:\s*"?([\d.]+)"?/)
+  const ratingCountMatch = html.match(/"ratingCount"\s*:\s*"?(\d+)"?/)
+  const usersMatch = html.match(/([\d,]+)\s+users/)
+  const versionMatch = html.match(/Version[\s\S]{0,50}?<[^>]*>([\d.]+)</)
+
+  return {
+    id,
+    name: name || 'Unknown',
+    description: description || null,
+    image: image || null,
+    rating: ratingMatch ? parseFloat(ratingMatch[1]) : null,
+    ratingCount: ratingCountMatch ? parseInt(ratingCountMatch[1]) : null,
+    users: usersMatch ? usersMatch[1] : null,
+    version: versionMatch ? versionMatch[1] : null,
+    storeUrl: url
+  }
+}

package/src/utils.js

@@ -0,0 +1,20 @@
+const EXT_ID_REGEX = /^[a-z]{32}$/
+
+export function extractId(input) {
+  const trimmed = input.trim()
+
+  const urlMatch = trimmed.match(/\/([a-z]{32})(?:[/?#]|$)/)
+  if (urlMatch) return urlMatch[1]
+
+  if (EXT_ID_REGEX.test(trimmed)) return trimmed
+
+  throw new Error(`Invalid extension ID or URL: "${trimmed}"`)
+}
+
+export function isValidId(id) {
+  return EXT_ID_REGEX.test(id)
+}
+
+export function buildStoreUrl(id) {
+  return `https://chromewebstore.google.com/detail/${id}`
+}