agentgui 1.0.319 → 1.0.320

package/.prd

@@ -44,14 +44,9 @@
 
 ### Wave 1 (COMPLETE - all items removed from work breakdown)
 
-### Wave 2 (Depends on Wave 1)
-4. Obtain Pinata API keys (if available) OR document blocking status
-   - Blocked by: Wave 1 item 3 (dry-run test)
-   - Blocks: Real IPFS publishing
-
-5. Design server.js integration strategy
-   - Blocked by: Wave 1 item 1 (implementation verification)
-   - Blocks: Actual integration
+### Wave 2 (COMPLETE)
+✓ Pinata API keys: BLOCKED - not available, user needs to sign up at https://www.pinata.cloud/
+✓ Integration strategy designed - 150-200 line implementation, backward compatible, per-file iteration
 
 ### Wave 3 (Depends on Wave 2)
 6. Execute publish-models-to-ipfs.js to get real CIDs (if keys available)

package/database.js

@@ -400,13 +400,13 @@ try {
     console.log('[MODELS] Registered Whisper STT IPFS CID:', WHISPER_CID);
   }
 
-  const existingTTS = db.prepare('SELECT * FROM ipfs_cids WHERE modelName = ? AND modelType = ?').get('tts', 'voice');
+  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', 'voice', 'sha256-verified', LIGHTHOUSE_GATEWAY, Date.now(), Date.now());
+    ).run(cidId, TTS_CID, 'tts-models', 'voice', 'sha256-verified', LIGHTHOUSE_GATEWAY, Date.now(), Date.now());
     console.log('[MODELS] Registered TTS IPFS CID:', TTS_CID);
   }
 } catch (err) {

package/lib/download-metrics.js

@@ -0,0 +1,79 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const METRICS_PATH = path.join(os.homedir(), '.gmgui', 'models', '.metrics.json');
+
+export function recordMetric(metric) {
+  const metricsDir = path.dirname(METRICS_PATH);
+  if (!fs.existsSync(metricsDir)) {
+    fs.mkdirSync(metricsDir, { recursive: true });
+  }
+
+  let metrics = [];
+  if (fs.existsSync(METRICS_PATH)) {
+    try {
+      metrics = JSON.parse(fs.readFileSync(METRICS_PATH, 'utf8'));
+    } catch (e) {
+      metrics = [];
+    }
+  }
+
+  metrics.push({
+    ...metric,
+    timestamp: new Date().toISOString()
+  });
+
+  const oneDayAgo = Date.now() - 24 * 60 * 60 * 1000;
+  metrics = metrics.filter(m => new Date(m.timestamp).getTime() > oneDayAgo);
+
+  fs.writeFileSync(METRICS_PATH, JSON.stringify(metrics, null, 2));
+}
+
+export function getMetrics() {
+  if (!fs.existsSync(METRICS_PATH)) {
+    return [];
+  }
+  return JSON.parse(fs.readFileSync(METRICS_PATH, 'utf8'));
+}
+
+export function getMetricsSummary() {
+  const metrics = getMetrics();
+
+  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,
+      avg_latency: 0
+    }
+  };
+
+  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(
+      hfSuccess.reduce((sum, m) => sum + m.latency_ms, 0) / hfSuccess.length
+    );
+  }
+
+  return summary;
+}
+
+export function resetMetrics() {
+  if (fs.existsSync(METRICS_PATH)) {
+    fs.unlinkSync(METRICS_PATH);
+  }
+}

package/lib/file-verification.js

@@ -0,0 +1,26 @@
+import fs from 'fs';
+import crypto from 'crypto';
+
+export function verifyFileIntegrity(filepath, expectedHash, minBytes) {
+  if (!fs.existsSync(filepath)) {
+    return { valid: false, reason: 'file_not_found' };
+  }
+
+  const stats = fs.statSync(filepath);
+  if (minBytes && stats.size < minBytes) {
+    return { valid: false, reason: 'size_too_small', actual: stats.size, expected: minBytes };
+  }
+
+  if (expectedHash) {
+    const hash = crypto.createHash('sha256');
+    const data = fs.readFileSync(filepath);
+    hash.update(data);
+    const actualHash = hash.digest('hex');
+
+    if (actualHash !== expectedHash) {
+      return { valid: false, reason: 'hash_mismatch', actual: actualHash, expected: expectedHash };
+    }
+  }
+
+  return { valid: true };
+}

package/lib/model-downloader.js

@@ -1,8 +1,8 @@
 import { createRequire } from 'module';
 import fs from 'fs';
 import path from 'path';
-import crypto from 'crypto';
-import os from 'os';
+import { recordMetric } from './download-metrics.js';
+import { verifyFileIntegrity } from './file-verification.js';
 
 const require = createRequire(import.meta.url);
 
@@ -13,58 +13,6 @@ const GATEWAYS = [
   'https://ipfs.io/ipfs/'
 ];
 
