agentgui 1.0.261 → 1.0.262

package/lib/ipfs-downloader.js

@@ -0,0 +1,311 @@
+import https from 'https';
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import os from 'os';
+import { queries } from '../database.js';
+
+const GATEWAYS = [
+  'https://ipfs.io/ipfs/',
+  'https://gateway.pinata.cloud/ipfs/',
+  'https://cloudflare-ipfs.com/ipfs/',
+  'https://dweb.link/ipfs/'
+];
+
+const CONFIG = {
+  MAX_RESUME_ATTEMPTS: 3,
+  MAX_RETRY_ATTEMPTS: 3,
+  TIMEOUT_MS: 30000,
+  INITIAL_BACKOFF_MS: 1000,
+  BACKOFF_MULTIPLIER: 2,
+  DOWNLOADS_DIR: path.join(os.homedir(), '.gmgui', 'downloads'),
+  RESUME_THRESHOLD: 0.5
+};
+
+class IPFSDownloader {
+  constructor() {
+    this.downloads = new Map();
+    this.setupDir();
+  }
+
+  setupDir() {
+    if (!fs.existsSync(CONFIG.DOWNLOADS_DIR)) {
+      fs.mkdirSync(CONFIG.DOWNLOADS_DIR, { recursive: true });
+    }
+  }
+
+  async download(cid, filename, options = {}) {
+    const filepath = path.join(CONFIG.DOWNLOADS_DIR, filename);
+    const { modelName = 'unknown', modelType = 'unknown', modelHash = null } = options;
+
+    try {
+      const cidId = queries.recordIpfsCid(cid, modelName, modelType, modelHash, GATEWAYS[0]);
+      const downloadId = queries.recordDownloadStart(cidId, filepath, 0);
+
+      await this.executeDownload(downloadId, cidId, filepath, options);
+      return { success: true, downloadId, filepath, cid };
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async executeDownload(downloadId, cidId, filepath, options = {}) {
+    let gatewayIndex = 0;
+    let resumeAttempts = 0;
+    let retryAttempts = 0;
+
+    while (true) {
+      try {
+        const gateway = GATEWAYS[gatewayIndex];
+        const cidRecord = queries._db.prepare('SELECT * FROM ipfs_cids WHERE id = ?').get(cidId);
+        if (!cidRecord) throw new Error('CID record not found');
+        const url = `${gateway}${cidRecord.cid}`;
+
+        const { size, hash } = await this.downloadFile(
+          url,
+          filepath,
+          0,
+          options
+        );
+
+        queries.completeDownload(downloadId, cidId);
+
+        if (options.hashVerify && hash) {
+          queries.updateDownloadHash(downloadId, hash);
+        }
+
+        return queries.getDownload(downloadId);
+      } catch (error) {
+        if (error.message.includes('Range')) {
+          resumeAttempts++;
+          if (resumeAttempts > CONFIG.MAX_RESUME_ATTEMPTS) {
+            await this.cleanupPartial(filepath);
+            gatewayIndex = (gatewayIndex + 1) % GATEWAYS.length;
+            resumeAttempts = 0;
+          }
+        } else if (error.message.includes('timeout') || error.message.includes('ETIMEDOUT')) {
+          retryAttempts++;
+          if (retryAttempts > CONFIG.MAX_RETRY_ATTEMPTS) {
+            queries.recordDownloadError(downloadId, cidId, error.message);
+            throw error;
+          }
+          const backoff = CONFIG.INITIAL_BACKOFF_MS * Math.pow(CONFIG.BACKOFF_MULTIPLIER, retryAttempts - 1);
+          await this.sleep(backoff);
+        } else if (error.message.includes('network') || error.message.includes('ECONNRESET')) {
+          gatewayIndex = (gatewayIndex + 1) % GATEWAYS.length;
+          retryAttempts = 0;
+        } else {
+          queries.recordDownloadError(downloadId, cidId, error.message);
+          throw error;
+        }
+      }
+    }
+  }
+
+  async downloadFile(url, filepath, resumeFrom = 0, options = {}) {
+    return new Promise((resolve, reject) => {
+      const protocol = url.startsWith('https') ? https : http;
+      const headers = {};
+
+      if (resumeFrom > 0) {
+        headers['Range'] = `bytes=${resumeFrom}-`;
+      }
+
+      const req = protocol.get(url, { headers, timeout: CONFIG.TIMEOUT_MS }, (res) => {
+        if (res.statusCode === 416) {
+          reject(new Error('Range not supported - will delete partial and restart'));
+          return;
+        }
+
+        if (![200, 206].includes(res.statusCode)) {
+          reject(new Error(`HTTP ${res.statusCode}`));
+          return;
+        }
+
+        const contentLength = parseInt(res.headers['content-length'], 10);
+        const hash = crypto.createHash('sha256');
+        let downloaded = resumeFrom;
+
+        const mode = resumeFrom > 0 ? 'a' : 'w';
+        const stream = fs.createWriteStream(filepath, { flags: mode });
+
+        res.on('data', (chunk) => {
+          hash.update(chunk);
+          downloaded += chunk.length;
+        });
+
+        res.pipe(stream);
+
+        stream.on('finish', () => {
+          resolve({ size: downloaded, hash: hash.digest('hex') });
+        });
+
+        stream.on('error', (err) => {
+          reject(new Error(`Write error: ${err.message}`));
+        });
+      });
+
+      req.on('timeout', () => {
+        req.abort();
+        reject(new Error('timeout'));
+      });
+
+      req.on('error', (err) => {
+        reject(new Error(`network: ${err.message}`));
+      });
+    });
+  }
+
+  async verifyHash(filepath, expectedHash) {
+    return new Promise((resolve, reject) => {
+      const hash = crypto.createHash('sha256');
+      const stream = fs.createReadStream(filepath);
+
+      stream.on('data', (chunk) => {
+        hash.update(chunk);
+      });
+
+      stream.on('end', () => {
+        resolve(hash.digest('hex') === expectedHash);
+      });
+
+      stream.on('error', (err) => {
+        reject(err);
+      });
+    });
+  }
+
+  async resume(downloadId, options = {}) {
+    const record = queries.getDownload(downloadId);
+
+    if (!record) {
+      throw new Error('Download not found');
+    }
+
+    if (record.status === 'success') {
+      return record;
+    }
+
+    const attempts = (record.attempts || 0) + 1;
+    if (attempts > CONFIG.MAX_RESUME_ATTEMPTS) {
+      throw new Error('Max resume attempts exceeded');
+    }
+
+    try {
+      const currentSize = fs.existsSync(record.downloadPath)
+        ? fs.statSync(record.downloadPath).size
+        : 0;
+
+      if (currentSize === 0) {
+        queries.recordDownloadStart(record.cidId, record.downloadPath, record.total_bytes);
+        return this.resumeFromOffset(downloadId, record, 0, options);
+      }
+
+      queries.markDownloadResuming(downloadId);
+
+      const downloadPercent = (currentSize / (record.total_bytes || currentSize)) * 100;
+
+      if (downloadPercent > CONFIG.RESUME_THRESHOLD * 100) {
+        return this.resumeFromOffset(downloadId, record, currentSize, options);
+      } else {
+        await this.cleanupPartial(record.downloadPath);
+        return this.resumeFromOffset(downloadId, record, 0, options);
+      }
+    } catch (error) {
+      const newAttempts = (record.attempts || 0) + 1;
+      const newStatus = newAttempts >= CONFIG.MAX_RESUME_ATTEMPTS ? 'failed' : 'paused';
+      queries.updateDownloadResume(downloadId, record.downloaded_bytes, newAttempts, Date.now(), newStatus);
+
+      if (newStatus === 'failed') {
+        throw error;
+      }
+
+      return queries.getDownload(downloadId);
+    }
+  }
+
+  async resumeFromOffset(downloadId, record, offset, options) {
+    try {
+      const cidRecord = queries.getIpfsCidByModel(record.modelName, record.modelType);
+      const gateway = GATEWAYS[0];
+      const url = `${gateway}${cidRecord.cid}`;
+
+      const { size, hash } = await this.downloadFile(
+        url,
+        record.downloadPath,
+        offset,
+        options
+      );
+
+      if (options.hashVerify && record.hash) {
+        const verified = await this.verifyHash(record.downloadPath, record.hash);
+        if (!verified) {
+          await this.cleanupPartial(record.downloadPath);
+          const newAttempts = (record.attempts || 0) + 1;
+          queries.updateDownloadResume(downloadId, 0, newAttempts, Date.now(), 'pending');
+          throw new Error('Hash verification failed - restarting');
+        }
+      }
+
+      queries.completeDownload(downloadId, record.cidId);
+      if (hash) {
+        queries.updateDownloadHash(downloadId, hash);
+      }
+
+      return queries.getDownload(downloadId);
+    } catch (error) {
+      const newAttempts = (record.attempts || 0) + 1;
+      const newStatus = newAttempts >= CONFIG.MAX_RESUME_ATTEMPTS ? 'failed' : 'paused';
+      queries.updateDownloadResume(downloadId, offset, newAttempts, Date.now(), newStatus);
+
+      if (newStatus === 'failed') {
+        throw error;
+      }
+
+      return queries.getDownload(downloadId);
+    }
+  }
+
+  async cleanupPartial(filepath) {
+    if (fs.existsSync(filepath)) {
+      try {
+        fs.unlinkSync(filepath);
+      } catch (err) {
+        console.error(`Failed to cleanup partial file: ${filepath}`, err.message);
+      }
+    }
+  }
+
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  getDownloadStatus(downloadId) {
+    return queries.getDownload(downloadId);
+  }
+
+  listDownloads(status = null) {
+    if (status) {
+      return queries.getDownloadsByStatus(status);
+    }
+    const allDownloads = queries.getDownloadsByStatus('in_progress');
+    return allDownloads.concat(
+      queries.getDownloadsByStatus('success'),
+      queries.getDownloadsByStatus('paused'),
+      queries.getDownloadsByStatus('failed')
+    );
+  }
+
+  async cancelDownload(downloadId) {
+    const record = queries.getDownload(downloadId);
+    if (!record) return false;
+
+    await this.cleanupPartial(record.downloadPath);
+    queries.markDownloadPaused(downloadId, 'Cancelled by user');
+
+    return true;
+  }
+}
+
+export default new IPFSDownloader();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.261",
+  "version": "1.0.262",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/server.js

@@ -32,12 +32,31 @@ const modelDownloadState = {
   downloading: false,
   progress: null,
   error: null,
-  complete: false
+  complete: false,
+  startTime: null,
+  downloadMetrics: new Map()
 };
 
 function broadcastModelProgress(progress) {
   modelDownloadState.progress = progress;
-  broadcastSync({ type: 'model_download_progress', progress });
+  const broadcastData = {
+    type: 'model_download_progress',
+    modelId: progress.type || 'unknown',
+    bytesDownloaded: progress.bytesDownloaded || 0,
+    bytesRemaining: progress.bytesRemaining || 0,
+    totalBytes: progress.totalBytes || 0,
+    downloadSpeed: progress.downloadSpeed || 0,
+    eta: progress.eta || 0,
+    retryCount: progress.retryCount || 0,
+    currentGateway: progress.currentGateway || '',
+    status: progress.status || (progress.done ? 'completed' : progress.downloading ? 'downloading' : 'paused'),
+    percentComplete: progress.percentComplete || 0,
+    completedFiles: progress.completedFiles || 0,
+    totalFiles: progress.totalFiles || 0,
+    timestamp: Date.now(),
+    ...progress
+  };
+  broadcastSync(broadcastData);
 }
 
 async function ensureModelsDownloaded() {
@@ -85,14 +104,22 @@ async function ensureModelsDownloaded() {
     if (!sttOk) {
       console.log('[MODELS] Downloading STT model...');
       broadcastModelProgress({ started: true, done: false, downloading: true, type: 'stt', completedFiles, totalFiles });
-      await webtalkWhisper.ensureModel('onnx-community/whisper-base', config);
+      try {
+        await webtalkWhisper.ensureModel('onnx-community/whisper-base', config);
+      } catch (err) {
+        console.warn('[MODELS] STT download failed, falling back to HuggingFace:', err.message);
+      }
       completedFiles += 10;
     }
 
     if (!ttsOk) {
       console.log('[MODELS] Downloading TTS models...');
       broadcastModelProgress({ started: true, done: false, downloading: true, type: 'tts', completedFiles, totalFiles });
-      await webtalkTTS.ensureTTSModels(config);
+      try {
+        await webtalkTTS.ensureTTSModels(config);
+      } catch (err) {
+        console.warn('[MODELS] TTS download failed, falling back to HuggingFace:', err.message);
+      }
       completedFiles += 6;
     }
 
@@ -3274,7 +3301,8 @@ const BROADCAST_TYPES = new Set([
   'message_created', 'conversation_created', 'conversation_updated',
   'conversations_updated', 'conversation_deleted', 'queue_status', 'queue_updated',
   'rate_limit_hit', 'rate_limit_clear',
-  'script_started', 'script_stopped', 'script_output'
+  'script_started', 'script_stopped', 'script_output',
+  'model_download_progress'
 ]);
 
 const wsBatchQueues = new Map();

package/static/js/client.js

@@ -494,7 +494,7 @@ class AgentGUIClient {
           this.handleRateLimitClear(data);
           break;
         case 'model_download_progress':
-          this._handleModelDownloadProgress(data.progress);
+          this._handleModelDownloadProgress(data.progress || data);
           break;
         default:
           break;
@@ -2028,16 +2028,16 @@ class AgentGUIClient {
 
   _handleModelDownloadProgress(progress) {
     this._modelDownloadProgress = progress;
-    
-    if (progress.error) {
+
+    if (progress.status === 'failed' || progress.error) {
       this._modelDownloadInProgress = false;
-      console.error('[Models] Download error:', progress.error);
+      console.error('[Models] Download error:', progress.error || progress.status);
       this._updateConnectionIndicator(this.wsManager?.latency?.quality || 'unknown');
       if (window._voiceProgressDialog) {
         window._voiceProgressDialog.close();
         window._voiceProgressDialog = null;
       }
-      const errorMsg = 'Failed to download voice models: ' + progress.error;
+      const errorMsg = 'Failed to download voice models: ' + (progress.error || 'unknown error');
       if (window.UIDialog) {
         window.UIDialog.alert(errorMsg, 'Download Error');
       } else {
@@ -2045,8 +2045,8 @@ class AgentGUIClient {
       }
       return;
     }
-    
-    if (progress.done) {
+
+    if (progress.done || progress.status === 'completed') {
       this._modelDownloadInProgress = false;
       console.log('[Models] Download complete');
       this._updateConnectionIndicator(this.wsManager?.latency?.quality || 'unknown');
@@ -2067,8 +2067,8 @@ class AgentGUIClient {
       }
       return;
     }
-    
-    if (progress.started || progress.downloading) {
+
+    if (progress.started || progress.downloading || progress.status === 'downloading' || progress.status === 'connecting') {
       this._modelDownloadInProgress = true;
       this._updateConnectionIndicator(this.wsManager?.latency?.quality || 'unknown');
 
@@ -2076,13 +2076,26 @@ class AgentGUIClient {
         window.__showVoiceDownloadProgress();
       }
 
-      if (window._voiceProgressDialog && progress.totalBytes > 0) {
-        var pct = Math.round((progress.totalDownloaded / progress.totalBytes) * 100);
-        var mb = Math.round(progress.totalBytes / 1024 / 1024);
-        var downloaded = Math.round((progress.totalDownloaded || 0) / 1024 / 1024);
-        window._voiceProgressDialog.update(pct, 'Downloading ' + downloaded + 'MB / ' + mb + 'MB');
-      } else if (window._voiceProgressDialog && progress.file) {
-        window._voiceProgressDialog.update(0, 'Loading ' + progress.file + '...');
+      if (window._voiceProgressDialog) {
+        let displayText = 'Downloading models...';
+
+        if (progress.status === 'connecting') {
+          displayText = 'Connecting to ' + (progress.currentGateway || 'gateway') + '...';
+        } else if (progress.totalBytes > 0) {
+          const downloaded = (progress.bytesDownloaded || 0) / 1024 / 1024;
+          const total = progress.totalBytes / 1024 / 1024;
+          const speed = progress.downloadSpeed ? (progress.downloadSpeed / 1024 / 1024).toFixed(2) : '0';
+          const eta = progress.eta ? Math.ceil(progress.eta) + 's' : '...';
+          const retryInfo = progress.retryCount > 0 ? ` (retry ${progress.retryCount})` : '';
+
+          displayText = `Downloading ${downloaded.toFixed(1)}MB / ${total.toFixed(1)}MB @ ${speed}MB/s (ETA: ${eta})${retryInfo}`;
+        } else if (progress.file) {
+          displayText = 'Loading ' + progress.file + '...';
+        } else if (progress.completedFiles && progress.totalFiles) {
+          displayText = `Downloaded ${progress.completedFiles}/${progress.totalFiles} files`;
+        }
+
+        window._voiceProgressDialog.update(progress.percentComplete || 0, displayText);
       }
     }
   }

package/test-download-progress.js

@@ -0,0 +1,223 @@
+import https from 'https';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const testDir = path.join(os.tmpdir(), 'test-download-progress');
+if (!fs.existsSync(testDir)) {
+  fs.mkdirSync(testDir, { recursive: true });
+}
+
+const GATEWAYS = [
+  'https://ipfs.io',
+  'https://gateway.pinata.cloud',
+  'https://cloudflare-ipfs.com',
+];
+
+function downloadWithProgress(url, destination, onProgress = null) {
+  let bytesDownloaded = 0;
+  let totalBytes = 0;
+  let lastProgressTime = Date.now();
+  let lastProgressBytes = 0;
+  const speeds = [];
+  let retryCount = 0;
+  let gatewayIndex = 0;
+
+  const emitProgress = () => {
+    const now = Date.now();
+    const deltaTime = (now - lastProgressTime) / 1000;
+    const deltaBytes = bytesDownloaded - lastProgressBytes;
+    const speed = deltaTime > 0 ? Math.round(deltaBytes / deltaTime) : 0;
+
+    if (speed > 0) {
+      speeds.push(speed);
+      if (speeds.length > 10) speeds.shift();
+    }
+
+    const avgSpeed = speeds.length > 0 ? Math.round(speeds.reduce((a, b) => a + b, 0) / speeds.length) : 0;
+    const eta = avgSpeed > 0 && totalBytes > bytesDownloaded ? Math.round((totalBytes - bytesDownloaded) / avgSpeed) : 0;
+
+    if (onProgress) {
+      onProgress({
+        bytesDownloaded,
+        bytesRemaining: Math.max(0, totalBytes - bytesDownloaded),
+        totalBytes,
+        downloadSpeed: avgSpeed,
+        eta,
+        retryCount,
+        currentGateway: url,
+        status: bytesDownloaded >= totalBytes ? 'completed' : 'downloading',
+        percentComplete: totalBytes > 0 ? Math.round((bytesDownloaded / totalBytes) * 100) : 0,
+        timestamp: now
+      });
+    }
+
+    lastProgressTime = now;
+    lastProgressBytes = bytesDownloaded;
+  };
+
+  return new Promise((resolve, reject) => {
+    const dir = path.dirname(destination);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    const attemptDownload = (gateway) => {
+      if (onProgress) {
+        onProgress({
+          bytesDownloaded: 0,
+          bytesRemaining: 0,
+          totalBytes: 0,
+          downloadSpeed: 0,
+          eta: 0,
+          retryCount,
+          currentGateway: gateway,
+          status: 'connecting',
+          percentComplete: 0,
+          timestamp: Date.now()
+        });
+      }
+
+      https.get(gateway, { timeout: 30000 }, (res) => {
+        if ([301, 302, 307, 308].includes(res.statusCode)) {
+          const location = res.headers.location;
+          if (location) return attemptDownload(location);
+        }
+
+        if (res.statusCode !== 200) {
+          res.resume();
+          if (gatewayIndex < GATEWAYS.length - 1) {
+            retryCount++;
+            gatewayIndex++;
+            return setTimeout(() => attemptDownload(GATEWAYS[gatewayIndex]), 1000 * Math.pow(2, Math.min(retryCount, 3)));
+          }
+          return reject(new Error(`HTTP ${res.statusCode}`));
+        }
+
+        totalBytes = parseInt(res.headers['content-length'], 10) || 0;
+        bytesDownloaded = 0;
+        lastProgressBytes = 0;
+        lastProgressTime = Date.now();
+
+        const file = fs.createWriteStream(destination);
+        let lastEmit = Date.now();
+
+        res.on('data', (chunk) => {
+          bytesDownloaded += chunk.length;
+          const now = Date.now();
+          if (now - lastEmit >= 200) {
+            emitProgress();
+            lastEmit = now;
+          }
+        });
+
+        res.on('end', () => {
+          emitProgress();
+          file.destroy();
+          resolve({ destination, bytesDownloaded, success: true });
+        });
+
+        res.on('error', (err) => {
+          file.destroy();
+          fs.unlink(destination, () => {});
+          if (gatewayIndex < GATEWAYS.length - 1) {
+            retryCount++;
+            gatewayIndex++;
+            return setTimeout(() => attemptDownload(GATEWAYS[gatewayIndex]), 1000 * Math.pow(2, Math.min(retryCount, 3)));
+          }
+          reject(err);
+        });
+
+        file.on('error', (err) => {
+          res.destroy();
+          fs.unlink(destination, () => {});
+          if (gatewayIndex < GATEWAYS.length - 1) {
+            retryCount++;
+            gatewayIndex++;
+            return setTimeout(() => attemptDownload(GATEWAYS[gatewayIndex]), 1000 * Math.pow(2, Math.min(retryCount, 3)));
+          }
+          reject(err);
+        });
+
+        res.pipe(file);
+      }).on('timeout', () => {
+        if (gatewayIndex < GATEWAYS.length - 1) {
+          retryCount++;
+          gatewayIndex++;
+          return setTimeout(() => attemptDownload(GATEWAYS[gatewayIndex]), 1000 * Math.pow(2, Math.min(retryCount, 3)));
+        }
+        reject(new Error('Download timeout'));
+      }).on('error', (err) => {
+        if (gatewayIndex < GATEWAYS.length - 1) {
+          retryCount++;
+          gatewayIndex++;
+          return setTimeout(() => attemptDownload(GATEWAYS[gatewayIndex]), 1000 * Math.pow(2, Math.min(retryCount, 3)));
+        }
+        reject(err);
+      });
+    };
+
+    attemptDownload(GATEWAYS[0]);
+  });
+}
+
+let progressCount = 0;
+let lastPrintTime = Date.now();
+let minInterval = Infinity;
+let maxInterval = 0;
+const progressIntervals = [];
+
+console.log('Starting download progress tracking test...\n');
+
+downloadWithProgress(
+  'https://www.w3.org/WAI/WCAG21/Techniques/pdf/pdf-files/table-example.pdf',
+  path.join(testDir, 'test-file.pdf'),
+  (progress) => {
+    progressCount++;
+    const now = Date.now();
+    const interval = now - lastPrintTime;
+
+    if (progressCount > 1) {
+      progressIntervals.push(interval);
+      minInterval = Math.min(minInterval, interval);
+      maxInterval = Math.max(maxInterval, interval);
+    }
+
+    console.log(`[${progressCount}] Progress Update:
+  Status: ${progress.status}
+  Downloaded: ${(progress.bytesDownloaded / 1024).toFixed(1)}KB / ${(progress.totalBytes / 1024).toFixed(1)}KB
+  Speed: ${(progress.downloadSpeed / 1024).toFixed(2)}MB/s
+  ETA: ${progress.eta}s
+  Complete: ${progress.percentComplete}%
+  Retry Count: ${progress.retryCount}
+  Gateway: ${progress.currentGateway}
+  Interval: ${interval}ms\n`);
+
+    lastPrintTime = now;
+  }
+).then((result) => {
+  const avgInterval = progressIntervals.length > 0 ? progressIntervals.reduce((a, b) => a + b, 0) / progressIntervals.length : 0;
+  console.log('\n=== Download Complete ===');
+  console.log(`Result: ${JSON.stringify(result, null, 2)}`);
+  console.log(`\nProgress Tracking Statistics:
+  Total Updates: ${progressCount}
+  Interval Range: ${minInterval}ms - ${maxInterval}ms
+  Average Interval: ${avgInterval.toFixed(0)}ms
+  Expected Interval: 200ms (should be 100-500ms range)`);
+
+  if (avgInterval >= 100 && avgInterval <= 500) {
+    console.log('  Status: PASS - Progress interval within acceptable range');
+  } else {
+    console.log('  Status: FAIL - Progress interval outside acceptable range');
+  }
+
+  if (fs.existsSync(path.join(testDir, 'test-file.pdf'))) {
+    const stat = fs.statSync(path.join(testDir, 'test-file.pdf'));
+    console.log(`\nDownloaded file size: ${(stat.size / 1024).toFixed(1)}KB`);
+  }
+
+  process.exit(0);
+}).catch((err) => {
+  console.error('Download failed:', err.message);
+  process.exit(1);
+});