@pioneer-platform/pioneer-discovery 0.8.4 → 4.21.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pioneer-platform/pioneer-discovery",
-  "version": "0.8.4",
+  "version": "4.21.16",
   "main": "./lib/index.js",
   "types": "./lib/main.d.ts",
   "_moduleAliases": {

package/scripts/.coingecko-failed.json

@@ -0,0 +1,46 @@
+{
+  "assets": {
+    "eip155:1/erc20:0x0173661769325565d4f011b2e5cda688689cc87c": {
+      "symbol": "QLT",
+      "name": "Quantland",
+      "chainId": "eip155:1",
+      "error": "Not found",
+      "attempts": 1
+    },
+    "eip155:1/erc20:0x0198f46f520f33cd4329bd4be380a25a90536cd5": {
+      "symbol": "PLA",
+      "name": "PlayChip",
+      "chainId": "eip155:1",
+      "error": "Not found",
+      "attempts": 1
+    },
+    "eip155:1/erc20:0x01792e1548dc317bde6123fe92da1fe6d7311c3c": {
+      "symbol": "SPIRAL",
+      "name": "Spiral",
+      "chainId": "eip155:1",
+      "error": "Not found",
+      "attempts": 1
+    },
+    "eip155:1/erc20:0x017e9db34fc69af0dc7c7b4b33511226971cddc7": {
+      "symbol": "OCD",
+      "name": "On Chain Dynamics",
+      "chainId": "eip155:1",
+      "error": "Not found",
+      "attempts": 1
+    },
+    "eip155:1/erc20:0x018fb5af9d015af25592a014c4266a84143de7a0": {
+      "symbol": "MP3",
+      "name": "MP3",
+      "chainId": "eip155:1",
+      "error": "Not found",
+      "attempts": 1
+    },
+    "eip155:1/erc20:0x01b23286ff60a543ec29366ae8d6b6274ca20541": {
+      "symbol": "BMP",
+      "name": "Brother Music Platform",
+      "chainId": "eip155:1",
+      "error": "Not found",
+      "attempts": 1
+    }
+  }
+}

package/scripts/.coingecko-progress.json

@@ -0,0 +1,9 @@
+{
+  "processed": {
+    "eip155:1/erc20:0x01ba67aac7f75f647d94220cc98fb30fcc5105bf": "local",
+    "eip155:1/erc20:0x0176b898e92e814c06cc379e508ceb571f70bd40": "local",
+    "eip155:1/erc20:0x01824357d7d7eaf4677bc17786abd26cbdec9ad7": "coingecko",
+    "eip155:1/erc20:0x018008bfb33d285247a21d44e50697654f754e63": "coingecko"
+  },
+  "timestamp": 1761709065992
+}

package/scripts/README-ICON-DOWNLOAD.md

@@ -0,0 +1,220 @@
+# Icon Download Scripts
+
+This directory contains scripts to download missing asset icons using CoinGecko API and TrustWallet fallbacks.
+
+## Overview
+
+We have **14,157 missing assets** that need icons downloaded. The enhanced download script uses:
+1. **CoinGecko API** - Query tokens by contract address to get official icon URLs
+2. **TrustWallet Assets** - Fallback to community-maintained token icons
+3. **Rate limiting** - Respects API limits (1.5s between calls = ~40 calls/minute)
+
+## Scripts
+
+### `test-coingecko-download.js` (Test Mode)
+Tests the download process on 5 sample assets from `test-sample.json`.
+
+**Usage:**
+```bash
+cd scripts
+node test-coingecko-download.js
+```
+
+**Expected output:**
+- Downloads 1-2 icons successfully (20-40% success rate typical for obscure tokens)
+- Shows detailed logging for each asset
+- Saves to: `../../../../../../services/pioneer-server/public/coins/`
+
+### `download-with-coingecko-api.js` (Production Mode)
+Full production script that processes all 14,157 missing assets from `missing-assets.json`.
+
+**Features:**
+- Progress saving (resume if interrupted)
+- Failed asset tracking
+- Periodic stats reporting
+- Respects API rate limits
+
+**Usage:**
+```bash
+cd scripts
+node download-with-coingecko-api.js
+```
+
+**Estimated time:** 6-7 hours for 14,157 assets (due to API rate limits)
+
+**Output files:**
+- `.coingecko-progress.json` - Progress tracking (auto-deleted on completion)
+- `.coingecko-failed.json` - Assets that couldn't be downloaded
+- `generatedAssetData.json` - Updated with new icon URLs
+
+## CoinGecko API Details
+
+### Chain Mappings
+The script supports multiple chains via CoinGecko platform IDs:
+
+| CAIP Chain ID | CoinGecko Platform |
+|---------------|-------------------|
+| eip155:1 | ethereum |
+| eip155:10 | optimism |
+| eip155:56 | binance-smart-chain |
+| eip155:100 | xdai |
+| eip155:137 | polygon-pos |
+| eip155:250 | fantom |
+| eip155:8453 | base |
+| eip155:42161 | arbitrum-one |
+| eip155:42220 | celo |
+| eip155:43114 | avalanche |
+| And more... |
+
+### API Endpoint Format
+```
+GET https://api.coingecko.com/api/v3/coins/{platform}/contract/{contract_address}
+```
+
+**Example:**
+```bash
+curl "https://api.coingecko.com/api/v3/coins/ethereum/contract/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
+```
+
+**Response includes:**
+```json
+{
+  "image": {
+    "thumb": "https://coin-images.coingecko.com/coins/images/6319/thumb/usdc.png",
+    "small": "https://coin-images.coingecko.com/coins/images/6319/small/usdc.png",
+    "large": "https://coin-images.coingecko.com/coins/images/6319/large/usdc.png"
+  }
+}
+```
+
+### Rate Limits
+- **Free tier**: 10-50 calls/minute
+- **Script delay**: 1.5 seconds between calls (~40 calls/minute)
+- **Retry logic**: Exponential backoff on rate limit (429) responses
+
+## Expected Results
+
+Based on the nature of the missing assets:
+
+- **Well-known tokens** (USDC, UNI, LINK, AAVE): ~90% success rate
+- **Popular DeFi tokens**: ~60-70% success rate
+- **Obscure/defunct tokens**: ~20-40% success rate
+- **Overall estimated success**: ~50-60% (7,000-8,500 icons)
+
+Many of these are:
+- Deprecated tokens
+- Low-liquidity tokens not listed on CoinGecko
+- Tokens on newly supported chains
+- Tokens with contract address changes
+
+## Fallback Strategy
+
+For each asset, the script tries in order:
+
+1. ✅ Check if file already exists locally (skip if found)
+2. 🔍 Query CoinGecko API by contract address
+3. 📥 Download from CoinGecko if found
+4. 🔄 Try TrustWallet GitHub repository as fallback
+5. ❌ Mark as failed if all attempts fail
+
+## Running the Full Download
+
+### Prerequisites
+```bash
+# Ensure directory exists
+mkdir -p ../../../../../../services/pioneer-server/public/coins
+
+# Verify missing-assets.json exists
+ls -lh missing-assets.json
+```
+
+### Step 1: Test on Sample
+```bash
+# Create test sample if needed
+jq '.[0:10]' missing-assets.json > test-sample.json
+
+# Run test
+node test-coingecko-download.js
+```
+
+### Step 2: Run Full Download
+```bash
+# Start the full download (6-7 hours)
+node download-with-coingecko-api.js
+
+# The script saves progress every 10 assets, so you can safely Ctrl+C and resume
+```
+
+### Step 3: Monitor Progress
+The script outputs:
+- Real-time status for each asset
+- Periodic stats every 10 assets
+- Final summary with success/fail breakdown
+
+### Step 4: Handle Failures
+After completion, check `.coingecko-failed.json` for assets that couldn't be downloaded:
+```bash
+jq '. | length' .coingecko-failed.json
+jq '.assets | to_entries | .[0:10]' .coingecko-failed.json
+```
+
+## Resuming After Interruption
+
+If the download is interrupted (Ctrl+C, network issue, etc.):
+
+```bash
+# Simply run again - it will resume from progress file
+node download-with-coingecko-api.js
+```
+
+The script automatically:
+- Loads `.coingecko-progress.json`
+- Skips already processed assets
+- Continues from where it left off
+
+## Troubleshooting
+
+### Rate Limiting
+If you see frequent "Rate limited" messages:
+- Increase `API_DELAY_MS` in the script (try 2000ms or 2500ms)
+- Wait 1 hour and resume (API limits reset)
+
+### Timeouts
+If you see many timeout errors:
+- Check your internet connection
+- Increase `timeout` parameter in `makeRequest()` and `downloadFile()`
+
+### 404 Not Found
+This is normal for:
+- Obscure tokens not in CoinGecko database
+- Newly launched tokens
+- Tokens on less popular chains
+
+### Invalid Chain
+Some assets may use chain IDs not yet mapped. Add them to `CHAIN_ID_TO_COINGECKO_PLATFORM` if needed.
+
+## Next Steps After Download
+
+1. **Verify downloads:**
+   ```bash
+   ls -lh ../../../../../../services/pioneer-server/public/coins/*.png | wc -l
+   ```
+
+2. **Update generatedAssetData.json:**
+   The script automatically updates icon URLs to point to the new local files
+
+3. **Deploy to production:**
+   Upload the coins directory to your CDN/server
+
+4. **Manual fixes:**
+   Review `.coingecko-failed.json` and manually source icons for high-priority tokens
+
+## Stats from Test Run
+
+Sample of 5 assets:
+- Already local: 0 → 1 (after first run)
+- Downloaded from CoinGecko: 2 (40%)
+- Downloaded from TrustWallet: 0
+- Failed: 3 (60%)
+
+Note: Success rate will vary significantly based on token popularity.

package/scripts/download-with-coingecko-api.js

@@ -0,0 +1,414 @@
+#!/usr/bin/env node
+/*
+ * Enhanced Icon Download with CoinGecko API
+ *
+ * Features:
+ * - Uses CoinGecko API to lookup tokens by contract address
+ * - Supports multiple chains (Ethereum, Optimism, Arbitrum, Base, BSC, Polygon, etc.)
+ * - Respects API rate limits (10-50 calls/minute on free tier)
+ * - Downloads high-quality images
+ * - Progress saving and resumption
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+
+const DATA_FILE = path.join(__dirname, '..', 'src', 'generatedAssetData.json');
+const LOCAL_COINS_DIR = path.join(__dirname, '..', '..', '..', '..', '..', 'services', 'pioneer-server', 'public', 'coins');
+const MISSING_ASSETS_FILE = path.join(__dirname, 'missing-assets.json');
+const PROGRESS_FILE = path.join(__dirname, '.coingecko-progress.json');
+const FAILED_FILE = path.join(__dirname, '.coingecko-failed.json');
+
+// API rate limiting
+const API_DELAY_MS = 1500; // 1.5 seconds between API calls (40 calls/minute)
+const MAX_RETRIES = 3;
+
+// Ensure local coins directory exists
+if (!fs.existsSync(LOCAL_COINS_DIR)) {
+  fs.mkdirSync(LOCAL_COINS_DIR, { recursive: true });
+}
+
+/**
+ * Map CAIP chainId to CoinGecko platform identifier
+ */
+const CHAIN_ID_TO_COINGECKO_PLATFORM = {
+  'eip155:1': 'ethereum',
+  'eip155:10': 'optimism',
+  'eip155:56': 'binance-smart-chain',
+  'eip155:100': 'xdai',
+  'eip155:137': 'polygon-pos',
+  'eip155:250': 'fantom',
+  'eip155:8453': 'base',
+  'eip155:42161': 'arbitrum-one',
+  'eip155:42220': 'celo',
+  'eip155:43114': 'avalanche',
+  'eip155:534352': 'scroll',
+  'eip155:59144': 'linea',
+  'eip155:324': 'zksync',
+  'eip155:1101': 'polygon-zkevm',
+  'eip155:5000': 'mantle',
+  'eip155:81457': 'blast',
+};
+
+/**
+ * Convert assetId to base64-encoded format
+ */
+function encodeAssetId(assetId) {
+  return Buffer.from(assetId).toString('base64');
+}
+
+/**
+ * Extract contract address from assetId
+ */
+function extractContractAddress(assetId) {
+  const match = assetId.match(/erc20:(0x[a-fA-F0-9]{40})/);
+  return match ? match[1].toLowerCase() : null;
+}
+
+/**
+ * Sleep for specified milliseconds
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Make HTTP/HTTPS request with timeout
+ */
+async function makeRequest(url, timeout = 10000) {
+  return new Promise((resolve, reject) => {
+    try {
+      const urlObj = new URL(url);
+      const client = urlObj.protocol === 'https:' ? https : http;
+
+      const req = client.get(url, { timeout }, (res) => {
+        let data = '';
+
+        res.on('data', chunk => {
+          data += chunk;
+        });
+
+        res.on('end', () => {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              const parsed = JSON.parse(data);
+              resolve({ success: true, data: parsed, statusCode: res.statusCode });
+            } catch (e) {
+              resolve({ success: false, error: 'Invalid JSON', statusCode: res.statusCode });
+            }
+          } else if (res.statusCode === 429) {
+            resolve({ success: false, error: 'Rate limited', statusCode: 429 });
+          } else if (res.statusCode === 404) {
+            resolve({ success: false, error: 'Not found', statusCode: 404 });
+          } else {
+            resolve({ success: false, error: `HTTP ${res.statusCode}`, statusCode: res.statusCode });
+          }
+        });
+      });
+
+      req.on('error', (err) => {
+        resolve({ success: false, error: err.message });
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        resolve({ success: false, error: 'Timeout' });
+      });
+    } catch (e) {
+      resolve({ success: false, error: e.message });
+    }
+  });
+}
+
+/**
+ * Download file from URL
+ */
+async function downloadFile(url, outputPath, timeout = 10000) {
+  return new Promise((resolve) => {
+    try {
+      const urlObj = new URL(url);
+      const client = urlObj.protocol === 'https:' ? https : http;
+
+      const req = client.get(url, { timeout }, (res) => {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          const fileStream = fs.createWriteStream(outputPath);
+          res.pipe(fileStream);
+          fileStream.on('finish', () => {
+            fileStream.close();
+            resolve(true);
+          });
+          fileStream.on('error', () => resolve(false));
+        } else if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          // Follow redirect
+          downloadFile(res.headers.location, outputPath, timeout).then(resolve);
+        } else {
+          resolve(false);
+        }
+      });
+
+      req.on('error', () => resolve(false));
+      req.on('timeout', () => {
+        req.destroy();
+        resolve(false);
+      });
+    } catch (e) {
+      resolve(false);
+    }
+  });
+}
+
+/**
+ * Query CoinGecko API for token info by contract address
+ */
+async function getCoinGeckoTokenInfo(chainId, contractAddress, retries = 0) {
+  const platform = CHAIN_ID_TO_COINGECKO_PLATFORM[chainId];
+  if (!platform) {
+    return { success: false, error: 'Unsupported chain' };
+  }
+
+  const url = `https://api.coingecko.com/api/v3/coins/${platform}/contract/${contractAddress}`;
+
+  const result = await makeRequest(url);
+
+  // Handle rate limiting with exponential backoff
+  if (result.statusCode === 429 && retries < MAX_RETRIES) {
+    const backoffMs = API_DELAY_MS * Math.pow(2, retries);
+    console.log(`  ⏳ Rate limited, waiting ${backoffMs}ms...`);
+    await sleep(backoffMs);
+    return getCoinGeckoTokenInfo(chainId, contractAddress, retries + 1);
+  }
+
+  return result;
+}
+
+/**
+ * Get TrustWallet fallback URLs
+ */
+function getTrustWalletFallbacks(assetData) {
+  const fallbacks = [];
+
+  if (assetData.assetId?.includes('erc20:')) {
+    const match = assetData.assetId.match(/erc20:(0x[a-fA-F0-9]+)/);
+    if (match) {
+      const contract = match[1];
+      // Simple checksum approach
+      const checksummed = contract.substring(0, 2) + contract.substring(2).split('')
+        .map((char, i) => i % 2 === 0 && parseInt(char, 16) >= 8 ? char.toUpperCase() : char)
+        .join('');
+
+      fallbacks.push(`https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/ethereum/assets/${checksummed}/logo.png`);
+    }
+  }
+
+  return fallbacks;
+}
+
+/**
+ * Process a single asset with CoinGecko API
+ */
+async function processAsset(assetId, assetData, stats, progress, failed) {
+  const encoded = encodeAssetId(assetId);
+  const localPath = path.join(LOCAL_COINS_DIR, `${encoded}.png`);
+
+  stats.total++;
+
+  // Skip if already processed successfully
+  if (progress.processed[assetId]) {
+    stats.skipped++;
+    return true;
+  }
+
+  // Check local file first
+  if (fs.existsSync(localPath)) {
+    const fileSize = fs.statSync(localPath).size;
+    if (fileSize > 0) {
+      stats.alreadyLocal++;
+      progress.processed[assetId] = 'local';
+      assetData.icon = `https://api.keepkey.com/coins/${encoded}.png`;
+      return true;
+    }
+  }
+
+  console.log(`\n[${stats.total}/${stats.totalAssets}] ${assetData.symbol} - ${assetData.name}`);
+  console.log(`  Asset: ${assetId.substring(0, 70)}...`);
+
+  // Extract contract address
+  const contractAddress = extractContractAddress(assetId);
+  if (!contractAddress) {
+    console.log(`  ⚠️  Not an ERC20 token - skipping CoinGecko lookup`);
+    stats.notErc20++;
+    progress.processed[assetId] = 'not_erc20';
+    return false;
+  }
+
+  // Query CoinGecko API
+  console.log(`  🔍 Querying CoinGecko API...`);
+  const result = await getCoinGeckoTokenInfo(assetData.chainId, contractAddress);
+
+  // Respect rate limits
+  await sleep(API_DELAY_MS);
+
+  if (result.success && result.data?.image) {
+    const imageUrl = result.data.image.large || result.data.image.small || result.data.image.thumb;
+
+    if (imageUrl) {
+      console.log(`  📥 Downloading from CoinGecko: ${imageUrl.substring(0, 70)}...`);
+      const downloaded = await downloadFile(imageUrl, localPath);
+
+      if (downloaded) {
+        console.log(`  ✅ Successfully downloaded from CoinGecko`);
+        stats.downloadedFromCoinGecko++;
+        progress.processed[assetId] = 'coingecko';
+        assetData.icon = `https://api.keepkey.com/coins/${encoded}.png`;
+        return true;
+      } else {
+        console.log(`  ❌ Download failed`);
+      }
+    }
+  } else {
+    console.log(`  ℹ️  CoinGecko: ${result.error || 'Not found'}`);
+  }
+
+  // Try TrustWallet fallback
+  const trustWalletUrls = getTrustWalletFallbacks(assetData);
+  for (const url of trustWalletUrls) {
+    console.log(`  🔄 Trying TrustWallet: ${url.substring(0, 70)}...`);
+    const downloaded = await downloadFile(url, localPath);
+    if (downloaded) {
+      console.log(`  ✅ Downloaded from TrustWallet`);
+      stats.downloadedFromTrustWallet++;
+      progress.processed[assetId] = 'trustwallet';
+      assetData.icon = `https://api.keepkey.com/coins/${encoded}.png`;
+      return true;
+    }
+  }
+
+  // Mark as failed
+  console.log(`  ❌ No icon found`);
+  stats.failed++;
+  failed.assets[assetId] = {
+    symbol: assetData.symbol,
+    name: assetData.name,
+    chainId: assetData.chainId,
+    error: result.error || 'No icon available',
+    attempts: (failed.assets[assetId]?.attempts || 0) + 1,
+  };
+
+  // Still set the target URL
+  assetData.icon = `https://api.keepkey.com/coins/${encoded}.png`;
+  return false;
+}
+
+/**
+ * Save progress
+ */
+function saveProgress(progress, data, stats, failed) {
+  fs.writeFileSync(PROGRESS_FILE, JSON.stringify(progress, null, 2));
+  fs.writeFileSync(DATA_FILE, JSON.stringify(data, null, 2));
+  fs.writeFileSync(FAILED_FILE, JSON.stringify(failed, null, 2));
+}
+
+/**
+ * Main execution
+ */
+async function main() {
+  console.log('🚀 Enhanced icon download with CoinGecko API\n');
+  console.log('⚠️  Rate limit: ~40 API calls per minute');
+  console.log('⏱️  This will take approximately 6-7 hours for 14,000 assets\n');
+
+  // Load missing assets
+  let assetsToProcess = {};
+  if (fs.existsSync(MISSING_ASSETS_FILE)) {
+    const missingAssets = JSON.parse(fs.readFileSync(MISSING_ASSETS_FILE, 'utf8'));
+    console.log(`📂 Loading ${missingAssets.length} assets from missing-assets.json\n`);
+
+    // Convert array to object keyed by assetId
+    for (const asset of missingAssets) {
+      assetsToProcess[asset.assetId] = {
+        symbol: asset.symbol,
+        name: asset.name,
+        chainId: asset.chainId,
+        icon: asset.oldIcon,
+        assetId: asset.assetId,
+      };
+    }
+  } else {
+    console.log('❌ missing-assets.json not found');
+    process.exit(1);
+  }
+
+  const entries = Object.entries(assetsToProcess);
+
+  // Load progress
+  let progress = { processed: {}, timestamp: Date.now() };
+  if (fs.existsSync(PROGRESS_FILE)) {
+    progress = JSON.parse(fs.readFileSync(PROGRESS_FILE, 'utf8'));
+    console.log(`📂 Resuming from previous run (${Object.keys(progress.processed).length} already processed)\n`);
+  }
+
+  // Load failed attempts
+  let failed = { assets: {} };
+  if (fs.existsSync(FAILED_FILE)) {
+    failed = JSON.parse(fs.readFileSync(FAILED_FILE, 'utf8'));
+  }
+
+  const stats = {
+    total: 0,
+    totalAssets: entries.length,
+    skipped: 0,
+    alreadyLocal: 0,
+    downloadedFromCoinGecko: 0,
+    downloadedFromTrustWallet: 0,
+    notErc20: 0,
+    failed: 0,
+  };
+
+  const saveInterval = 10; // Save every 10 assets
+
+  // Process sequentially to respect API rate limits
+  for (let i = 0; i < entries.length; i++) {
+    const [assetId, assetData] = entries[i];
+    await processAsset(assetId, assetData, stats, progress, failed);
+
+    // Save progress periodically
+    if ((i + 1) % saveInterval === 0) {
+      saveProgress(progress, assetsToProcess, stats, failed);
+      console.log(`\n💾 Progress saved (${i + 1}/${entries.length})`);
+
+      // Print interim stats
+      const percentComplete = ((i + 1) / entries.length * 100).toFixed(1);
+      console.log(`📊 ${percentComplete}% complete | CoinGecko: ${stats.downloadedFromCoinGecko} | TrustWallet: ${stats.downloadedFromTrustWallet} | Failed: ${stats.failed}\n`);
+    }
+  }
+
+  // Final save
+  saveProgress(progress, assetsToProcess, stats, failed);
+
+  // Print summary
+  console.log('\n' + '='.repeat(80));
+  console.log('📊 FINAL SUMMARY');
+  console.log('='.repeat(80));
+  console.log(`Total assets processed:          ${stats.totalAssets}`);
+  console.log(`Skipped (already done):          ${stats.skipped}`);
+  console.log(`Already in local storage:        ${stats.alreadyLocal}`);
+  console.log(`Downloaded from CoinGecko:       ${stats.downloadedFromCoinGecko}`);
+  console.log(`Downloaded from TrustWallet:     ${stats.downloadedFromTrustWallet}`);
+  console.log(`Not ERC20 (skipped):             ${stats.notErc20}`);
+  console.log(`Failed (no icon found):          ${stats.failed}`);
+  console.log('='.repeat(80));
+
+  const successRate = ((stats.downloadedFromCoinGecko + stats.downloadedFromTrustWallet) / stats.totalAssets * 100).toFixed(1);
+  console.log(`\n✅ Success rate: ${successRate}%\n`);
+
+  const localFiles = fs.readdirSync(LOCAL_COINS_DIR).filter(f => f.endsWith('.png')).length;
+  console.log(`📁 Local coins directory: ${localFiles} PNG files\n`);
+
+  console.log(`📝 Failed assets saved to: ${FAILED_FILE}\n`);
+}
+
+main().catch(err => {
+  console.error('❌ Error:', err);
+  process.exit(1);
+});