@involvex/ext-cli 1.0.1

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@involvex/ext-cli",
+  "version": "1.0.1",
+  "author": "involvex",
+  "type": "module",
+  "bin": {
+    "ext-cli": "./src/cli.ts"
+  },
+  "scripts": {
+    "build": "bun build src/cli.ts --compile --outfile dist/ext-cli.exe",
+    "dev": "bun run src/cli.ts",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/ test/",
+    "lint:fix": "biome check src/ test/ --fix",
+    "format": "biome format --write src/ test/",
+    "check": "bun run format && bun run lint:fix && bun run typecheck",
+    "prebuild": "bun run check"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.2",
+    "@types/bun": "latest",
+    "@types/node": "^26.1.0",
+    "@types/node-forge": "^1.3.14"
+  },
+  "peerDependencies": {
+    "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "chromium-edge-launcher": "^2.0.1",
+    "commander": "^15.0.0",
+    "node-forge": "^1.4.0"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,209 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import { downloadExtension } from "./downloader";
+import { extractCrx } from "./extractor";
+import { getEdgeInstallationPath, launch } from "./launcher";
+import { packCrx } from "./packer";
+import { searchExtensions } from "./search";
+
+const program = new Command();
+
+program
+  .name("ext-cli")
+  .description("Chrome/Edge Extension Manager - download, extract, and pack extensions")
+  .version("1.0.0");
+
+program
+  .command("get")
+  .description("Download an extension from Chrome Web Store or Edge Add-ons")
+  .argument("<url-or-id>", "Store URL or 32-char extension ID")
+  .option("-d, --dir <directory>", "Output directory", ".")
+  .option("-e, --extract", "Extract the CRX after downloading")
+  .action(async (urlOrId: string, opts: { dir: string; extract: boolean }) => {
+    try {
+      const crxPath = await downloadExtension(urlOrId, opts.dir);
+
+      if (opts.extract) {
+        const extDir = crxPath.replace(/\.crx$/, "");
+        await extractCrx(crxPath, extDir);
+        console.log(`\nDone! Extension extracted to: ${extDir}`);
+      } else {
+        console.log(`\nDone! CRX saved to: ${crxPath}`);
+      }
+    } catch (error) {
+      console.error(`Error: ${error instanceof Error ? error.message : error}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("extract")
+  .description("Extract a CRX file to a directory")
+  .argument("<crx-file>", "Path to .crx file")
+  .option("-d, --dir <directory>", "Output directory")
+  .action(async (crxFile: string, opts: { dir?: string }) => {
+    try {
+      const outputDir = opts.dir ?? crxFile.replace(/\.crx$/, "");
+      await extractCrx(crxFile, outputDir);
+      console.log(`\nDone! Extracted to: ${outputDir}`);
+    } catch (error) {
+      console.error(`Error: ${error instanceof Error ? error.message : error}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("pack")
+  .description("Pack a directory into a CRX file")
+  .argument("<directory>", "Extension directory containing manifest.json")
+  .option("-o, --output <path>", "Output CRX file path")
+  .action(async (directory: string, opts: { output?: string }) => {
+    try {
+      const crxPath = await packCrx(directory, opts.output);
+      console.log(`\nDone! Packed to: ${crxPath}`);
+    } catch (error) {
+      console.error(`Error: ${error instanceof Error ? error.message : error}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("search")
+  .description("Search Chrome Web Store and Edge Add-ons for extensions")
+  .argument("<query>", "Search query")
+  .action(async (query: string) => {
+    try {
+      console.log(`Searching for "${query}"...`);
+      const results = await searchExtensions(query);
+
+      if (results.length === 0) {
+        console.log("No extensions found.");
+        return;
+      }
+
+      console.log(`\nFound ${results.length} extensions:\n`);
+
+      for (const result of results) {
+        console.log(`- ${result.name}`);
+        console.log(`  ID: ${result.id}`);
+        console.log(`  Store: ${result.store}`);
+        console.log("");
+      }
+    } catch (error) {
+      console.error(`Error: ${error instanceof Error ? error.message : error}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("launch")
+  .description("Launch Edge with an extension loaded")
+  .option("-e, --extension <path>", "Path to extension directory or .crx file")
+  .option("--headless", "Run in headless mode")
+  .option("-u, --url <url>", "Starting URL", "about:blank")
+  .option("-p, --port <port>", "Remote debugging port")
+  .option("--keep-open", "Keep Edge open after Ctrl-C (don't auto-kill)")
+  .option("--user-data-dir <path>", "Custom user data directory")
+  .action(
+    async (opts: {
+      extension?: string;
+      headless?: boolean;
+      url?: string;
+      port?: string;
+      keepOpen?: boolean;
+      userDataDir?: string;
+    }) => {
+      try {
+        const edge = await launch({
+          extension: opts.extension,
+          headless: opts.headless,
+          url: opts.url,
+          port: opts.port ? parseInt(opts.port, 10) : undefined,
+          keepOpen: opts.keepOpen,
+          userDataDir: opts.userDataDir,
+        });
+
+        console.log(`\nEdge launched!`);
+        console.log(`  Debugging port: ${edge.port}`);
+        console.log(`  Process ID: ${edge.pid}`);
+
+        if (opts.keepOpen) {
+          console.log(`  Press Ctrl-C to stop Edge (--keep-open enabled)`);
+        } else {
+          console.log(`  Press Ctrl-C to stop Edge`);
+        }
+      } catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : error}`);
+        process.exit(1);
+      }
+    },
+  );
+
+program
+  .command("test")
+  .description("Download, extract, and launch an extension for testing")
+  .argument("<url-or-id>", "Store URL or 32-char extension ID")
+  .option("-d, --dir <directory>", "Output directory for download", ".")
+  .option("--headless", "Run in headless mode")
+  .option("-u, --url <url>", "Starting URL after launch", "about:blank")
+  .option("-p, --port <port>", "Remote debugging port")
+  .option("--keep-open", "Keep Edge open after Ctrl-C")
+  .action(
+    async (
+      urlOrId: string,
+      opts: {
+        dir?: string;
+        headless?: boolean;
+        url?: string;
+        port?: string;
+        keepOpen?: boolean;
+      },
+    ) => {
+      try {
+        console.log(`Downloading extension...`);
+        const crxPath = await downloadExtension(urlOrId, opts.dir ?? ".");
+
+        console.log(`Extracting...`);
+        const extDir = crxPath.replace(/\.crx$/, "");
+        await extractCrx(crxPath, extDir);
+
+        console.log(`Launching Edge...`);
+        const edge = await launch({
+          extension: extDir,
+          headless: opts.headless,
+          url: opts.url,
+          port: opts.port ? parseInt(opts.port, 10) : undefined,
+          keepOpen: opts.keepOpen,
+        });
+
+        console.log(`\nDone! Edge launched with extension.`);
+        console.log(`  Debugging port: ${edge.port}`);
+        console.log(`  Process ID: ${edge.pid}`);
+
+        if (opts.keepOpen) {
+          console.log(`  Press Ctrl-C to stop Edge (--keep-open enabled)`);
+        } else {
+          console.log(`  Press Ctrl-C to stop Edge`);
+        }
+      } catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : error}`);
+        process.exit(1);
+      }
+    },
+  );
+
+program
+  .command("edge-path")
+  .description("Show the path to the detected Edge installation")
+  .action(() => {
+    try {
+      const path = getEdgeInstallationPath();
+      console.log(path);
+    } catch (error) {
+      console.error(`Error: ${error instanceof Error ? error.message : error}`);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/src/crx-parser.ts

@@ -0,0 +1,35 @@
+// src/crx-parser.ts
+
+export interface CrxInfo {
+  version: number;
+  headerLength: number;
+  zipOffset: number;
+}
+
+const CRX_MAGIC = "Cr24";
+
+export function parseCrxHeader(buffer: Buffer): CrxInfo {
+  if (buffer.length < 12) {
+    throw new Error("Not a CRX file: buffer too small");
+  }
+
+  const magic = buffer.toString("ascii", 0, 4);
+  if (magic !== CRX_MAGIC) {
+    throw new Error(`Not a CRX file: invalid magic "${magic}" (expected "${CRX_MAGIC}")`);
+  }
+
+  const version = buffer.readUInt32LE(4);
+  if (version !== 2 && version !== 3) {
+    throw new Error(`Unsupported CRX version: ${version}`);
+  }
+
+  const headerLength = buffer.readUInt32LE(8);
+  const zipOffset = 12 + headerLength;
+
+  return { version, headerLength, zipOffset };
+}
+
+export function extractZipFromCrx(buffer: Buffer): Buffer {
+  const info = parseCrxHeader(buffer);
+  return buffer.subarray(info.zipOffset);
+}

package/src/downloader.ts

@@ -0,0 +1,61 @@
+// src/downloader.ts
+
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parseStoreUrl } from "./url-parser";
+
+const CHROME_CRX_URL =
+  "https://clients2.google.com/service/update2/crx?response=redirect&prodversion=131.0&acceptformat=crx2,crx3&x=id%3D{ID}%26uc";
+
+const EDGE_CRX_URL =
+  "https://edge.microsoft.com/extensionwebstorebase/v1/crx?response=redirect&x=id%3D{ID}%26installsource%3Dondemand%26uc";
+
+function buildDownloadUrl(id: string, store: "chrome" | "edge"): string {
+  const template = store === "chrome" ? CHROME_CRX_URL : EDGE_CRX_URL;
+  return template.replace("{ID}", id);
+}
+
+/**
+ * Download a CRX file from the Chrome Web Store or Edge Add-ons.
+ * Accepts a full store URL or a bare 32-char extension ID.
+ * Returns the path to the saved .crx file.
+ */
+export async function downloadExtension(urlOrId: string, outputDir: string = "."): Promise<string> {
+  const { id, store } = parseStoreUrl(urlOrId);
+  const downloadUrl = buildDownloadUrl(id, store);
+
+  console.log(`Downloading ${store} extension: ${id}`);
+  console.log(`URL: ${downloadUrl}`);
+
+  const response = await fetch(downloadUrl, {
+    headers: {
+      "User-Agent":
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+    },
+    redirect: "follow",
+  });
+
+  if (!response.ok) {
+    throw new Error(`Download failed: HTTP ${response.status} ${response.statusText}`);
+  }
+
+  const arrayBuffer = await response.arrayBuffer();
+  const buffer = Buffer.from(arrayBuffer);
+
+  // Verify it's a valid CRX file
+  const magic = buffer.toString("ascii", 0, 4);
+  if (magic !== "Cr24") {
+    throw new Error(
+      `Invalid CRX response: got "${magic}" instead of "Cr24". The extension may not exist or the store may have changed.`,
+    );
+  }
+
+  // Ensure output directory exists
+  await mkdir(outputDir, { recursive: true });
+
+  const outputPath = join(outputDir, `${id}.crx`);
+  await writeFile(outputPath, buffer);
+
+  console.log(`Saved: ${outputPath} (${(buffer.length / 1024).toFixed(1)} KB)`);
+  return outputPath;
+}

package/src/extractor.ts

@@ -0,0 +1,34 @@
+// src/extractor.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { extractZipFromCrx } from "./crx-parser";
+
+export async function extractCrx(crxPath: string, outputDir?: string): Promise<string> {
+  const crxBuffer = await readFile(crxPath);
+  const zipBuffer = extractZipFromCrx(crxBuffer);
+
+  const baseName = basename(crxPath, ".crx");
+  const destDir = outputDir ?? join(".", baseName);
+  await mkdir(destDir, { recursive: true });
+
+  const tempZip = join(destDir, "__temp__.zip");
+  await writeFile(tempZip, zipBuffer);
+
+  const proc = Bun.spawn([
+    "powershell",
+    "-Command",
+    `Expand-Archive -Path '${tempZip}' -DestinationPath '${destDir}' -Force`,
+  ]);
+  const exitCode = await proc.exited;
+
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`Failed to extract ZIP: ${stderr}`);
+  }
+
+  const { unlink } = await import("node:fs/promises");
+  await unlink(tempZip);
+
+  console.log(`Extracted to: ${destDir}`);
+  return destDir;
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+export { downloadExtension } from "./downloader";
+export { extractCrx } from "./extractor";
+export {
+  getDefaultFlags,
+  getEdgeInstallationPath,
+  killAllEdges,
+  type LaunchedEdge,
+  type LaunchOptions,
+  launch,
+} from "./launcher";
+export { packCrx } from "./packer";
+export {
+  searchChromeWebStore,
+  searchEdgeAddons,
+  searchExtensions,
+} from "./search";

package/src/launcher.ts

@@ -0,0 +1,107 @@
+import type { ChildProcess } from "node:child_process";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { getEdgePath, killAll, Launcher, launch as launchEdge } from "chromium-edge-launcher";
+import { extractCrx } from "./extractor";
+
+export interface LaunchOptions {
+  extension?: string;
+  headless?: boolean;
+  url?: string;
+  port?: number;
+  edgeFlags?: string[];
+  keepOpen?: boolean;
+  userDataDir?: string | boolean;
+}
+
+export interface LaunchedEdge {
+  port: number;
+  pid: number;
+  kill: () => void;
+  process: ChildProcess;
+}
+
+function isCrxFile(path: string): boolean {
+  return path.toLowerCase().endsWith(".crx");
+}
+
+async function prepareExtensionPath(extensionPath: string): Promise<string> {
+  if (isCrxFile(extensionPath)) {
+    const tempDir = mkdtempSync(join(tmpdir(), "ext-cli-"));
+    await extractCrx(extensionPath, tempDir);
+    return tempDir;
+  }
+  return extensionPath;
+}
+
+export async function launch(options: LaunchOptions = {}): Promise<LaunchedEdge> {
+  const {
+    extension,
+    headless = false,
+    url = "about:blank",
+    port,
+    edgeFlags = [],
+    keepOpen = false,
+    userDataDir,
+  } = options;
+
+  const flags = [...edgeFlags];
+
+  if (headless) {
+    flags.push("--headless=new", "--disable-gpu");
+  }
+
+  if (!keepOpen) {
+    flags.push("--disable-extensions-except");
+  }
+
+  let extPath: string | undefined;
+  let tempExtDir: string | undefined;
+
+  if (extension) {
+    if (!existsSync(extension)) {
+      throw new Error(`Extension path does not exist: ${extension}`);
+    }
+    extPath = await prepareExtensionPath(extension);
+    if (isCrxFile(extension)) {
+      tempExtDir = extPath;
+    }
+    flags.push(`--load-extension=${extPath}`);
+  }
+
+  const launched = await launchEdge({
+    startingUrl: url,
+    port,
+    edgeFlags: flags,
+    handleSIGINT: !keepOpen,
+    userDataDir,
+    ignoreDefaultFlags: false,
+  });
+
+  const kill = () => {
+    launched.kill();
+    if (tempExtDir && existsSync(tempExtDir)) {
+      rmSync(tempExtDir, { recursive: true, force: true });
+    }
+  };
+
+  return {
+    port: launched.port,
+    pid: launched.pid,
+    kill,
+    process: launched.process,
+  };
+}
+
+export function killAllEdges(): Error[] {
+  return killAll();
+}
+
+export function getEdgeInstallationPath(): string {
+  return getEdgePath();
+}
+
+export function getDefaultFlags(): string[] {
+  return Launcher.defaultFlags();
+}

package/src/packer.ts

@@ -0,0 +1,127 @@
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import forge from "node-forge";
+
+const ALPHABET = "abcdefghijklmnop";
+const CHUNK_SIZE = 8192;
+
+/**
+ * Safely encode a Buffer to a forge binary string without stack overflow.
+ * forge.util.binary.raw.encode uses String.fromCharCode.apply which
+ * overflows the stack for large buffers.
+ */
+function safeBinaryEncode(buf: Buffer): string {
+  let result = "";
+  for (let i = 0; i < buf.length; i += CHUNK_SIZE) {
+    result += String.fromCharCode.apply(
+      null,
+      buf.subarray(i, i + CHUNK_SIZE) as unknown as number[],
+    );
+  }
+  return result;
+}
+
+function computeExtensionId(publicKeyDer: Buffer): string {
+  const md = forge.md.sha256.create();
+  md.update(forge.util.binary.raw.encode(publicKeyDer));
+  const hash = forge.util.binary.raw.decode(md.digest().getBytes());
+  const idBytes = Array.from(hash.slice(0, 16));
+  return idBytes.map((b: number) => ALPHABET[b % 16]).join("");
+}
+
+function encodeVarint(value: number): number[] {
+  const bytes: number[] = [];
+  while (value > 0x7f) {
+    bytes.push((value & 0x7f) | 0x80);
+    value >>>= 7;
+  }
+  bytes.push(value & 0x7f);
+  return bytes;
+}
+
+function encodeField(fieldNumber: number, wireType: number, data: number[]): number[] {
+  const tag = encodeVarint((fieldNumber << 3) | wireType);
+  return [...tag, ...encodeVarint(data.length), ...data];
+}
+
+function buildCrx3Header(publicKeyDer: Buffer, signature: Buffer): Buffer {
+  const _pubKeyProof = encodeField(1, 2, [
+    ...encodeField(1, 2, Array.from(publicKeyDer)),
+    ...encodeField(2, 2, Array.from(signature)),
+  ]);
+
+  const asp = encodeField(2, 2, [
+    ...encodeField(1, 2, Array.from(publicKeyDer)),
+    ...encodeField(2, 2, Array.from(signature)),
+  ]);
+
+  const header = encodeField(1, 2, asp);
+  return Buffer.from(header);
+}
+
+export async function packCrx(dirPath: string, outputPath?: string): Promise<string> {
+  const manifestPath = join(dirPath, "manifest.json");
+  if (!existsSync(manifestPath)) {
+    throw new Error("No manifest.json found in directory");
+  }
+
+  JSON.parse(readFileSync(manifestPath, "utf-8"));
+
+  const keyPath = join(dirPath, "key.pem");
+  let privateKey: forge.pki.PrivateKey;
+
+  if (existsSync(keyPath)) {
+    const pem = readFileSync(keyPath, "utf-8");
+    privateKey = forge.pki.privateKeyFromPem(pem);
+  } else {
+    privateKey = forge.pki.rsa.generateKeyPair({ bits: 2048 }).privateKey;
+    const pem = forge.pki.privateKeyToPem(privateKey);
+    writeFileSync(keyPath, pem, "utf-8");
+  }
+
+  const pubDerBuf = Buffer.from(
+    forge.asn1
+      .toDer(forge.pki.publicKeyToAsn1(forge.pki.setRsaPublicKey(privateKey.n, privateKey.e)))
+      .getBytes(),
+    "binary",
+  );
+
+  const crxId = computeExtensionId(pubDerBuf);
+
+  const tmpZip = join(dirPath, "..", "__tmp_pack__.zip");
+  try {
+    execSync(
+      `powershell -NoProfile -Command "Compress-Archive -Path '${join(dirPath, "*")}' -DestinationPath '${tmpZip}' -Force"`,
+      { stdio: "pipe" },
+    );
+  } catch (e: unknown) {
+    throw new Error(`Failed to create ZIP: ${e instanceof Error ? e.message : String(e)}`);
+  }
+
+  const zipData = readFileSync(tmpZip);
+
+  const signMd = forge.md.sha256.create();
+  signMd.update(crxId);
+  signMd.update(safeBinaryEncode(zipData));
+
+  const sigBytes = privateKey.sign(signMd);
+
+  const headerBuf = buildCrx3Header(pubDerBuf, Buffer.from(sigBytes, "binary"));
+
+  const out = outputPath ?? join(dirPath, "output.crx");
+  const magic = Buffer.from("Cr24");
+  const version = Buffer.alloc(4);
+  version.writeUInt32LE(3, 0);
+  const headerLen = Buffer.alloc(4);
+  headerLen.writeUInt32LE(headerBuf.length, 0);
+
+  const result = Buffer.concat([magic, version, headerLen, headerBuf, zipData]);
+  writeFileSync(out, result);
+
+  try {
+    unlinkSync(tmpZip);
+  } catch {}
+
+  return out;
+}