agentgui 1.0.294 → 1.0.295

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.294",
+  "version": "1.0.295",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",
@@ -30,7 +30,7 @@
     "fsbrowse": "^0.2.18",
     "google-auth-library": "^10.5.0",
     "onnxruntime-node": "^1.24.1",
-    "webtalk": "^1.0.13",
+    "webtalk": "^1.0.14",
     "ws": "^8.14.2"
   },
   "overrides": {

package/server.js

@@ -14,7 +14,7 @@ import Busboy from 'busboy';
 import fsbrowse from 'fsbrowse';
 import { queries } from './database.js';
 import { runClaudeWithStreaming } from './lib/claude-runner.js';
-import IPFSDownloader from './lib/ipfs-downloader.js';
+const { downloadWithProgress } = createRequire(import.meta.url)('webtalk/ipfs-downloader');
 
 const ttsTextAccumulators = new Map();
 
@@ -121,7 +121,7 @@ async function ensureModelsDownloaded() {
           const sttUrl = `${lighthouseGateway}/${ipfsCid.cid}/stt/onnx-community/whisper-base/onnx/`;
           const sttFile = path.join(sttDir, 'whisper-onnx.tar');
 
-          await IPFSDownloader.downloadWithProgress(
+          await downloadWithProgress(
             sttUrl,
             sttFile,
             (progress) => {
@@ -178,7 +178,7 @@ async function ensureModelsDownloaded() {
           const ttsUrl = `${lighthouseGateway}/${ipfsCid.cid}/tts/`;
           const ttsFile = path.join(ttsDir, 'tts-models.tar');
 
-          await IPFSDownloader.downloadWithProgress(
+          await downloadWithProgress(
             ttsUrl,
             ttsFile,
             (progress) => {

package/lib/ipfs-downloader.js

@@ -1,459 +0,0 @@
-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,
-  get DOWNLOADS_DIR() { return path.join(process.env.PORTABLE_DATA_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;
-  }
-
-  async downloadWithProgress(url, destination, onProgress = null) {
-    const dir = path.dirname(destination);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-
-    let bytesDownloaded = 0;
-    let totalBytes = 0;
-    let lastProgressTime = Date.now();
-    let lastProgressBytes = 0;
-    const speeds = [];
-    let gatewayIndex = 0;
-    let retryCount = 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 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()
-          });
-        }
-
-        const protocol = gateway.startsWith('https') ? https : http;
-        protocol.get(gateway, { timeout: CONFIG.TIMEOUT_MS }, (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]);
-    });
-  }
-}
-
-export default new IPFSDownloader();

package/test-download-progress.js

@@ -1,223 +0,0 @@
-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);
-});

package/tests/ipfs-downloader.test.js

@@ -1,370 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import crypto from 'crypto';
-import downloader from '../lib/ipfs-downloader.js';
-import { queries } from '../database.js';
-
-const TEST_DIR = path.join(os.homedir(), '.gmgui', 'test-downloads');
-const TEST_TIMEOUT = 60000;
-
-class TestRunner {
-  constructor() {
-    this.passed = 0;
-    this.failed = 0;
-    this.results = [];
-  }
-
-  async test(name, fn) {
-    try {
-      await fn();
-      this.passed++;
-      this.results.push({ name, status: 'PASS' });
-      console.log(`[PASS] ${name}`);
-    } catch (err) {
-      this.failed++;
-      this.results.push({ name, status: 'FAIL', error: err.message });
-      console.log(`[FAIL] ${name}: ${err.message}`);
-    }
-  }
-
-  summary() {
-    console.log(`\n=== TEST SUMMARY ===`);
-    console.log(`Passed: ${this.passed}`);
-    console.log(`Failed: ${this.failed}`);
-    console.log(`Total: ${this.passed + this.failed}`);
-    return this.failed === 0;
-  }
-}
-
-async function setupTestEnv() {
-  if (!fs.existsSync(TEST_DIR)) {
-    fs.mkdirSync(TEST_DIR, { recursive: true });
-  }
-}
-
-function cleanupTestEnv() {
-  if (fs.existsSync(TEST_DIR)) {
-    const files = fs.readdirSync(TEST_DIR);
-    for (const file of files) {
-      fs.unlinkSync(path.join(TEST_DIR, file));
-    }
-    fs.rmdirSync(TEST_DIR);
-  }
-}
-
-async function createMockFile(size, corrupted = false) {
-  const buffer = Buffer.alloc(size);
-  for (let i = 0; i < size; i++) {
-    buffer[i] = Math.floor(Math.random() * 256);
-  }
-
-  if (corrupted) {
-    buffer[0] = 0xFF;
-    buffer[1] = 0xFF;
-  }
-
-  const filename = `mock-${Date.now()}.bin`;
-  const filepath = path.join(TEST_DIR, filename);
-  fs.writeFileSync(filepath, buffer);
-  return { filepath, size, hash: crypto.createHash('sha256').update(buffer).digest('hex') };
-}
-
-async function simulatePartialDownload(filepath, targetSize) {
-  if (!fs.existsSync(filepath)) {
-    const buffer = Buffer.alloc(targetSize);
-    crypto.randomFillSync(buffer);
-    fs.writeFileSync(filepath, buffer);
-  }
-  return fs.statSync(filepath).size;
-}
-
-const runner = new TestRunner();
-
-console.log('=== IPFS DOWNLOADER RESUME TESTS ===\n');
-
-await setupTestEnv();
-
-await runner.test('1. Detect partial download by size comparison', async () => {
-  const testFile = path.join(TEST_DIR, 'partial.bin');
-  const fullSize = 1000;
-  const partialSize = 250;
-
-  await simulatePartialDownload(testFile, partialSize);
-  const actualSize = fs.statSync(testFile).size;
-
-  if (actualSize !== partialSize) {
-    throw new Error(`Size mismatch: expected ${partialSize}, got ${actualSize}`);
-  }
-
-  if (actualSize < fullSize) {
-    console.log(`    Partial download detected: ${actualSize}/${fullSize} bytes`);
-  }
-});
-
-await runner.test('2. Resume from offset (25% partial)', async () => {
-  const testFile = path.join(TEST_DIR, 'resume-25.bin');
-  const fullSize = 1000;
-  const partial25 = Math.floor(fullSize * 0.25);
-
-  const buffer = Buffer.alloc(partial25);
-  crypto.randomFillSync(buffer);
-  fs.writeFileSync(testFile, buffer);
-
-  const currentSize = fs.statSync(testFile).size;
-  const resumed = await simulatePartialDownload(testFile, fullSize);
-
-  if (currentSize < fullSize && resumed >= currentSize) {
-    console.log(`    Successfully resumed from ${currentSize} bytes`);
-  } else {
-    throw new Error('Resume from 25% failed');
-  }
-});
-
-await runner.test('3. Resume from offset (50% partial)', async () => {
-  const testFile = path.join(TEST_DIR, 'resume-50.bin');
-  const fullSize = 1000;
-  const partial50 = Math.floor(fullSize * 0.5);
-
-  const buffer = Buffer.alloc(partial50);
-  crypto.randomFillSync(buffer);
-  fs.writeFileSync(testFile, buffer);
-
-  const currentSize = fs.statSync(testFile).size;
-  const resumed = await simulatePartialDownload(testFile, fullSize);
-
-  if (currentSize < fullSize && resumed >= currentSize) {
-    console.log(`    Successfully resumed from ${currentSize} bytes (50%)`);
-  } else {
-    throw new Error('Resume from 50% failed');
-  }
-});
-
-await runner.test('4. Resume from offset (75% partial)', async () => {
-  const testFile = path.join(TEST_DIR, 'resume-75.bin');
-  const fullSize = 1000;
-  const partial75 = Math.floor(fullSize * 0.75);
-
-  const buffer = Buffer.alloc(partial75);
-  crypto.randomFillSync(buffer);
-  fs.writeFileSync(testFile, buffer);
-
-  const currentSize = fs.statSync(testFile).size;
-  const resumed = await simulatePartialDownload(testFile, fullSize);
-
-  if (currentSize < fullSize && resumed >= currentSize) {
-    console.log(`    Successfully resumed from ${currentSize} bytes (75%)`);
-  } else {
-    throw new Error('Resume from 75% failed');
-  }
-});
-
-await runner.test('5. Hash verification after resume', async () => {
-  const mockData = await createMockFile(1000);
-  const verified = await downloader.verifyHash(mockData.filepath, mockData.hash);
-
-  if (!verified) {
-    throw new Error('Hash verification failed for valid file');
-  }
-
-  console.log(`    Hash verified: ${mockData.hash.substring(0, 16)}...`);
-});
-
-await runner.test('6. Detect corrupted file during resume', async () => {
-  const mockData = await createMockFile(1000, true);
-  const corruptedHash = crypto.createHash('sha256').update(Buffer.alloc(1000, 0xFF)).digest('hex');
-
-  const verified = await downloader.verifyHash(mockData.filepath, corruptedHash);
-
-  if (verified) {
-    throw new Error('Hash mismatch should have been detected');
-  }
-
-  console.log(`    Corruption detected correctly`);
-});
-
-await runner.test('7. Cleanup partial file on corruption', async () => {
-  const testFile = path.join(TEST_DIR, 'corrupted.bin');
-  const buffer = Buffer.alloc(500);
-  crypto.randomFillSync(buffer);
-  fs.writeFileSync(testFile, buffer);
-
-  if (!fs.existsSync(testFile)) {
-    throw new Error('Test file not created');
-  }
-
-  await downloader.cleanupPartial(testFile);
-
-  if (fs.existsSync(testFile)) {
-    throw new Error('Partial file was not cleaned up');
-  }
-
-  console.log(`    Partial file cleaned up successfully`);
-});
-
-await runner.test('8. Track resume attempts in database', async () => {
-  const cidRecord = queries.recordIpfsCid(
-    'QmTest12345',
-    'test-model',
-    'test-type',
-    'test-hash',
-    'https://ipfs.io/ipfs/'
-  );
-
-  const downloadId = queries.recordDownloadStart(cidRecord, '/tmp/test.bin', 1000);
-  const initial = queries.getDownload(downloadId);
-
-  if (!initial || initial.attempts === undefined) {
-    throw new Error('Download tracking failed');
-  }
-
-  queries.updateDownloadResume(downloadId, 250, 1, Date.now(), 'resuming');
-  const updated = queries.getDownload(downloadId);
-
-  if (updated.attempts !== 1) {
-    throw new Error(`Attempt tracking failed: expected 1, got ${updated.attempts}`);
-  }
-
-  console.log(`    Attempts tracked: ${updated.attempts}`);
-});
-
-await runner.test('9. Gateway fallback on unavailability', async () => {
-  const gateways = [
-    'https://ipfs.io/ipfs/',
-    'https://gateway.pinata.cloud/ipfs/',
-    'https://cloudflare-ipfs.com/ipfs/'
-  ];
-
-  let fallbackIndex = 0;
-  const simulateFallback = (currentIndex) => {
-    fallbackIndex = (currentIndex + 1) % gateways.length;
-    return gateways[fallbackIndex];
-  };
-
-  const initialGateway = gateways[0];
-  const nextGateway = simulateFallback(0);
-
-  if (nextGateway === initialGateway) {
-    throw new Error('Gateway fallback failed');
-  }
-
-  console.log(`    Fallback: ${initialGateway} -> ${nextGateway}`);
-});
-
-await runner.test('10. Exponential backoff for timeouts', async () => {
-  const INITIAL_BACKOFF = 1000;
-  const MULTIPLIER = 2;
-
-  const backoffs = [];
-  for (let attempt = 1; attempt <= 3; attempt++) {
-    const backoff = INITIAL_BACKOFF * Math.pow(MULTIPLIER, attempt - 1);
-    backoffs.push(backoff);
-  }
-
-  if (backoffs[0] !== 1000 || backoffs[1] !== 2000 || backoffs[2] !== 4000) {
-    throw new Error(`Backoff calculation wrong: ${backoffs}`);
-  }
-
-  console.log(`    Backoff delays: ${backoffs.join('ms, ')}ms`);
-});
-
-await runner.test('11. Max resume attempts enforcement', async () => {
-  const cidRecord = queries.recordIpfsCid(
-    'QmTest67890',
-    'test-model-2',
-    'test-type-2',
-    'test-hash-2',
-    'https://ipfs.io/ipfs/'
-  );
-
-  const downloadId = queries.recordDownloadStart(cidRecord, '/tmp/test2.bin', 1000);
-
-  let attempts = 0;
-  while (attempts < 4) {
-    attempts++;
-    if (attempts > 3) {
-      const download = queries.getDownload(downloadId);
-      if (download.attempts >= 3) {
-        console.log(`    Max attempts enforced at ${download.attempts}`);
-        break;
-      }
-    }
-    queries.updateDownloadResume(downloadId, 250 * attempts, attempts, Date.now(), 'resuming');
-  }
-
-  const final = queries.getDownload(downloadId);
-  if (final.attempts > 3) {
-    console.log(`    Attempts capped at ${final.attempts}`);
-  }
-});
-
-await runner.test('12. Range header support detection', async () => {
-  const headers = { 'Accept-Ranges': 'bytes' };
-  const supportsRange = headers['Accept-Ranges'] === 'bytes';
-
-  if (!supportsRange) {
-    throw new Error('Range header detection failed');
-  }
-
-  console.log(`    Server supports Range requests`);
-});
-
-await runner.test('13. Stream reset recovery strategy', async () => {
-  const fullSize = 1000;
-  const downloadedSize = 600;
-  const threshold = 0.5;
-
-  const downloadPercent = (downloadedSize / fullSize) * 100;
-  const shouldResume = downloadPercent > (threshold * 100);
-
-  if (!shouldResume) {
-    throw new Error('Stream reset strategy failed');
-  }
-
-  console.log(`    Stream reset detected at ${downloadPercent}%, resuming (>50%)`);
-});
-
-await runner.test('14. Disk space handling during resume', async () => {
-  const testFile = path.join(TEST_DIR, 'diskspace.bin');
-  const testSize = 100;
-
-  const buffer = Buffer.alloc(testSize);
-  crypto.randomFillSync(buffer);
-  fs.writeFileSync(testFile, buffer);
-
-  const stats = fs.statSync(testFile);
-  if (stats.size !== testSize) {
-    throw new Error('File write verification failed');
-  }
-
-  console.log(`    File write verified: ${stats.size} bytes`);
-});
-
-await runner.test('15. Download status lifecycle', async () => {
-  const cidRecord = queries.recordIpfsCid(
-    'QmTestStatus',
-    'test-model-status',
-    'test-type-status',
-    'test-hash-status',
-    'https://ipfs.io/ipfs/'
-  );
-
-  const downloadId = queries.recordDownloadStart(cidRecord, '/tmp/status.bin', 1000);
-  let download = queries.getDownload(downloadId);
-
-  const statuses = ['in_progress', 'resuming', 'paused', 'success'];
-  for (const status of statuses.slice(0, 3)) {
-    queries.updateDownloadResume(downloadId, 100, 1, Date.now(), status);
-    download = queries.getDownload(downloadId);
-    if (download.status !== status) {
-      throw new Error(`Status transition failed: ${download.status} !== ${status}`);
-    }
-  }
-
-  console.log(`    Status lifecycle: ${statuses.slice(0, 3).join(' -> ')}`);
-});
-
-cleanupTestEnv();
-
-const allPassed = runner.summary();
-process.exit(allPassed ? 0 : 1);