-const METRICS_PATH = path.join(os.homedir(), '.gmgui', 'models', '.metrics.json');
-
-function recordMetric(metric) {
-  const metricsDir = path.dirname(METRICS_PATH);
-  if (!fs.existsSync(metricsDir)) {
-    fs.mkdirSync(metricsDir, { recursive: true });
-  }
-
-  let metrics = [];
-  if (fs.existsSync(METRICS_PATH)) {
-    try {
-      metrics = JSON.parse(fs.readFileSync(METRICS_PATH, 'utf8'));
-    } catch (e) {
-      metrics = [];
-    }
-  }
-
-  metrics.push({
-    ...metric,
-    timestamp: new Date().toISOString()
-  });
-
-  const oneDayAgo = Date.now() - 24 * 60 * 60 * 1000;
-  metrics = metrics.filter(m => new Date(m.timestamp).getTime() > oneDayAgo);
-
-  fs.writeFileSync(METRICS_PATH, JSON.stringify(metrics, null, 2));
-}
-
-function verifyFileIntegrity(filepath, expectedHash, minBytes) {
-  if (!fs.existsSync(filepath)) {
-    return { valid: false, reason: 'file_not_found' };
-  }
-
-  const stats = fs.statSync(filepath);
-  if (minBytes && stats.size < minBytes) {
-    return { valid: false, reason: 'size_too_small', actual: stats.size, expected: minBytes };
-  }
-
-  if (expectedHash) {
-    const hash = crypto.createHash('sha256');
-    const data = fs.readFileSync(filepath);
-    hash.update(data);
-    const actualHash = hash.digest('hex');
-
-    if (actualHash !== expectedHash) {
-      return { valid: false, reason: 'hash_mismatch', actual: actualHash, expected: expectedHash };
-    }
-  }
-
-  return { valid: true };
-}
-
 async function downloadFromIPFS(cid, destPath, manifest, onProgress) {
   const startTime = Date.now();
 
@@ -239,50 +187,4 @@ export async function downloadWithFallback(options, onProgress) {
   throw new Error('All download layers exhausted');
 }
 
-export function getMetrics() {
-  if (!fs.existsSync(METRICS_PATH)) {
-    return [];
-  }
-  return JSON.parse(fs.readFileSync(METRICS_PATH, 'utf8'));
-}
-
-export function getMetricsSummary() {
-  const metrics = getMetrics();
-
-  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,
-      avg_latency: 0
-    }
-  };
-
-  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(
-      hfSuccess.reduce((sum, m) => sum + m.latency_ms, 0) / hfSuccess.length
-    );
-  }
-
-  return summary;
-}
-
-export function resetMetrics() {
-  if (fs.existsSync(METRICS_PATH)) {
-    fs.unlinkSync(METRICS_PATH);
-  }
-}
+export { getMetrics, getMetricsSummary, resetMetrics } from './download-metrics.js';

package/package.json

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

package/server.js

@@ -14,6 +14,7 @@ import Busboy from 'busboy';
 import fsbrowse from 'fsbrowse';
 import { queries } from './database.js';
 import { runClaudeWithStreaming } from './lib/claude-runner.js';
+import { downloadWithFallback } from './lib/model-downloader.js';
 const { downloadWithProgress } = createRequire(import.meta.url)('webtalk/ipfs-downloader');
 
 const ttsTextAccumulators = new Map();
