@avalix/chroma 0.0.9 → 0.0.11

package/dist/{index.js → index.mjs}

@@ -4,9 +4,10 @@ import path from "node:path";
 import process from "node:process";
 
 //#region src/wallets/polkadot-js.ts
+const VERSION$1 = "0.62.6";
 const POLKADOT_JS_CONFIG = {
-	downloadUrl: "https://github.com/polkadot-js/extension/releases/download/v0.61.7/master-chrome-build.zip",
-	extensionName: "polkadot-extension-0.61.7"
+	downloadUrl: `https://github.com/polkadot-js/extension/releases/download/v${VERSION$1}/master-chrome-build.zip`,
+	extensionName: `polkadot-extension-${VERSION$1}`
 };
 async function findExtensionPopup$1(context, extensionId) {
 	const maxAttempts = 10;
@@ -25,7 +26,6 @@ async function getPolkadotJSExtensionPath() {
 	const extensionsDir = path.resolve(process.cwd(), ".chroma");
 	const extensionDir = path.join(extensionsDir, POLKADOT_JS_CONFIG.extensionName);
 	if (!fs.existsSync(extensionDir) || fs.readdirSync(extensionDir).length === 0) throw new Error(`Polkadot-JS extension not found at: ${extensionDir}\n\nPlease download the extension first by running:\n  npx @avalix/chroma download-extensions\n`);
-	console.log(`✅ Found Polkadot-JS extension at: ${extensionDir}`);
 	return extensionDir;
 }
 async function importPolkadotJSAccount(page, { seed, name = "Test Account", password = "h3llop0lkadot!" }) {
@@ -39,6 +39,7 @@ async function importPolkadotJSAccount(page, { seed, name = "Test Account", pass
 			await understoodButton.click();
 			await extensionPage.waitForTimeout(100);
 		}
+		if (await extensionPage.getByRole("button", { name: "I Understand" }).isVisible()) await extensionPage.getByRole("button", { name: "I Understand" }).click();
 		await extensionPage.goto(`${extensionPopupUrl}#/account/import-seed`);
 		await extensionPage.locator("textarea").fill(seed);
 		await extensionPage.locator("button:has-text(\"Next\")").click();
@@ -46,7 +47,6 @@ async function importPolkadotJSAccount(page, { seed, name = "Test Account", pass
 		await extensionPage.locator("input[type=\"password\"]").fill(password);
 		await extensionPage.locator("div").filter({ hasText: /^Repeat password for verification$/ }).getByRole("textbox").fill(password);
 		await extensionPage.getByRole("button", { name: "Add the account with the supplied seed" }).click();
-		console.log(`✅ Created Polkadot-JS wallet account: ${name}`);
 	} finally {
 		await extensionPage.close();
 	}
@@ -55,9 +55,9 @@ async function authorizePolkadotJS(page) {
 	const context = page.__extensionContext;
 	const extensionId = page.__extensionId;
 	const extensionPopup = await findExtensionPopup$1(context, extensionId);
-	await extensionPopup.getByText("Select all").click();
+	if (await extensionPopup.getByRole("button", { name: "I Understand" }).isVisible()) await extensionPopup.getByRole("button", { name: "I Understand" }).click();
+	if (!await extensionPopup.getByText("Select all").locator("..").locator("input[type=\"checkbox\"]").isChecked().catch(() => false)) await extensionPopup.getByText("Select all").click();
 	await extensionPopup.getByRole("button", { name: /Connect \d+ account\(s\)/ }).click();
-	console.log("✅ Polkadot-JS wallet connected successfully");
 }
 async function approvePolkadotJSTx(page, options = {}) {
 	const { password = "h3llop0lkadot!" } = options;
@@ -66,20 +66,19 @@ async function approvePolkadotJSTx(page, options = {}) {
 	const extensionPopup = await findExtensionPopup$1(context, extensionId);
 	await extensionPopup.getByRole("textbox").fill(password);
 	await extensionPopup.getByRole("button", { name: "Sign the transaction" }).click();
-	console.log("✅ Polkadot-JS transaction signed successfully");
 }
 async function rejectPolkadotJSTx(page) {
 	const context = page.__extensionContext;
 	const extensionId = page.__extensionId;
 	await (await findExtensionPopup$1(context, extensionId)).getByRole("link", { name: "Cancel" }).click();
-	console.log("✅ Polkadot-JS transaction rejected successfully");
 }
 
 //#endregion
 //#region src/wallets/talisman.ts
+const VERSION = "3.1.13";
 const TALISMAN_CONFIG = {
-	downloadUrl: "https://github.com/avalix-labs/polkadot-wallets/raw/refs/heads/main/talisman/talisman-3.0.5.zip",
-	extensionName: "talisman-extension-3.0.5"
+	downloadUrl: `https://github.com/avalix-labs/polkadot-wallets/raw/refs/heads/main/talisman/talisman-${VERSION}.zip`,
+	extensionName: `talisman-extension-${VERSION}`
 };
 async function findExtensionPopup(context, extensionId) {
 	const maxAttempts = 10;
@@ -102,7 +101,6 @@ async function getTalismanExtensionPath() {
 	const extensionsDir = path.resolve(process.cwd(), ".chroma");
 	const extensionDir = path.join(extensionsDir, TALISMAN_CONFIG.extensionName);
 	if (!fs.existsSync(extensionDir) || fs.readdirSync(extensionDir).length === 0) throw new Error(`Talisman extension not found at: ${extensionDir}\n\nPlease download the extension first by running:\n  npx @avalix/chroma download-extensions\n`);
-	console.log(`✅ Found Talisman extension at: ${extensionDir}`);
 	return extensionDir;
 }
 async function importEthPrivateKey(page, { seed, name = "Test Account", password = "h3llop0lkadot!" }) {
@@ -115,18 +113,13 @@ async function importEthPrivateKey(page, { seed, name = "Test Account", password
 		const pages = context.pages();
 		for (const p of pages) {
 			const url = p.url();
-			console.log(`📄 Found page: ${url}`);
 			if (url.includes("onboarding.html") || url.includes(`chrome-extension://${extensionId}/`)) {
 				extensionPage = p;
-				console.log(`✅ Found Talisman onboarding page: ${url}`);
 				break;
 			}
 		}
 		if (extensionPage) break;
-		if (attempt < maxAttempts - 1) {
-			console.log(`⏳ Attempt ${attempt + 1}/${maxAttempts}: Waiting for onboarding page...`);
-			await new Promise((resolve) => setTimeout(resolve, retryDelay));
-		}
+		if (attempt < maxAttempts - 1) await new Promise((resolve) => setTimeout(resolve, retryDelay));
 	}
 	if (!extensionPage) throw new Error(`Talisman onboarding page not found after ${maxAttempts} attempts`);
 	try {
@@ -147,7 +140,6 @@ async function importEthPrivateKey(page, { seed, name = "Test Account", password
 		await extensionPage.getByRole("textbox", { name: "Enter your private key" }).fill(seed);
 		await extensionPage.getByRole("button", { name: "Save" }).click();
 		await extensionPage.close();
-		console.log("✅ Talisman account import completed");
 	} catch (error) {
 		console.error("❌ Error during Talisman account import:", error);
 		throw error;
@@ -162,14 +154,18 @@ async function authorizeTalisman(page, options = {}) {
 	await extensionPopup.getByTestId("connection-connect-button").click();
 	try {
 		await (await findExtensionPopup(context, extensionId)).getByRole("button", { name: "Approve" }).click();
-	} catch {
-		console.log("No another popup found, skipping");
-	}
+	} catch {}
 }
 async function approveTalismanTx(page) {
 	const context = page.__extensionContext;
 	const extensionId = page.__extensionId;
-	await (await findExtensionPopup(context, extensionId)).getByRole("button", { name: "Approve" }).click();
+	const extensionPopup = await findExtensionPopup(context, extensionId);
+	try {
+		await extensionPopup.getByRole("button", { name: "Yes" }).click();
+	} catch {
+		console.log("No another popup found, skipping");
+	}
+	await extensionPopup.getByRole("button", { name: "Approve" }).click();
 }
 async function rejectTalismanTx(page) {
 	const context = page.__extensionContext;
@@ -194,8 +190,7 @@ function createWalletInstance(walletType, extensionId, context) {
 	const baseInstance = {
 		extensionId,
 		importMnemonic: async (options) => {
-			const page = context.pages()[0] || await context.newPage();
-			const extPage = createExtendedPage(page, context, extensionId);
+			const extPage = createExtendedPage(context.pages()[0] || await context.newPage(), context, extensionId);
 			importedAccountName = options.name || "Test Account";
 			switch (walletType) {
 				case "polkadot-js":
@@ -206,8 +201,7 @@ function createWalletInstance(walletType, extensionId, context) {
 			}
 		},
 		authorize: async (options = {}) => {
-			const page = context.pages()[0] || await context.newPage();
-			const extPage = createExtendedPage(page, context, extensionId);
+			const extPage = createExtendedPage(context.pages()[0] || await context.newPage(), context, extensionId);
 			const accountName = options.accountName || importedAccountName;
 			switch (walletType) {
 				case "polkadot-js":
@@ -220,8 +214,7 @@ function createWalletInstance(walletType, extensionId, context) {
 			}
 		},
 		approveTx: async (options = {}) => {
-			const page = context.pages()[0] || await context.newPage();
-			const extPage = createExtendedPage(page, context, extensionId);
+			const extPage = createExtendedPage(context.pages()[0] || await context.newPage(), context, extensionId);
 			switch (walletType) {
 				case "polkadot-js":
 					await approvePolkadotJSTx(extPage, options);
@@ -233,8 +226,7 @@ function createWalletInstance(walletType, extensionId, context) {
 			}
 		},
 		rejectTx: async () => {
-			const page = context.pages()[0] || await context.newPage();
-			const extPage = createExtendedPage(page, context, extensionId);
+			const extPage = createExtendedPage(context.pages()[0] || await context.newPage(), context, extensionId);
 			switch (walletType) {
 				case "polkadot-js":
 					await rejectPolkadotJSTx(extPage);
@@ -255,8 +247,7 @@ function createWalletInstance(walletType, extensionId, context) {
 			...baseInstance,
 			type: "talisman",
 			importEthPrivateKey: async (options) => {
-				const page = context.pages()[0] || await context.newPage();
-				const extPage = createExtendedPage(page, context, extensionId);
+				const extPage = createExtendedPage(context.pages()[0] || await context.newPage(), context, extensionId);
 				importedAccountName = options.name || "Test Account";
 				await importEthPrivateKey(extPage, {
 					seed: options.privateKey,
@@ -304,7 +295,6 @@ function createWalletTest(options = {}) {
 				const extensionId = allServiceWorkers[i].url().split("/")[2];
 				const walletType = walletConfigs[i].type;
 				extensionIds.set(walletType, extensionId);
-				console.log(`✅ Loaded ${walletType} extension with ID: ${extensionId}`);
 			}
 			await use(extensionIds);
 		}, { scope: "worker" }],

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@avalix/chroma",
   "type": "module",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "End-to-end testing library for Polkadot wallet interactions",
   "author": "Avalix Labs",
   "license": "MIT",
@@ -24,12 +24,12 @@
     "blockchain"
   ],
   "exports": {
-    ".": "./dist/index.js",
+    ".": "./dist/index.mjs",
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "bin": {
     "chroma": "./scripts/cli.js"
   },
@@ -43,22 +43,27 @@
     "dev": "tsdown --watch",
     "lint": "eslint --fix .",
     "prepublishOnly": "npm run build",
-    "download-extensions": "rm -rf .chroma && tsx scripts/download-extensions.ts"
+    "download-extensions": "rm -rf .chroma && tsx scripts/download-extensions.ts",
+    "test": "playwright test --ui",
+    "test:unit": "vitest",
+    "test:unit:run": "vitest run",
+    "test:unit:coverage": "vitest run --coverage"
   },
   "peerDependencies": {
-    "@playwright/test": "^1.55.0"
+    "@playwright/test": "^1.57.0"
   },
   "dependencies": {
-    "unzipper": "^0.12.3"
+    "adm-zip": "^0.5.16"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^5.3.0",
-    "@playwright/test": "^1.55.0",
-    "@types/node": "^24.3.3",
-    "@types/unzipper": "^0.10.10",
-    "eslint": "^9.35.0",
-    "tsdown": "latest",
-    "tsx": "^4.20.6"
+    "@antfu/eslint-config": "^6.5.1",
+    "@playwright/test": "^1.57.0",
+    "@types/node": "^24.10.2",
+    "@types/unzipper": "^0.10.11",
+    "eslint": "^9.39.1",
+    "tsdown": "^0.20.1",
+    "tsx": "^4.21.0",
+    "vitest": "^4.0.18"
   },
   "publishConfig": {
     "access": "public"

package/scripts/download-extensions.ts

@@ -1,13 +1,38 @@
 #!/usr/bin/env node
+import fs from 'node:fs'
+import path from 'node:path'
 import process from 'node:process'
+import { fileURLToPath } from 'node:url'
 import { downloadAndExtractExtension } from '../src/utils/download-extension.js'
 import { POLKADOT_JS_CONFIG } from '../src/wallets/polkadot-js.js'
 import { TALISMAN_CONFIG } from '../src/wallets/talisman.js'
 
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+async function getVersion(): Promise<string> {
+  const packageJsonPath = path.resolve(__dirname, '../package.json')
+  const packageJson = JSON.parse(await fs.promises.readFile(packageJsonPath, 'utf-8'))
+  return packageJson.version
+}
+
+async function clearChromaDir(): Promise<void> {
+  const chromaDir = path.resolve(process.cwd(), '.chroma')
+
+  if (fs.existsSync(chromaDir)) {
+    console.log('🗑️  Clearing existing .chroma directory...')
+    await fs.promises.rm(chromaDir, { recursive: true, force: true })
+  }
+}
+
 async function main() {
-  console.log('🚀 Downloading Chroma wallet extensions...\n')
+  const version = await getVersion()
+  console.log(`🎨 Chroma v${version}\n`)
+  console.log('🚀 Downloading wallet extensions...\n')
 
   try {
+    // Clear existing .chroma directory
+    await clearChromaDir()
+
     // Download Polkadot-JS extension
     await downloadAndExtractExtension({
       downloadUrl: POLKADOT_JS_CONFIG.downloadUrl,

package/src/context-playwright/index.ts

@@ -97,7 +97,6 @@ export function createWalletTest<const T extends readonly WalletConfig[]>(
         const extensionId = allServiceWorkers[i].url().split('/')[2]
         const walletType = walletConfigs[i].type
         extensionIds.set(walletType, extensionId)
-        console.log(`✅ Loaded ${walletType} extension with ID: ${extensionId}`)
       }
 
       await use(extensionIds)

package/src/utils/download-extension.integration.test.ts

@@ -0,0 +1,95 @@
+import type { DownloadExtensionOptions } from './download-extension.js'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { downloadAndExtractExtension } from './download-extension.js'
+
+/**
+ * Integration Tests (real download) - Requires network
+ * Tests actual download and extraction with real extension files
+ *
+ * Important test cases:
+ * - Nested zip extraction (Talisman has a zip inside a zip)
+ * - Standard zip extraction (Polkadot-JS)
+ * - Skip download if already exists
+ * - Error handling for invalid URLs
+ */
+describe('downloadAndExtractExtension (integration tests)', () => {
+  let tempDir: string
+
+  beforeEach(async () => {
+    tempDir = path.join(os.tmpdir(), `chroma-test-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+    await fs.promises.mkdir(tempDir, { recursive: true })
+  })
+
+  afterEach(async () => {
+    if (tempDir && fs.existsSync(tempDir)) {
+      await fs.promises.rm(tempDir, { recursive: true, force: true })
+    }
+  })
+
+  it('should handle nested zip extraction (Talisman)', async () => {
+    // Talisman extension has a nested zip structure
+    const VERSION = '3.1.13'
+    const options: DownloadExtensionOptions = {
+      downloadUrl: `https://github.com/avalix-labs/polkadot-wallets/raw/refs/heads/main/talisman/talisman-${VERSION}.zip`,
+      extensionName: `talisman-extension-${VERSION}`,
+      targetDir: tempDir,
+    }
+
+    const result = await downloadAndExtractExtension(options)
+
+    expect(result).toBe(path.join(tempDir, `talisman-extension-${VERSION}`))
+    expect(fs.existsSync(result)).toBe(true)
+
+    // Talisman should have manifest.json after nested extraction
+    const files = await fs.promises.readdir(result)
+    expect(files).toContain('manifest.json')
+  }, 60000)
+
+  it('should handle standard zip extraction (Polkadot-JS)', async () => {
+    const VERSION = '0.62.6'
+    const options: DownloadExtensionOptions = {
+      downloadUrl: `https://github.com/polkadot-js/extension/releases/download/v${VERSION}/master-chrome-build.zip`,
+      extensionName: `polkadot-extension-${VERSION}`,
+      targetDir: tempDir,
+    }
+
+    const result = await downloadAndExtractExtension(options)
+
+    expect(result).toBe(path.join(tempDir, `polkadot-extension-${VERSION}`))
+    expect(fs.existsSync(result)).toBe(true)
+
+    const files = await fs.promises.readdir(result)
+    expect(files).toContain('manifest.json')
+  }, 60000)
+
+  it('should skip download if extension already exists', async () => {
+    const extensionDir = path.join(tempDir, 'existing-extension')
+    await fs.promises.mkdir(extensionDir, { recursive: true })
+    await fs.promises.writeFile(path.join(extensionDir, 'manifest.json'), '{"name": "test"}')
+
+    const options: DownloadExtensionOptions = {
+      downloadUrl: 'https://example.com/should-not-be-called.zip',
+      extensionName: 'existing-extension',
+      targetDir: tempDir,
+    }
+
+    const result = await downloadAndExtractExtension(options)
+
+    expect(result).toBe(extensionDir)
+  })
+
+  it('should throw error for invalid URL', async () => {
+    const options: DownloadExtensionOptions = {
+      downloadUrl: 'https://github.com/invalid-user-12345/nonexistent-repo/releases/download/v0.0.0/nonexistent.zip',
+      extensionName: 'invalid-extension',
+      targetDir: tempDir,
+    }
+
+    await expect(downloadAndExtractExtension(options)).rejects.toThrow(
+      /Failed to download\/extract invalid-extension/,
+    )
+  }, 15000)
+})

package/src/utils/download-extension.test.ts

@@ -0,0 +1,173 @@
+import type { DownloadExtensionOptions } from './download-extension.js'
+import fs from 'node:fs'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { downloadAndExtractExtension } from './download-extension.js'
+
+/**
+ * Unit Tests (with mocks) - Fast, no network required
+ * Tests error handling, cleanup logic, and path resolution
+ */
+
+// Mock adm-zip
+const mockExtractAllTo = vi.fn()
+vi.mock('adm-zip', () => {
+  return {
+    default: vi.fn().mockImplementation(() => ({
+      extractAllTo: mockExtractAllTo,
+    })),
+  }
+})
+
+// Mock fetch
+const mockFetch = vi.fn()
+vi.stubGlobal('fetch', mockFetch)
+
+// Mock stream/promises pipeline
+vi.mock('node:stream/promises', () => ({
+  pipeline: vi.fn().mockResolvedValue(undefined),
+}))
+
+// Mock fs module
+vi.mock('node:fs', async () => {
+  const actual = await vi.importActual<typeof import('node:fs')>('node:fs')
+  return {
+    ...actual,
+    default: {
+      ...actual,
+      existsSync: vi.fn(),
+      readdirSync: vi.fn(),
+      promises: {
+        mkdir: vi.fn().mockResolvedValue(undefined),
+        rm: vi.fn().mockResolvedValue(undefined),
+        rename: vi.fn().mockResolvedValue(undefined),
+        unlink: vi.fn().mockResolvedValue(undefined),
+        readdir: vi.fn().mockResolvedValue([]),
+      },
+      createWriteStream: vi.fn().mockReturnValue({
+        on: vi.fn(),
+        write: vi.fn(),
+        end: vi.fn(),
+      }),
+    },
+    existsSync: vi.fn(),
+    readdirSync: vi.fn(),
+    createWriteStream: vi.fn().mockReturnValue({
+      on: vi.fn(),
+      write: vi.fn(),
+      end: vi.fn(),
+    }),
+  }
+})
+
+describe('downloadAndExtractExtension (unit tests)', () => {
+  const mockOptions: DownloadExtensionOptions = {
+    downloadUrl: 'https://example.com/extension.zip',
+    extensionName: 'test-extension',
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.spyOn(console, 'log').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe('when extension already exists', () => {
+    it('should skip download and return existing path', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(true)
+      mockedFs.readdirSync.mockReturnValue(['manifest.json'] as any)
+
+      const result = await downloadAndExtractExtension(mockOptions)
+
+      expect(result).toContain('test-extension')
+      expect(mockFetch).not.toHaveBeenCalled()
+      expect(console.log).toHaveBeenCalledWith(
+        expect.stringContaining('already exists'),
+        expect.any(String),
+      )
+    })
+  })
+
+  describe('when extension does not exist', () => {
+    beforeEach(() => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(false)
+      mockedFs.readdirSync.mockReturnValue([])
+    })
+
+    it('should throw error when download fails with bad status', async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 404,
+        statusText: 'Not Found',
+      })
+
+      await expect(downloadAndExtractExtension(mockOptions)).rejects.toThrow(
+        'Failed to download/extract test-extension',
+      )
+    })
+
+    it('should throw error when fetch throws network error', async () => {
+      mockFetch.mockRejectedValue(new Error('Network error'))
+
+      await expect(downloadAndExtractExtension(mockOptions)).rejects.toThrow(
+        'Failed to download/extract test-extension: Network error',
+      )
+    })
+
+    it('should cleanup files on error', async () => {
+      const mockedFs = vi.mocked(fs)
+
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+      })
+
+      mockedFs.existsSync.mockImplementation((p: fs.PathLike) => {
+        const pathStr = p.toString()
+        if (pathStr.endsWith('test-extension') && !pathStr.includes('.zip')) {
+          return false
+        }
+        return true
+      })
+
+      await expect(downloadAndExtractExtension(mockOptions)).rejects.toThrow()
+
+      expect(mockedFs.promises.unlink).toHaveBeenCalled()
+      expect(mockedFs.promises.rm).toHaveBeenCalled()
+    })
+  })
+
+  describe('targetDir option', () => {
+    it('should use custom targetDir when provided', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(true)
+      mockedFs.readdirSync.mockReturnValue(['manifest.json'] as any)
+
+      const customOptions: DownloadExtensionOptions = {
+        ...mockOptions,
+        targetDir: '/custom/path',
+      }
+
+      const result = await downloadAndExtractExtension(customOptions)
+
+      expect(result).toBe(path.join('/custom/path', 'test-extension'))
+    })
+
+    it('should use default .chroma directory when targetDir not provided', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(true)
+      mockedFs.readdirSync.mockReturnValue(['manifest.json'] as any)
+
+      const result = await downloadAndExtractExtension(mockOptions)
+
+      expect(result).toContain('.chroma')
+      expect(result).toContain('test-extension')
+    })
+  })
+})

package/src/utils/download-extension.ts

@@ -2,7 +2,7 @@ import fs, { createWriteStream } from 'node:fs'
 import path from 'node:path'
 import process from 'node:process'
 import { pipeline } from 'node:stream/promises'
-import { Extract } from 'unzipper'
+import AdmZip from 'adm-zip'
 
 export interface DownloadExtensionOptions {
   downloadUrl: string
@@ -10,6 +10,11 @@ export interface DownloadExtensionOptions {
   targetDir?: string
 }
 
+function unzipFile(zipPath: string, destDir: string): void {
+  const zip = new AdmZip(zipPath)
+  zip.extractAllTo(destDir, true)
+}
+
 export async function downloadAndExtractExtension(options: DownloadExtensionOptions): Promise<string> {
   const { downloadUrl, extensionName, targetDir } = options
 
@@ -17,6 +22,7 @@ export async function downloadAndExtractExtension(options: DownloadExtensionOpti
   const extensionsDir = targetDir || path.resolve(process.cwd(), '.chroma')
   const extensionDir = path.join(extensionsDir, extensionName)
   const zipPath = path.join(extensionsDir, `${extensionName}.zip`)
+  const tempExtractDir = path.join(extensionsDir, `${extensionName}-temp`)
 
   // Create extensions directory if it doesn't exist
   await fs.promises.mkdir(extensionsDir, { recursive: true })
@@ -42,11 +48,29 @@ export async function downloadAndExtractExtension(options: DownloadExtensionOpti
 
     console.log('📦 Extracting extension...')
 
-    // Standard zip extraction
-    await pipeline(
-      fs.createReadStream(zipPath),
-      Extract({ path: extensionDir }),
-    )
+    // Extract to temp directory first
+    await fs.promises.mkdir(tempExtractDir, { recursive: true })
+    unzipFile(zipPath, tempExtractDir)
+
+    // Check if it's a nested zip (contains another .zip file)
+    const files = await fs.promises.readdir(tempExtractDir)
+    const nestedZip = files.find(f => f.endsWith('.zip'))
+
+    if (nestedZip) {
+      console.log(`📦 Found nested zip: ${nestedZip}, extracting...`)
+      const nestedZipPath = path.join(tempExtractDir, nestedZip)
+
+      // Extract the nested zip to final location
+      await fs.promises.mkdir(extensionDir, { recursive: true })
+      unzipFile(nestedZipPath, extensionDir)
+
+      // Clean up temp directory
+      await fs.promises.rm(tempExtractDir, { recursive: true, force: true })
+    }
+    else {
+      // No nested zip, just rename temp to final
+      await fs.promises.rename(tempExtractDir, extensionDir)
+    }
 
     // Clean up ZIP file
     await fs.promises.unlink(zipPath)
@@ -62,6 +86,9 @@ export async function downloadAndExtractExtension(options: DownloadExtensionOpti
     if (fs.existsSync(extensionDir)) {
       await fs.promises.rm(extensionDir, { recursive: true, force: true }).catch(() => {})
     }
+    if (fs.existsSync(tempExtractDir)) {
+      await fs.promises.rm(tempExtractDir, { recursive: true, force: true }).catch(() => {})
+    }
 
     throw new Error(`Failed to download/extract ${extensionName}: ${error instanceof Error ? error.message : String(error)}`)
   }