agentgui 1.0.359 → 1.0.361

package/build-portable.js

@@ -135,7 +135,20 @@ if (process.env.NO_BUNDLE_MODELS === 'true') {
   log('Skipping model bundling (NO_BUNDLE_MODELS=true) - models will download on first use');
 } else {
   log('Bundling AI models...');
-  const userModels = process.env.MODELS_SOURCE_DIR || path.join(os.homedir(), '.gmgui', 'models');
+    // Get models from AnEntrypoint/models or local cache
+  let modelsDir = process.env.MODELS_SOURCE_DIR || path.join(os.homedir(), '.gmgui', 'models');
+  
+  // If models not present and we're in CI, clone from GitHub
+  if (!fs.existsSync(modelsDir) && process.env.CI) {
+    console.log('[BUILD] Models not found, cloning from GitHub...');
+    const ciModelsDir = path.join(os.tmpdir(), 'models-clone');
+    try {
+      require('child_process').execSync(`git clone https://github.com/AnEntrypoint/models.git "${ciModelsDir}" --depth 1`, { stdio: 'inherit' });
+      modelsDir = ciModelsDir;
+    } catch (e) {
+      console.error('[BUILD] Failed to clone models from GitHub:', e.message);
+    }
+  }
   if (fs.existsSync(userModels)) {
     copyDir(userModels, path.join(out, 'models'));
     log(`Models bundled: ${Math.round(sizeOf(path.join(out, 'models')) / 1024 / 1024)}MB`);

package/database.js

@@ -150,39 +150,6 @@ function initSchema() {
     CREATE INDEX IF NOT EXISTS idx_chunks_conv_created ON chunks(conversationId, created_at);
     CREATE INDEX IF NOT EXISTS idx_chunks_sess_created ON chunks(sessionId, created_at);
 
-    CREATE TABLE IF NOT EXISTS ipfs_cids (
-      id TEXT PRIMARY KEY,
-      cid TEXT NOT NULL UNIQUE,
-      modelName TEXT NOT NULL,
-      modelType TEXT NOT NULL,
-      modelHash TEXT,
-      gatewayUrl TEXT,
-      cached_at INTEGER NOT NULL,
-      last_accessed_at INTEGER NOT NULL,
-      success_count INTEGER DEFAULT 0,
-      failure_count INTEGER DEFAULT 0
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_ipfs_cids_model ON ipfs_cids(modelName);
-    CREATE INDEX IF NOT EXISTS idx_ipfs_cids_type ON ipfs_cids(modelType);
-    CREATE INDEX IF NOT EXISTS idx_ipfs_cids_hash ON ipfs_cids(modelHash);
-
-    CREATE TABLE IF NOT EXISTS ipfs_downloads (
-      id TEXT PRIMARY KEY,
-      cidId TEXT NOT NULL,
-      downloadPath TEXT NOT NULL,
-      status TEXT DEFAULT 'pending',
-      downloaded_bytes INTEGER DEFAULT 0,
-      total_bytes INTEGER,
-      error_message TEXT,
-      started_at INTEGER NOT NULL,
-      completed_at INTEGER,
-      FOREIGN KEY (cidId) REFERENCES ipfs_cids(id)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_ipfs_downloads_cid ON ipfs_downloads(cidId);
-    CREATE INDEX IF NOT EXISTS idx_ipfs_downloads_status ON ipfs_downloads(status);
-    CREATE INDEX IF NOT EXISTS idx_ipfs_downloads_started ON ipfs_downloads(started_at);
   `);
 }
 
@@ -305,9 +272,9 @@ try {
   console.error('[Migration] Error:', err.message);
 }
 
-// Migration: Add resume capability columns to ipfs_downloads if needed
+// Migration: Add resume capability columns to  if needed
 try {
-  const result = db.prepare("PRAGMA table_info(ipfs_downloads)").all();
+  const result = db.prepare("PRAGMA table_info()").all();
   const columnNames = result.map(r => r.name);
   const resumeColumns = {
     attempts: 'INTEGER DEFAULT 0',
@@ -318,12 +285,12 @@ try {
 
   for (const [colName, colDef] of Object.entries(resumeColumns)) {
     if (!columnNames.includes(colName)) {
-      db.exec(`ALTER TABLE ipfs_downloads ADD COLUMN ${colName} ${colDef}`);
-      console.log(`[Migration] Added column ${colName} to ipfs_downloads table`);
+      db.exec(`ALTER TABLE  ADD COLUMN ${colName} ${colDef}`);
+      console.log(`[Migration] Added column ${colName} to  table`);
     }
   }
 } catch (err) {
-  console.error('[Migration] IPFS schema update warning:', err.message);
+  console.error('[Migration] Schema update warning:', err.message);
 }
 
 // Migration: Backfill messages for conversations imported without message content
@@ -383,46 +350,6 @@ try {
   console.error('[Migration] Backfill error:', err.message);
 }
 
-// Register official IPFS CIDs for voice models
-try {
-  const LIGHTHOUSE_GATEWAY = 'https://gateway.lighthouse.storage/ipfs';
-  const WHISPER_CID = 'bafybeidyw252ecy4vs46bbmezrtw325gl2ymdltosmzqgx4edjsc3fbofy';
-  const TTS_CID = 'bafybeidyw252ecy4vs46bbmezrtw325gl2ymdltosmzqgx4edjsc3fbofy';
-  const TTS_TOKENIZER_MODEL_CID = 'bafkreigumf3fvylzkzthrsjqshc7u3zjqtbrxpuzbpy2uywzfrsnsg6d6y';
-
-  // Check if CIDs are already registered
-  const existingWhisper = db.prepare('SELECT * FROM ipfs_cids WHERE modelName = ? AND modelType = ?').get('whisper-base', 'stt');
-  if (!existingWhisper) {
-    const cidId = `cid-${Date.now()}-whisper`;
-    db.prepare(
-      `INSERT INTO ipfs_cids (id, cid, modelName, modelType, modelHash, gatewayUrl, cached_at, last_accessed_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(cidId, WHISPER_CID, 'whisper-base', 'stt', 'sha256-verified', LIGHTHOUSE_GATEWAY, Date.now(), Date.now());
-    console.log('[MODELS] Registered Whisper STT IPFS CID:', WHISPER_CID);
-  }
-
-  const existingTTS = db.prepare('SELECT * FROM ipfs_cids WHERE modelName = ? AND modelType = ?').get('tts-models', 'voice');
-  if (!existingTTS) {
-    const cidId = `cid-${Date.now()}-tts`;
-    db.prepare(
-      `INSERT INTO ipfs_cids (id, cid, modelName, modelType, modelHash, gatewayUrl, cached_at, last_accessed_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(cidId, TTS_CID, 'tts-models', 'voice', 'sha256-verified', LIGHTHOUSE_GATEWAY, Date.now(), Date.now());
-    console.log('[MODELS] Registered TTS IPFS CID:', TTS_CID);
-  }
-
-  const existingTokenizerModel = db.prepare('SELECT * FROM ipfs_cids WHERE modelName = ? AND modelType = ?').get('tts-tokenizer.model', 'voice-file');
-  if (!existingTokenizerModel) {
-    const cidId = `cid-${Date.now()}-tts-tokenizer-model`;
-    db.prepare(
-      `INSERT INTO ipfs_cids (id, cid, modelName, modelType, modelHash, gatewayUrl, cached_at, last_accessed_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(cidId, TTS_TOKENIZER_MODEL_CID, 'tts-tokenizer.model', 'voice-file', 'd461765ae179566678c93091c5fa6f2984c31bbe990bf1aa62d92c64d91bc3f6', LIGHTHOUSE_GATEWAY, Date.now(), Date.now());
-    console.log('[MODELS] Registered TTS tokenizer.model IPFS CID:', TTS_TOKENIZER_MODEL_CID);
-  }
-} catch (err) {
-  console.warn('[MODELS] IPFS CID registration warning:', err.message);
-}
 
 const stmtCache = new Map();
 function prep(sql) {
@@ -1345,84 +1272,15 @@ export const queries = {
     return deletedCount;
   },
 
-  recordIpfsCid(cid, modelName, modelType, modelHash, gatewayUrl) {
-    const id = generateId('ipfs');
-    const now = Date.now();
-    const stmt = prep(`
-      INSERT INTO ipfs_cids (id, cid, modelName, modelType, modelHash, gatewayUrl, cached_at, last_accessed_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(cid) DO UPDATE SET last_accessed_at = ?, success_count = success_count + 1
-    `);
-    stmt.run(id, cid, modelName, modelType, modelHash, gatewayUrl, now, now, now);
-    const record = this.getIpfsCid(cid);
-    return record ? record.id : id;
-  },
-
-  getIpfsCid(cid) {
-    const stmt = prep('SELECT * FROM ipfs_cids WHERE cid = ?');
-    return stmt.get(cid);
-  },
-
-  getIpfsCidByModel(modelName, modelType) {
-    const stmt = prep('SELECT * FROM ipfs_cids WHERE modelName = ? AND modelType = ? ORDER BY last_accessed_at DESC LIMIT 1');
-    return stmt.get(modelName, modelType);
-  },
-
-  recordDownloadStart(cidId, downloadPath, totalBytes) {
-    const id = generateId('dl');
-    const stmt = prep(`
-      INSERT INTO ipfs_downloads (id, cidId, downloadPath, status, total_bytes, started_at)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `);
-    stmt.run(id, cidId, downloadPath, 'in_progress', totalBytes, Date.now());
-    return id;
-  },
-
-  updateDownloadProgress(downloadId, downloadedBytes) {
-    const stmt = prep(`
-      UPDATE ipfs_downloads SET downloaded_bytes = ? WHERE id = ?
-    `);
-    stmt.run(downloadedBytes, downloadId);
-  },
-
-  completeDownload(downloadId, cidId) {
-    const now = Date.now();
-    prep(`
-      UPDATE ipfs_downloads SET status = ?, completed_at = ? WHERE id = ?
-    `).run('success', now, downloadId);
-    prep(`
-      UPDATE ipfs_cids SET last_accessed_at = ? WHERE id = ?
-    `).run(now, cidId);
-  },
-
-  recordDownloadError(downloadId, cidId, errorMessage) {
-    const now = Date.now();
-    prep(`
-      UPDATE ipfs_downloads SET status = ?, error_message = ?, completed_at = ? WHERE id = ?
-    `).run('failed', errorMessage, now, downloadId);
-    prep(`
-      UPDATE ipfs_cids SET failure_count = failure_count + 1 WHERE id = ?
-    `).run(cidId);
-  },
-
-  getDownload(downloadId) {
-    const stmt = prep('SELECT * FROM ipfs_downloads WHERE id = ?');
-    return stmt.get(downloadId);
-  },
-
-  getDownloadsByCid(cidId) {
-    const stmt = prep('SELECT * FROM ipfs_downloads WHERE cidId = ? ORDER BY started_at DESC');
-    return stmt.all(cidId);
-  },
 
   getDownloadsByStatus(status) {
-    const stmt = prep('SELECT * FROM ipfs_downloads WHERE status = ? ORDER BY started_at DESC');
+    const stmt = prep('SELECT * FROM  WHERE status = ? ORDER BY started_at DESC');
     return stmt.all(status);
   },
 
   updateDownloadResume(downloadId, currentSize, attempts, lastAttempt, status) {
     const stmt = prep(`
-      UPDATE ipfs_downloads
+      UPDATE 
       SET downloaded_bytes = ?, attempts = ?, lastAttempt = ?, status = ?
       WHERE id = ?
     `);
@@ -1430,17 +1288,17 @@ export const queries = {
   },
 
   updateDownloadHash(downloadId, hash) {
-    const stmt = prep('UPDATE ipfs_downloads SET hash = ? WHERE id = ?');
+    const stmt = prep('UPDATE  SET hash = ? WHERE id = ?');
     stmt.run(hash, downloadId);
   },
 
   markDownloadResuming(downloadId) {
-    const stmt = prep('UPDATE ipfs_downloads SET status = ?, lastAttempt = ? WHERE id = ?');
+    const stmt = prep('UPDATE  SET status = ?, lastAttempt = ? WHERE id = ?');
     stmt.run('resuming', Date.now(), downloadId);
   },
 
   markDownloadPaused(downloadId, errorMessage) {
-    const stmt = prep('UPDATE ipfs_downloads SET status = ?, error_message = ?, lastAttempt = ? WHERE id = ?');
+    const stmt = prep('UPDATE  SET status = ?, error_message = ?, lastAttempt = ? WHERE id = ?');
     stmt.run('paused', errorMessage, Date.now(), downloadId);
   }
 };

package/lib/download-metrics.js

@@ -43,11 +43,6 @@ export function getMetricsSummary() {
   const summary = {
     total: metrics.length,
     cache_hits: metrics.filter(m => m.layer === 'cache' && m.status === 'hit').length,
-    ipfs: {
-      success: metrics.filter(m => m.layer === 'ipfs' && m.status === 'success').length,
-      error: metrics.filter(m => m.layer === 'ipfs' && m.status === 'error').length,
-      avg_latency: 0
-    },
     huggingface: {
       success: metrics.filter(m => m.layer === 'huggingface' && m.status === 'success').length,
       error: metrics.filter(m => m.layer === 'huggingface' && m.status === 'error').length,
@@ -55,13 +50,6 @@ export function getMetricsSummary() {
     }
   };
 
-  const ipfsSuccess = metrics.filter(m => m.layer === 'ipfs' && m.status === 'success');
-  if (ipfsSuccess.length > 0) {
-    summary.ipfs.avg_latency = Math.round(
-      ipfsSuccess.reduce((sum, m) => sum + m.latency_ms, 0) / ipfsSuccess.length
-    );
-  }
-
   const hfSuccess = metrics.filter(m => m.layer === 'huggingface' && m.status === 'success');
   if (hfSuccess.length > 0) {
     summary.huggingface.avg_latency = Math.round(

package/lib/model-downloader.js

@@ -7,85 +7,13 @@ import { verifyFileIntegrity } from './file-verification.js';
 const require = createRequire(import.meta.url);
 
 const GATEWAYS = [
-  'https://cloudflare-ipfs.com/ipfs/',
-  'https://dweb.link/ipfs/',
-  'https://gateway.pinata.cloud/ipfs/',
-  'https://ipfs.io/ipfs/'
+  'https://cloudflare-huggingface.com/huggingface/',
+  'https://dweb.link/huggingface/',
+  'https://gateway.pinata.cloud/huggingface/',
+  'https://huggingface.io/huggingface/'
 ];
 
-async function downloadFromIPFS(cid, destPath, manifest, onProgress) {
-  const startTime = Date.now();
-
-  for (let gatewayIndex = 0; gatewayIndex < GATEWAYS.length; gatewayIndex++) {
-    const gateway = GATEWAYS[gatewayIndex];
-    const gatewayName = new URL(gateway).hostname;
-
-    for (let retry = 0; retry < 2; retry++) {
-      try {
-        if (onProgress) {
-          onProgress({
-            layer: 'ipfs',
-            gateway: gatewayName,
-            attempt: retry + 1,
-            status: 'attempting'
-          });
-        }
-
-        const { downloadWithProgress } = require('webtalk/ipfs-downloader');
-        const url = `${gateway}${cid}`;
-
-        await downloadWithProgress(url, destPath, (progress) => {
-          if (onProgress) {
-            onProgress({
-              layer: 'ipfs',
-              gateway: gatewayName,
-              status: 'downloading',
-              ...progress
-            });
-          }
-        });
-
-        const verification = verifyFileIntegrity(
-          destPath,
-          manifest?.sha256,
-          manifest?.size ? manifest.size * 0.8 : null
-        );
-
-        if (!verification.valid) {
-          if (fs.existsSync(destPath)) fs.unlinkSync(destPath);
-          throw new Error(`Verification failed: ${verification.reason}`);
-        }
-
-        recordMetric({
-          modelType: 'model',
-          layer: 'ipfs',
-          gateway: gatewayName,
-          status: 'success',
-          latency_ms: Date.now() - startTime,
-          bytes_downloaded: fs.statSync(destPath).size
-        });
-
-        return { success: true, source: 'ipfs', gateway: gatewayName };
-      } catch (error) {
-        recordMetric({
-          modelType: 'model',
-          layer: 'ipfs',
-          gateway: gatewayName,
-          status: 'error',
-          error_type: error.name,
-          error_message: error.message,
-          latency_ms: Date.now() - startTime
-        });
-
-        if (retry < 1) {
-          await new Promise(resolve => setTimeout(resolve, 1000 * (retry + 1)));
-        }
-      }
-    }
-  }
 
-  throw new Error('All IPFS gateways exhausted');
-}
 
 async function downloadFromHuggingFace(url, destPath, minBytes, onProgress) {
   const startTime = Date.now();
@@ -132,13 +60,12 @@ async function downloadFromHuggingFace(url, destPath, minBytes, onProgress) {
 
 export async function downloadWithFallback(options, onProgress) {
   const {
-    ipfsCid,
+    huggingfaceCid,
     huggingfaceUrl,
     destPath,
     manifest,
     minBytes,
-    preferredLayer = 'ipfs'
-  } = options;
+    preferredLayer = } = options;
 
   const dir = path.dirname(destPath);
   if (!fs.existsSync(dir)) {
@@ -162,14 +89,13 @@ export async function downloadWithFallback(options, onProgress) {
     }
   }
 
-  const layers = preferredLayer === 'ipfs'
-    ? ['ipfs', 'huggingface']
-    : ['huggingface', 'ipfs'];
+  const layers = preferredLayer === ? ['huggingface']
+    : ['huggingface', ];
 
   for (const layer of layers) {
     try {
-      if (layer === 'ipfs' && ipfsCid) {
-        return await downloadFromIPFS(ipfsCid, destPath, manifest, onProgress);
+      if (layer === && huggingfaceCid) {
+        return await downloadFromhuggingface(huggingfaceCid, destPath, manifest, onProgress);
       } else if (layer === 'huggingface' && huggingfaceUrl) {
         return await downloadFromHuggingFace(huggingfaceUrl, destPath, minBytes, onProgress);
       }

package/package.json

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

package/server.js

@@ -2669,13 +2669,6 @@ const server = http.createServer(async (req, res) => {
         const { getMetricsSummary } = await import('./lib/model-downloader.js');
         const summary = getMetricsSummary();
         const health = {
-          ipfs: {
-            status: summary.ipfs.success > 0 ? 'healthy' : summary.ipfs.error > 0 ? 'degraded' : 'unknown',
-            success_rate: summary.ipfs.success + summary.ipfs.error > 0
-              ? ((summary.ipfs.success / (summary.ipfs.success + summary.ipfs.error)) * 100).toFixed(2)
-              : 0,
-            avg_latency_ms: summary.ipfs.avg_latency
-          },
           huggingface: {
             status: summary.huggingface.success > 0 ? 'healthy' : summary.huggingface.error > 0 ? 'degraded' : 'unknown',
             success_rate: summary.huggingface.success + summary.huggingface.error > 0

package/lib/ipfs-publish.js

@@ -1,136 +0,0 @@
-import { createRequire } from 'module';
-import { create } from 'ipfs-http-client';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-
-const require = createRequire(import.meta.url);
-
-export async function publishToIPFS(dirPath, options = {}) {
-  const {
-    gateway = '/ip4/127.0.0.1/tcp/5001',
-    pinToServices = ['pinata', 'lighthouse'],
-    onProgress = null
-  } = options;
-
-  try {
-    const ipfs = create({ url: gateway });
-
-    const dir = path.resolve(dirPath);
-    if (!fs.existsSync(dir)) {
-      throw new Error(`Directory not found: ${dir}`);
-    }
-
-    const files = [];
-    function addFiles(currentPath, basePath) {
-      const entries = fs.readdirSync(currentPath, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path.join(currentPath, entry.name);
-        const relativePath = path.relative(basePath, fullPath);
-
-        if (entry.isDirectory()) {
-          addFiles(fullPath, basePath);
-        } else {
-          files.push({
-            path: relativePath,
-            content: fs.readFileSync(fullPath)
-          });
-        }
-      }
-    }
-
-    addFiles(dir, dir);
-
-    if (onProgress) {
-      onProgress({ status: 'preparing', fileCount: files.length });
-    }
-
-    let uploadedCount = 0;
-    const results = [];
-
-    for await (const result of ipfs.addAll(files, { wrapWithDirectory: true, pin: true })) {
-      uploadedCount++;
-      results.push(result);
-
-      if (onProgress && result.path !== '') {
-        onProgress({
-          status: 'uploading',
-          file: result.path,
-          cid: result.cid.toString(),
-          uploaded: uploadedCount,
-          total: files.length
-        });
-      }
-    }
-
-    const rootCID = results[results.length - 1].cid.toString();
-
-    if (onProgress) {
-      onProgress({
-        status: 'complete',
-        rootCID,
-        fileCount: files.length,
-        results
-      });
-    }
-
-    return {
-      rootCID,
-      files: results.filter(r => r.path !== '').map(r => ({
-        path: r.path,
-        cid: r.cid.toString(),
-        size: r.size
-      }))
-    };
-  } catch (error) {
-    throw new Error(`IPFS publish failed: ${error.message}`);
-  }
-}
-
-export async function publishModels() {
-  const modelsDir = path.join(os.homedir(), '.gmgui', 'models');
-  const whisperDir = path.join(modelsDir, 'onnx-community', 'whisper-base');
-  const ttsDir = path.join(modelsDir, 'tts');
-
-  console.log('Publishing models to IPFS...\n');
-
-  const results = {};
-
-  if (fs.existsSync(whisperDir)) {
-    console.log('Publishing Whisper models...');
-    try {
-      const whisperResult = await publishToIPFS(whisperDir, {
-        onProgress: (progress) => {
-          if (progress.status === 'uploading') {
-            console.log(`  ${progress.uploaded}/${progress.total}: ${progress.file}`);
-          } else if (progress.status === 'complete') {
-            console.log(`✓ Whisper CID: ${progress.rootCID}\n`);
-          }
-        }
-      });
-      results.whisper = whisperResult;
-    } catch (error) {
-      console.error(`✗ Whisper publish failed: ${error.message}`);
-    }
-  }
-
-  if (fs.existsSync(ttsDir)) {
-    console.log('Publishing TTS models...');
-    try {
-      const ttsResult = await publishToIPFS(ttsDir, {
-        onProgress: (progress) => {
-          if (progress.status === 'uploading') {
-            console.log(`  ${progress.uploaded}/${progress.total}: ${progress.file}`);
-          } else if (progress.status === 'complete') {
-            console.log(`✓ TTS CID: ${progress.rootCID}\n`);
-          }
-        }
-      });
-      results.tts = ttsResult;
-    } catch (error) {
-      console.error(`✗ TTS publish failed: ${error.message}`);
-    }
-  }
-
-  return results;
-}

package/scripts/publish-models-to-ipfs.js

@@ -1,172 +0,0 @@
-#!/usr/bin/env node
-
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import https from 'https';
-import FormData from 'form-data';
-
-const PINATA_API_KEY = process.env.PINATA_API_KEY || '';
-const PINATA_SECRET_KEY = process.env.PINATA_SECRET_KEY || '';
-
-async function uploadToPinata(dirPath, folderName) {
-  if (!PINATA_API_KEY || !PINATA_SECRET_KEY) {
-    throw new Error('PINATA_API_KEY and PINATA_SECRET_KEY environment variables required');
-  }
-
-  const form = new FormData();
-
-  function addFilesRecursive(currentPath, basePath) {
-    const entries = fs.readdirSync(currentPath, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(currentPath, entry.name);
-      const relativePath = path.relative(basePath, fullPath);
-
-      if (entry.isDirectory()) {
-        addFilesRecursive(fullPath, basePath);
-      } else {
-        form.append('file', fs.createReadStream(fullPath), {
-          filepath: `${folderName}/${relativePath}`
-        });
-      }
-    }
-  }
-
-  addFilesRecursive(dirPath, dirPath);
-
-  const metadata = JSON.stringify({
-    name: folderName,
-    keyvalues: {
-      type: 'model',
-      timestamp: new Date().toISOString()
-    }
-  });
-  form.append('pinataMetadata', metadata);
-
-  const options = JSON.stringify({
-    wrapWithDirectory: false
-  });
-  form.append('pinataOptions', options);
-
-  return new Promise((resolve, reject) => {
-    const req = https.request({
-      method: 'POST',
-      hostname: 'api.pinata.cloud',
-      path: '/pinning/pinFileToIPFS',
-      headers: {
-        ...form.getHeaders(),
-        pinata_api_key: PINATA_API_KEY,
-        pinata_secret_api_key: PINATA_SECRET_KEY
-      }
-    }, (res) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => {
-        if (res.statusCode === 200) {
-          resolve(JSON.parse(data));
-        } else {
-          reject(new Error(`Pinata API error: ${res.statusCode} - ${data}`));
-        }
-      });
-    });
-
-    req.on('error', reject);
-    form.pipe(req);
-  });
-}
-
-async function publishViaPinata() {
-  const modelsDir = path.join(os.homedir(), '.gmgui', 'models');
-  const whisperDir = path.join(modelsDir, 'onnx-community', 'whisper-base');
-  const ttsDir = path.join(modelsDir, 'tts');
-
-  console.log('Publishing models to IPFS via Pinata...\n');
-
-  const results = {};
-
-  if (fs.existsSync(whisperDir)) {
-    console.log('Publishing Whisper models...');
-    try {
-      const result = await uploadToPinata(whisperDir, 'whisper-base');
-      results.whisper = {
-        cid: result.IpfsHash,
-        size: result.PinSize,
-        timestamp: result.Timestamp
-      };
-      console.log(`✓ Whisper CID: ${result.IpfsHash}`);
-      console.log(`  Size: ${(result.PinSize / 1024 / 1024).toFixed(2)} MB\n`);
-    } catch (error) {
-      console.error(`✗ Whisper failed: ${error.message}\n`);
-    }
-  }
-
-  if (fs.existsSync(ttsDir)) {
-    console.log('Publishing TTS models...');
-    try {
-      const result = await uploadToPinata(ttsDir, 'tts-models');
-      results.tts = {
-        cid: result.IpfsHash,
-        size: result.PinSize,
-        timestamp: result.Timestamp
-      };
-      console.log(`✓ TTS CID: ${result.IpfsHash}`);
-      console.log(`  Size: ${(result.PinSize / 1024 / 1024).toFixed(2)} MB\n`);
-    } catch (error) {
-      console.error(`✗ TTS failed: ${error.message}\n`);
-    }
-  }
-
-  const manifestPath = path.join(modelsDir, '.manifests.json');
-  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-
-  if (results.whisper) {
-    manifest['whisper-base'].ipfsHash = results.whisper.cid;
-    manifest['whisper-base'].publishedAt = new Date().toISOString();
-  }
-  if (results.tts) {
-    manifest['tts-models'].ipfsHash = results.tts.cid;
-    manifest['tts-models'].publishedAt = new Date().toISOString();
-  }
-
-  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-  console.log(`✓ Updated manifests at ${manifestPath}`);
-
-  console.log('\n=== IPFS GATEWAYS ===');
-  if (results.whisper) {
-    console.log('\nWhisper models:');
-    console.log(`  Cloudflare: https://cloudflare-ipfs.com/ipfs/${results.whisper.cid}`);
-    console.log(`  dweb.link:  https://dweb.link/ipfs/${results.whisper.cid}`);
-    console.log(`  Pinata:     https://gateway.pinata.cloud/ipfs/${results.whisper.cid}`);
-  }
-  if (results.tts) {
-    console.log('\nTTS models:');
-    console.log(`  Cloudflare: https://cloudflare-ipfs.com/ipfs/${results.tts.cid}`);
-    console.log(`  dweb.link:  https://dweb.link/ipfs/${results.tts.cid}`);
-    console.log(`  Pinata:     https://gateway.pinata.cloud/ipfs/${results.tts.cid}`);
-  }
-
-  return results;
-}
-
-console.log('AgentGUI Model Publishing Tool\n');
-console.log('This script publishes Whisper and TTS models to IPFS via Pinata.');
-console.log('Required: PINATA_API_KEY and PINATA_SECRET_KEY environment variables.\n');
-console.log('Get free API keys at: https://www.pinata.cloud/\n');
-
-if (!PINATA_API_KEY || !PINATA_SECRET_KEY) {
-  console.error('ERROR: Missing Pinata credentials');
-  console.error('Set environment variables:');
-  console.error('  export PINATA_API_KEY=your_api_key');
-  console.error('  export PINATA_SECRET_KEY=your_secret_key\n');
-  process.exit(1);
-}
-
-publishViaPinata()
-  .then(results => {
-    console.log('\n✓ Publishing complete!');
-    console.log(JSON.stringify(results, null, 2));
-  })
-  .catch(error => {
-    console.error('\n✗ Publishing failed:', error.message);
-    process.exit(1);
-  });