feat: support custom CDN URL with Basic Auth credentials (#282) (#534)

* feat: support custom CDN URL with Basic Auth credentials (#282)

* Update src/utils.ts

---------

Co-authored-by: Mrunal chaudhari <mchaudhari@tjc-group.com>
Co-authored-by: Christian Bromann <git@bromann.dev>

Author: 3 people

src/install.ts

@@ -11,7 +11,7 @@ import { HttpProxyAgent } from 'http-proxy-agent'
 
 import findEdgePath from './finder.js'
 import { TAGGED_VERSIONS, EDGE_PRODUCTS_API, EDGEDRIVER_BUCKET, TAGGED_VERSION_URL, LATEST_RELEASE_URL, DOWNLOAD_URL, BINARY_FILE, log } from './constants.js'
-import { hasAccess, getNameByArchitecture, sleep } from './utils.js'
+import { hasAccess, getNameByArchitecture, sleep, extractBasicAuthFromUrl } from './utils.js'
 
 interface ProductAPIResponse {
     Product: string
@@ -67,9 +67,14 @@ export async function download (
 
 async function downloadDriver(version: string) {
     try {
-        const downloadUrl = format(DOWNLOAD_URL, version, getNameByArchitecture())
+        const rawDownloadUrl = format(DOWNLOAD_URL, version, getNameByArchitecture())
+        const { url: downloadUrl, authHeader } = extractBasicAuthFromUrl(rawDownloadUrl)
         log.info(`Downloading Edgedriver from ${downloadUrl}`)
-        const res = await fetch(downloadUrl, fetchOpts)
+        const opts: NodeRequestInit = { ...fetchOpts }
+        if (authHeader) {
+            opts.headers = { ...opts.headers, Authorization: authHeader }
+        }
+        const res = await fetch(downloadUrl, opts)
 
         if (!res.body || !res.ok || res.status !== 200) {
             throw new Error(`Failed to download binary from ${downloadUrl} (statusCode ${res.status})`)
@@ -112,9 +117,14 @@ async function downloadDriver(version: string) {
         log.info(`Downloading alternative Edgedriver version from ${alternativeDownloadUrl}`)
         const versionResponse = await fetch(alternativeDownloadUrl, fetchOpts)
         const alternativeVersion = sanitizeVersion(await versionResponse.text())
-        const downloadUrl = format(DOWNLOAD_URL, alternativeVersion, getNameByArchitecture())
+        const rawDownloadUrl = format(DOWNLOAD_URL, alternativeVersion, getNameByArchitecture())
+        const { url: downloadUrl, authHeader } = extractBasicAuthFromUrl(rawDownloadUrl)
         log.info(`Downloading Edgedriver from ${downloadUrl}`)
-        const res = await fetch(downloadUrl, fetchOpts)
+        const opts: NodeRequestInit = { ...fetchOpts }
+        if (authHeader) {
+            opts.headers = { ...opts.headers, Authorization: authHeader }
+        }
+        const res = await fetch(downloadUrl, opts)
         if (!res.body || !res.ok || res.status !== 200) {
             throw new Error(`Failed to download binary from ${downloadUrl} (statusCode ${res.status})`)
         }

src/utils.ts

@@ -110,3 +110,32 @@ export async function hasAccess(filePath: string) {
 export function sleep (ms = 100) {
     return new Promise((resolve) => setTimeout(resolve, ms))
 }
+
+export interface BasicAuthResult {
+    url: string
+    authHeader?: string
+}
+
+/**
+ * Extract Basic Auth credentials from a URL and return the cleaned URL with auth header.
+ * This is needed because fetch() doesn't support URLs with embedded credentials.
+ * @param urlString URL that may contain credentials (e.g., https://user:pass@host/)
+ * @returns Object with cleaned URL and optional Authorization header
+ */
+export function extractBasicAuthFromUrl(urlString: string): BasicAuthResult {
+    try {
+        const url = new URL(urlString)
+        if (url.username || url.password) {
+            const credentials = btoa(`${url.username}:${url.password}`)
+            url.username = ''
+            url.password = ''
+            return {
+                url: url.toString(),
+                authHeader: `Basic ${credentials}`
+            }
+        }
+    } catch {
+        // If URL parsing fails, return original string
+    }
+    return { url: urlString }
+}

tests/unit.test.ts

@@ -3,7 +3,7 @@ import { vi, test, expect } from 'vitest'
 
 import * as pkgExports from '../src/index.js'
 import { fetchVersion } from '../src/install.js'
-import { getNameByArchitecture, parseParams } from '../src/utils.js'
+import { getNameByArchitecture, parseParams, extractBasicAuthFromUrl } from '../src/utils.js'
 import { EDGE_PRODUCTS_API } from '../src/constants.js'
 
 vi.mock('node:os', () => ({
@@ -116,3 +116,28 @@ test('exports', () => {
     expect(typeof pkgExports.findEdgePath).toBe('function')
     expect(typeof pkgExports.start).toBe('function')
 })
+
+test('extractBasicAuthFromUrl with credentials', () => {
+    const result = extractBasicAuthFromUrl('https://myuser:mypassword@cdn.example.com/path/file.zip')
+    expect(result.url).toBe('https://cdn.example.com/path/file.zip')
+    expect(result.authHeader).toBe('Basic ' + Buffer.from('myuser:mypassword').toString('base64'))
+})
+
+test('extractBasicAuthFromUrl without credentials', () => {
+    const result = extractBasicAuthFromUrl('https://cdn.example.com/path/file.zip')
+    expect(result.url).toBe('https://cdn.example.com/path/file.zip')
+    expect(result.authHeader).toBeUndefined()
+})
+
+test('extractBasicAuthFromUrl with only username', () => {
+    const result = extractBasicAuthFromUrl('https://myuser@cdn.example.com/path/file.zip')
+    expect(result.url).toBe('https://cdn.example.com/path/file.zip')
+    expect(result.authHeader).toBe('Basic ' + Buffer.from('myuser:').toString('base64'))
+})
+
+test('extractBasicAuthFromUrl with invalid URL returns original', () => {
+    const result = extractBasicAuthFromUrl('not-a-valid-url')
+    expect(result.url).toBe('not-a-valid-url')
+    expect(result.authHeader).toBeUndefined()
+})
+