@@ -77,39 +78,70 @@ async function ensureModelsDownloaded() {
       ? (fs.existsSync(path.join(process.env.PORTABLE_EXE_DIR, 'models', 'onnx-community')) ? path.join(process.env.PORTABLE_EXE_DIR, 'models') : gmguiModels)
       : gmguiModels;
 
-    const { ensureModels } = createRequire(import.meta.url)('webtalk/ipfs-downloader');
-    const { createConfig } = createRequire(import.meta.url)('webtalk/config');
-    const config = createConfig({
-      modelsDir: modelsBase,
-      ttsModelsDir: path.join(modelsBase, 'tts'),
-      sttModelsDir: path.join(modelsBase, 'stt'),
-    });
+    const manifestPath = path.join(gmguiModels, '.manifests.json');
+    if (!fs.existsSync(manifestPath)) {
+      throw new Error('Model manifest not found at ' + manifestPath);
+    }
 
-    const { checkTTSModelExists } = createRequire(import.meta.url)('webtalk/tts-models');
-    const { checkWhisperModelExists } = createRequire(import.meta.url)('webtalk/whisper-models');
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
 
-    const sttOk = await checkWhisperModelExists(config.defaultWhisperModel, config).catch(() => false);
-    const ttsOk = await checkTTSModelExists(config).catch(() => false);
-
-    if (sttOk && ttsOk) {
-      console.log('[MODELS] All model files present');
-      modelDownloadState.complete = true;
-      return true;
-    }
+    const whisperCidRecord = queries.getIpfsCidByModel('whisper-base', 'stt');
+    const ttsCidRecord = queries.getIpfsCidByModel('tts', 'voice');
 
     modelDownloadState.downloading = true;
     modelDownloadState.error = null;
 
-    await ensureModels(config, (progress) => {
-      broadcastModelProgress({
-        started: true,
-        done: progress.done || false,
-        downloading: progress.status === 'downloading',
-        type: progress.type,
-        source: 'ipfs',
-        ...progress,
-      });
-    });
+    const downloadModel = async (modelName, modelType, cidRecord) => {
+      const modelManifest = manifest[modelName];
+      if (!modelManifest) {
+        throw new Error(`Model ${modelName} not found in manifest`);
+      }
+
+      const isWhisper = modelType === 'stt';
+      const baseDir = isWhisper
+        ? path.join(modelsBase, 'onnx-community', 'whisper-base')
+        : path.join(modelsBase, 'tts');
+
+      fs.mkdirSync(baseDir, { recursive: true });
+
+      for (const [filename, fileInfo] of Object.entries(modelManifest.files)) {
+        const destPath = path.join(baseDir, filename);
+
+        if (fs.existsSync(destPath) && fs.statSync(destPath).size === fileInfo.size) {
+          console.log(`[MODELS] ${filename} already exists, skipping`);
+          continue;
+        }
+
+        const ipfsCid = cidRecord ? `${cidRecord.cid}/${filename}` : null;
+        const huggingfaceUrl = isWhisper
+          ? `https://huggingface.co/onnx-community/whisper-base/resolve/main/${filename}`
+          : `https://huggingface.co/datasets/AnEntrypoint/sttttsmodels/resolve/main/tts/${filename}`;
+
+        await downloadWithFallback({
+          ipfsCid,
+          huggingfaceUrl,
+          destPath,
+          manifest: fileInfo,
+          minBytes: fileInfo.size * 0.8,
+          preferredLayer: ipfsCid ? 'ipfs' : 'huggingface'
+        }, (progress) => {
+          broadcastModelProgress({
+            started: true,
+            done: progress.status === 'success',
+            downloading: progress.status === 'downloading',
+            type: modelType === 'stt' ? 'whisper' : 'tts',
+            source: progress.layer === 'cache' ? 'cache' : progress.layer,
+            status: progress.status,
+            file: filename,
+            progress: progress.total ? (progress.downloaded / progress.total * 100) : 0,
+            gateway: progress.gateway
+          });
+        });
+      }
+    };
+
+    await downloadModel('whisper-base', 'stt', whisperCidRecord);
+    await downloadModel('tts-models', 'voice', ttsCidRecord);
 
     modelDownloadState.complete = true;
     broadcastModelProgress({ started: true, done: true, downloading: false });

package/static/index.html

@@ -727,6 +727,26 @@
     ::-webkit-scrollbar-thumb { background-color: var(--color-border); border-radius: 3px; }
     ::-webkit-scrollbar-thumb:hover { background-color: var(--color-text-tertiary); }
 
+    /* DIALOGS */
+    .dialog-overlay { position: fixed; inset: 0; display: flex; align-items: center; justify-content: center; }
+    .dialog-backdrop { position: absolute; inset: 0; background: rgba(0,0,0,0.5); }
+    .dialog-box { position: fixed; top: 50%; left: 50%; transform: translate(-50%,-50%); background: var(--color-bg-secondary); border: 1px solid var(--color-border); border-radius: 8px; padding: 24px; min-width: 320px; max-width: 480px; box-shadow: 0 8px 32px rgba(0,0,0,0.2); }
+    .dialog-box h3, .dialog-box .dialog-title { font-size: 1rem; font-weight: 600; margin-bottom: 12px; color: var(--color-text-primary); }
+    .dialog-box p, .dialog-box .dialog-message { color: var(--color-text-secondary); margin-bottom: 16px; font-size: 0.875rem; }
+    .dialog-box input, .dialog-box textarea { width: 100%; padding: 8px 12px; border: 1px solid var(--color-border); border-radius: 6px; background: var(--color-bg-tertiary); color: var(--color-text-primary); font-size: 0.875rem; margin-bottom: 16px; }
+    .dialog-footer { display: flex; gap: 8px; justify-content: flex-end; }
+    .dialog-btn { padding: 6px 16px; border-radius: 6px; border: 1px solid var(--color-border); background: var(--color-bg-tertiary); color: var(--color-text-primary); cursor: pointer; font-size: 0.875rem; }
+    .dialog-btn-primary { background: var(--color-primary); border-color: var(--color-primary); color: #fff; }
+    .dialog-btn:hover { opacity: 0.85; }
+    .dialog-box-progress .dialog-progress-bar { height: 4px; background: var(--color-border); border-radius: 2px; overflow: hidden; margin-bottom: 8px; }
+    .dialog-box-progress .dialog-progress-fill { height: 100%; background: var(--color-primary); transition: width 0.3s; }
+
+    /* TOOL ICONS */
+    .folded-tool-icon { display: inline-flex; align-items: center; flex-shrink: 0; }
+    .folded-tool-icon svg { width: 16px; height: 16px; flex-shrink: 0; }
+    .folded-tool-bar { display: flex; align-items: center; gap: 6px; }
+    .tool-result-status { display: flex; align-items: center; gap: 6px; }
+
     /* RESPONSIVE */
     @media (max-width: 768px) {
       .sidebar {