agentgui 1.0.836 → 1.0.837

package/lib/asset-server.js

@@ -0,0 +1,145 @@
+import fs from 'fs';
+import path from 'path';
+import zlib from 'zlib';
+import { LRUCache } from 'lru-cache';
+
+const MIME_TYPES = { '.html': 'text/html; charset=utf-8', '.js': 'application/javascript; charset=utf-8', '.css': 'text/css; charset=utf-8', '.json': 'application/json', '.png': 'image/png', '.jpg': 'image/jpeg', '.svg': 'image/svg+xml' };
+
+export const _assetCache = new LRUCache({ max: 200 });
+export const htmlState = { cache: null, etag: null };
+
+export function generateETag(stats) {
+  return `"${stats.mtimeMs.toString(36)}-${stats.size.toString(36)}"`;
+}
+
+export function warmAssetCache(staticDir) {
+  const dirs = ['js', 'css', 'lib', 'vendor'];
+  let count = 0;
+  for (const dir of dirs) {
+    const full = path.join(staticDir, dir);
+    if (!fs.existsSync(full)) continue;
+    for (const file of fs.readdirSync(full)) {
+      const filePath = path.join(full, file);
+      try {
+        const stats = fs.statSync(filePath);
+        if (!stats.isFile()) continue;
+        const etag = generateETag(stats);
+        if (_assetCache.has(etag)) continue;
+        const raw = fs.readFileSync(filePath);
+        _assetCache.set(etag, raw.length < 860 ? { raw, gz: null } : { raw, gz: zlib.gzipSync(raw, { level: 6 }) });
+        count++;
+      } catch (_) {}
+    }
+  }
+  for (const file of ['app.js', 'theme.js']) {
+    const filePath = path.join(staticDir, file);
+    try {
+      const stats = fs.statSync(filePath);
+      const etag = generateETag(stats);
+      if (!_assetCache.has(etag)) {
+        const raw = fs.readFileSync(filePath);
+        _assetCache.set(etag, raw.length < 860 ? { raw, gz: null } : { raw, gz: zlib.gzipSync(raw, { level: 6 }) });
+        count++;
+      }
+    } catch (_) {}
+  }
+  if (count > 0) console.log(`[CACHE] Pre-warmed ${count} static assets`);
+}
+
+export function serveFile(filePath, res, req, { compressAndSend, acceptsEncoding, watch, BASE_URL, PKG_VERSION }) {
+  const ext = path.extname(filePath).toLowerCase();
+  const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+
+  if (ext !== '.html') {
+    fs.stat(filePath, (err, stats) => {
+      if (err) { res.writeHead(500); res.end('Server error'); return; }
+      const etag = generateETag(stats);
+      if (req && req.headers['if-none-match'] === etag) { res.writeHead(304); res.end(); return; }
+      const cacheControl = 'public, no-cache';
+      const sendCached = (cached) => {
+        if (acceptsEncoding(req, 'gzip') && cached.gz) {
+          res.writeHead(200, { 'Content-Type': contentType, 'Content-Encoding': 'gzip', 'Content-Length': cached.gz.length, 'ETag': etag, 'Cache-Control': cacheControl });
+          res.end(cached.gz);
+        } else {
+          res.writeHead(200, { 'Content-Type': contentType, 'Content-Length': cached.raw.length, 'ETag': etag, 'Cache-Control': cacheControl });
+          res.end(cached.raw);
+        }
+      };
+      const cached = _assetCache.get(etag);
+      if (cached) { sendCached(cached); return; }
+      fs.readFile(filePath, (err2, raw) => {
+        if (err2) { res.writeHead(500); res.end('Server error'); return; }
+        if (raw.length < 860) { const entry = { raw, gz: null }; _assetCache.set(etag, entry); sendCached(entry); return; }
+        const gz = zlib.gzipSync(raw, { level: 6 });
+        const entry = { raw, gz };
+        _assetCache.set(etag, entry);
+        sendCached(entry);
+      });
+    });
+    return;
+  }
+
+  fs.stat(filePath, (err, stats) => {
+    if (err) { res.writeHead(500); res.end('Server error'); return; }
+    const etag = generateETag(stats);
+    if (!watch && htmlState.cache && htmlState.etag === etag) {
+      res.writeHead(200, { 'Content-Type': contentType, 'Cache-Control': 'no-store', 'Content-Encoding': 'gzip', 'Content-Length': htmlState.cache.length });
+      res.end(htmlState.cache);
+      return;
+    }
+    fs.readFile(filePath, (err2, data) => {
+      if (err2) { res.writeHead(500); res.end('Server error'); return; }
+      let content = data.toString();
+      const wsToken = process.env.PASSWORD ? `window.__WS_TOKEN='${process.env.PASSWORD.replace(/'/g, "\\'")}';` : '';
+      const baseTag = `<script>window.__BASE_URL='${BASE_URL}';window.__SERVER_VERSION='${PKG_VERSION}';${wsToken}</script>`;
+      content = content.replace('<head>', `<head>\n  <base href="${BASE_URL}/">\n  ` + baseTag);
+      content = content.replace(/(href|src)="vendor\//g, `$1="${BASE_URL}/vendor/`);
+      content = content.replace(/(src)="\/gm\/js\//g, `$1="${BASE_URL}/js/`);
+      if (watch) {
+        content += `\n<script>(function(){const ws=new WebSocket((location.protocol==='https:'?'wss://':'ws://')+location.host+'${BASE_URL}/hot-reload');ws.onmessage=e=>{if(JSON.parse(e.data).type==='reload')location.reload()};})();</script>`;
+      }
+      compressAndSend(req, res, 200, contentType, content);
+      if (!watch && acceptsEncoding(req, 'gzip')) {
+        htmlState.cache = zlib.gzipSync(Buffer.from(content), { level: 6 });
+        htmlState.etag = etag;
+      }
+    });
+  });
+}
+
+export function createChunkBatcher(queries, debugLog) {
+  const pending = [];
+  let timer = null;
+  const BATCH_SIZE = 10;
+  const BATCH_INTERVAL = 50;
+
+  function flush() {
+    if (pending.length === 0) return;
+    const batch = pending.splice(0);
+    try {
+      const tx = queries._db ? queries._db.transaction(() => {
+        for (const c of batch) queries.createChunk(c.sessionId, c.conversationId, c.sequence, c.type, c.data);
+      }) : null;
+      if (tx) { tx(); } else {
+        for (const c of batch) {
+          try { queries.createChunk(c.sessionId, c.conversationId, c.sequence, c.type, c.data); } catch (e) { debugLog(`[chunk] ${e.message}`); }
+        }
+      }
+    } catch (err) {
+      debugLog(`[chunk-batch] Batch write failed: ${err.message}`);
+      for (const c of batch) {
+        try { queries.createChunk(c.sessionId, c.conversationId, c.sequence, c.type, c.data); } catch (_) {}
+      }
+    }
+  }
+
+  function add(sessionId, conversationId, sequence, blockType, blockData) {
+    pending.push({ sessionId, conversationId, sequence, type: blockType, data: blockData });
+    if (pending.length >= BATCH_SIZE) { if (timer) { clearTimeout(timer); timer = null; } flush(); }
+    else if (!timer) { timer = setTimeout(() => { timer = null; flush(); }, BATCH_INTERVAL); }
+  }
+
+  function drain() { if (timer) { clearTimeout(timer); timer = null; } flush(); }
+
+  return { add, drain };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.836",
+  "version": "1.0.837",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",

package/server.js

@@ -1706,7 +1706,7 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
   execMachine.send(conversationId, { type: 'START', sessionId });
   queries.setIsStreaming(conversationId, true);
   queries.updateSession(sessionId, { status: 'active' });
-  const batcher = createChunkBatcher();
+  const batcher = createChunkBatcher(queries, debugLog);
 
   try {
     debugLog(`[stream] Starting: conversationId=${conversationId}, sessionId=${sessionId}`);
@@ -2757,8 +2757,8 @@ if (watch) {
       fs.watchFile(fp, { interval: 100 }, (curr, prev) => {
         if (curr.mtime > prev.mtime) {
           _assetCache.clear();
-          _htmlCache = null;
-          _htmlCacheEtag = null;
+          htmlState.cache = null;
+          htmlState.etag = null;
           hotReloadClients.forEach(c => { if (c.readyState === 1) c.send(JSON.stringify({ type: 'reload' })); });
         }
       });
@@ -2821,7 +2821,7 @@ function onServerReady() {
   }
 
   recoverStaleSessions();
-  warmAssetCache();
+  warmAssetCache(staticDir);
 
   // Run DB cleanup on startup and every 6 hours
   try { queries.cleanup(); console.log('[cleanup] Initial DB cleanup complete'); } catch (e) { console.error('[cleanup] Error:', e.message); }