agentgui 1.0.652 → 1.0.654

package/package.json

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

package/server.js

@@ -302,7 +302,6 @@ const rateLimitState = new Map();
 const activeProcessesByRunId = new Map();
 const activeProcessesByConvId = new Map(); // Store process handles by conversationId for steering
 const steeringTimeouts = new Map(); // Track timeout handles for process cleanup
-const acpQueries = queries;
 const checkpointManager = new CheckpointManager(queries);
 const STUCK_AGENT_THRESHOLD_MS = 600000;
 const NO_PID_GRACE_PERIOD_MS = 60000;
@@ -1592,115 +1591,6 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
-    const oldRunByIdMatch = pathOnly.match(/^\/api\/runs\/([^/]+)$/);
-    if (oldRunByIdMatch) {
-    const runId = oldRunByIdMatch[1];
-      const session = queries.getSession(runId);
-      
-      if (!session) {
-        sendJSON(req, res, 404, { error: 'Run not found' });
-        return;
-      }
-
-      if (req.method === 'GET') {
-        sendJSON(req, res, 200, {
-          id: session.id,
-          status: session.status,
-          started_at: session.started_at,
-          completed_at: session.completed_at,
-          agentId: session.agentId,
-          input: null,
-          output: null
-        });
-        return;
-      }
-
-      if (req.method === 'DELETE') {
-        queries.deleteSession(runId);
-        sendJSON(req, res, 204, {});
-        return;
-      }
-
-      if (req.method === 'POST') {
-        if (session.status !== 'interrupted') {
-          sendJSON(req, res, 409, { error: 'Can only resume interrupted runs' });
-          return;
-        }
-
-        let body = '';
-        for await (const chunk of req) { body += chunk; }
-        let parsed = {};
-        try { parsed = body ? JSON.parse(body) : {}; } catch {}
-
-        const { input } = parsed;
-        if (!input) {
-          sendJSON(req, res, 400, { error: 'Missing input in request body' });
-          return;
-        }
-
-        const conv = queries.getConversation(session.conversationId);
-        const resolvedAgentId = session.agentId || conv?.agentId || 'claude-code';
-        const resolvedModel = conv?.model || null;
-        const cwd = conv?.workingDirectory || STARTUP_CWD;
-
-        queries.updateSession(runId, { status: 'pending' });
-        
-        const message = queries.createMessage(session.conversationId, 'user', typeof input === 'string' ? input : JSON.stringify(input));
-
-        processMessageWithStreaming(session.conversationId, message.id, runId, typeof input === 'string' ? input : JSON.stringify(input), resolvedAgentId, resolvedModel);
-
-        sendJSON(req, res, 200, {
-          id: session.id,
-          status: 'pending',
-          started_at: session.started_at,
-          agentId: resolvedAgentId
-        });
-        return;
-      }
-    }
-
-    const oldRunCancelMatch = pathOnly.match(/^\/api\/runs\/([^/]+)\/cancel$/);
-    if (oldRunCancelMatch && req.method === 'POST') {
-      const runId = oldRunCancelMatch[1];
-      const session = queries.getSession(runId);
-      
-      if (!session) {
-        sendJSON(req, res, 404, { error: 'Run not found' });
-        return;
-      }
-
-      const conversationId = session.conversationId;
-      const entry = activeExecutions.get(conversationId);
-      
-      if (entry && entry.sessionId === runId) {
-        const { pid } = entry;
-        if (pid) {
-          try {
-            process.kill(-pid, 'SIGKILL');
-          } catch {
-            try {
-              process.kill(pid, 'SIGKILL');
-            } catch (e) {}
-          }
-        }
-      }
-
-      queries.updateSession(runId, { status: 'interrupted', completed_at: Date.now() });
-      queries.setIsStreaming(conversationId, false);
-      activeExecutions.delete(conversationId);
-
-      broadcastSync({
-        type: 'streaming_complete',
-        sessionId: runId,
-        conversationId,
-        interrupted: true,
-        timestamp: Date.now()
-      });
-
-      sendJSON(req, res, 204, {});
-      return;
-    }
-
     const scriptsMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/scripts$/);
     if (scriptsMatch && req.method === 'GET') {
       const conv = queries.getConversation(scriptsMatch[1]);
@@ -2318,13 +2208,13 @@ const server = http.createServer(async (req, res) => {
     if (modelsMatch && req.method === 'GET') {
       const agentId = modelsMatch[1];
       const cached = modelCache.get(agentId);
-      if (cached && (Date.now() - cached.ts) < 300000) {
+      if (cached && (Date.now() - cached.timestamp) < 300000) {
         sendJSON(req, res, 200, { models: cached.models });
         return;
       }
       try {
         const models = await getModelsForAgent(agentId);
-        modelCache.set(agentId, { models, ts: Date.now() });
+        modelCache.set(agentId, { models, timestamp: Date.now() });
         sendJSON(req, res, 200, { models });
       } catch (err) {
         sendJSON(req, res, 200, { models: [] });
@@ -3597,6 +3487,21 @@ function createChunkBatcher() {
   return { add, drain };
 }
 
+function parseRateLimitResetTime(text) {
+  const match = text.match(/resets?\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*\(?(UTC|[A-Z]{2,4})\)?/i);
+  if (!match) return 300;
+  let hours = parseInt(match[1], 10);
+  const minutes = match[2] ? parseInt(match[2], 10) : 0;
+  const period = match[3]?.toLowerCase();
+  if (period === 'pm' && hours !== 12) hours += 12;
+  if (period === 'am' && hours === 12) hours = 0;
+  const now = new Date();
+  const resetTime = new Date(now);
+  resetTime.setUTCHours(hours, minutes, 0, 0);
+  if (resetTime <= now) resetTime.setUTCDate(resetTime.getUTCDate() + 1);
+  return Math.max(60, Math.ceil((resetTime.getTime() - now.getTime()) / 1000));
+}
+
 async function processMessageWithStreaming(conversationId, messageId, sessionId, content, agentId, model, subAgent) {
   const startTime = Date.now();
   touchACP(agentId);
@@ -3700,28 +3605,8 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
             if (rateLimitTextMatch) {
               debugLog(`[rate-limit] Detected rate limit message in stream for conv ${conversationId}`);
               
-              // Extract reset time from message
-              let retryAfterSec = 300; // default 5 minutes
-              const resetTimeMatch = block.text.match(/resets?\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*\(?(UTC|[A-Z]{2,4})\)?/i);
-              if (resetTimeMatch) {
-                let hours = parseInt(resetTimeMatch[1], 10);
-                const minutes = resetTimeMatch[2] ? parseInt(resetTimeMatch[2], 10) : 0;
-                const period = resetTimeMatch[3]?.toLowerCase();
-                
-                if (period === 'pm' && hours !== 12) hours += 12;
-                if (period === 'am' && hours === 12) hours = 0;
-                
-                const now = new Date();
-                const resetTime = new Date(now);
-                resetTime.setUTCHours(hours, minutes, 0, 0);
-                
-                if (resetTime <= now) {
-                  resetTime.setUTCDate(resetTime.getUTCDate() + 1);
-                }
-                
-                retryAfterSec = Math.max(60, Math.ceil((resetTime.getTime() - now.getTime()) / 1000));
-                debugLog(`[rate-limit] Parsed reset time: ${resetTime.toISOString()}, retry in ${retryAfterSec}s`);
-              }
+              const retryAfterSec = parseRateLimitResetTime(block.text);
+              debugLog(`[rate-limit] Parsed reset time, retry in ${retryAfterSec}s`);
               
               // Kill the running process
               const entry = activeExecutions.get(conversationId);
@@ -3833,26 +3718,7 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
           if (rateLimitResultMatch) {
             debugLog(`[rate-limit] Detected rate limit in result for conv ${conversationId}`);
             
-            let retryAfterSec = 300;
-            const resetTimeMatch = resultText.match(/resets?\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*\(?(UTC|[A-Z]{2,4})\)?/i);
-            if (resetTimeMatch) {
-              let hours = parseInt(resetTimeMatch[1], 10);
-              const minutes = resetTimeMatch[2] ? parseInt(resetTimeMatch[2], 10) : 0;
-              const period = resetTimeMatch[3]?.toLowerCase();
-              
-              if (period === 'pm' && hours !== 12) hours += 12;
-              if (period === 'am' && hours === 12) hours = 0;
-              
-              const now = new Date();
-              const resetTime = new Date(now);
-              resetTime.setUTCHours(hours, minutes, 0, 0);
-              
-              if (resetTime <= now) {
-                resetTime.setUTCDate(resetTime.getUTCDate() + 1);
-              }
-              
-              retryAfterSec = Math.max(60, Math.ceil((resetTime.getTime() - now.getTime()) / 1000));
-            }
+            const retryAfterSec = parseRateLimitResetTime(resultText);
             
             const entry = activeExecutions.get(conversationId);
             if (entry && entry.pid) {

package/static/index.html

@@ -3245,6 +3245,7 @@
     var _escHtmlRe = /[&<>"']/g;
     window._escHtml = function(t) { return t.replace(_escHtmlRe, function(c) { return _escHtmlMap[c]; }); };
   </script>
+  <script defer src="/gm/js/conversations.js"></script>
   <script defer src="/gm/js/event-processor.js"></script>
   <script defer src="/gm/js/streaming-renderer.js"></script>
   <script defer src="/gm/js/image-loader.js"></script>
@@ -3252,12 +3253,10 @@
   <script defer src="/gm/js/event-consolidator.js"></script>
   <script defer src="/gm/js/websocket-manager.js"></script>
   <script defer src="/gm/js/ws-client.js"></script>
-  <script defer src="/gm/js/event-filter.js"></script>
-  <script defer src="/gm/js/syntax-highlighter.js"></script>
+<script defer src="/gm/js/syntax-highlighter.js"></script>
   <script defer src="/gm/js/dialogs.js"></script>
   <script defer src="/gm/js/ui-components.js"></script>
   <script defer src="/gm/js/state-barrier.js"></script>
-   <script defer src="/gm/js/conversations.js"></script>
    <script defer src="/gm/js/terminal.js"></script>
    <script defer src="/gm/js/script-runner.js"></script>
    <script defer src="/gm/js/tools-manager.js"></script>

package/static/js/dialogs.js

@@ -2,10 +2,7 @@
   var activeDialogs = [];
   var dialogZIndex = 10000;
 
-  function escapeHtml(text) {
-    var map = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' };
-    return String(text).replace(/[&<>"']/g, function(c) { return map[c]; });
-  }
+  function escapeHtml(text) { return window._escHtml(text); }
 
   function createOverlay() {
     var overlay = document.createElement('div');

package/static/js/event-processor.js

@@ -1,71 +1,10 @@
-/**
- * Event Processor
- * Transforms, validates, and enriches streaming events
- * Handles ANSI colors, markdown, diffs, and other data transformations
- */
-
 class EventProcessor {
   constructor(config = {}) {
     this.config = {
       enableSyntaxHighlight: config.enableSyntaxHighlight !== false,
-      enableMarkdown: config.enableMarkdown !== false,
-      enableANSI: config.enableANSI !== false,
-      maxContentLength: config.maxContentLength || 100000,
       ...config
     };
 
-    // ANSI color codes mapping
-    this.ansiCodes = {
-      reset: '\x1b[0m',
-      bold: '\x1b[1m',
-      dim: '\x1b[2m',
-      italic: '\x1b[3m',
-      underline: '\x1b[4m',
-      blink: '\x1b[5m',
-      reverse: '\x1b[7m',
-      hidden: '\x1b[8m',
-      strikethrough: '\x1b[9m',
-      // Foreground colors
-      black: '\x1b[30m',
-      red: '\x1b[31m',
-      green: '\x1b[32m',
-      yellow: '\x1b[33m',
-      blue: '\x1b[34m',
-      magenta: '\x1b[35m',
-      cyan: '\x1b[36m',
-      white: '\x1b[37m',
-      // Background colors
-      bgBlack: '\x1b[40m',
-      bgRed: '\x1b[41m',
-      bgGreen: '\x1b[42m',
-      bgYellow: '\x1b[43m',
-      bgBlue: '\x1b[44m',
-      bgMagenta: '\x1b[45m',
-      bgCyan: '\x1b[46m',
-      bgWhite: '\x1b[47m'
-    };
-
-    // CSS color mapping
-    this.colorMap = {
-      '30': '#000000', // black
-      '31': '#ff6b6b', // red
-      '32': '#51cf66', // green
-      '33': '#ffd43b', // yellow
-      '34': '#4dabf7', // blue
-      '35': '#da77f2', // magenta
-      '36': '#20c997', // cyan
-      '37': '#ffffff', // white
-      '90': '#666666', // bright black
-      '91': '#ff8787', // bright red
-      '92': '#69db7c', // bright green
-      '93': '#ffe066', // bright yellow
-      '94': '#74c0fc', // bright blue
-      '95': '#e599f7', // bright magenta
-      '96': '#38f9d7', // bright cyan
-      '97': '#f8f9fa'  // bright white
-    };
-
-    // Statistics
     this.stats = {
       totalEvents: 0,
       processedEvents: 0,
@@ -103,29 +42,13 @@ class EventProcessor {
         processTime: 0
       };
 
-      // Transform event based on type
-      if (event.type === 'text_block' || event.type === 'code_block') {
-        processed.content = this.transformContent(event.content || '', event.type);
-        this.stats.transformedEvents++;
-      }
-
-      if (event.type === 'command_execute' && event.output) {
-        processed.output = this.transformANSI(event.output);
-        this.stats.transformedEvents++;
-      }
-
-      if (event.type === 'file_diff' || event.type === 'git_diff') {
-        processed.diff = this.transformDiff(event.diff || event.content || '');
-        this.stats.transformedEvents++;
-      }
-
       if (event.type === 'file_read' && event.path && this.isImagePath(event.path)) {
         processed.isImage = true;
         processed.imagePath = event.path;
         this.stats.transformedEvents++;
       }
 
-      if ((event.type === 'text_block' || event.type === 'command_execute' || event.type === 'streaming_progress') && event.content || event.output) {
+      if ((event.type === 'text_block' || event.type === 'command_execute' || event.type === 'streaming_progress') && (event.content || event.output)) {
         const imagePaths = this.extractImagePaths(event.content || event.output || '');
         if (imagePaths.length > 0) {
           processed.detectedImages = imagePaths;
@@ -178,151 +101,6 @@ class EventProcessor {
     return true;
   }
 
-  /**
-   * Transform content based on type
-   */
-  transformContent(content, type) {
-    if (typeof content !== 'string') {
-      return content;
-    }
-
-    if (content.length > this.config.maxContentLength) {
-      return content.substring(0, this.config.maxContentLength) + '\n... (truncated)';
-    }
-
-    return content;
-  }
-
-  /**
-   * Transform ANSI escape codes to HTML/CSS
-   */
-  transformANSI(text) {
-    if (!this.config.enableANSI || typeof text !== 'string') {
-      return text;
-    }
-
-    let result = '';
-    let currentStyle = { fg: null, bg: null, bold: false };
-    const stack = [];
-
-    // Pattern for ANSI escape sequences
-    const pattern = /\x1b\[([0-9;]*?)m/g;
-    let lastIndex = 0;
-    let match;
-
-    while ((match = pattern.exec(text)) !== null) {
-      // Add text before this escape sequence
-      if (match.index > lastIndex) {
-        const plainText = text.substring(lastIndex, match.index);
-        result += this.escapeHtml(plainText);
-      }
-
-      // Parse ANSI code
-      const codes = match[1].split(';').map(c => parseInt(c, 10));
-      for (const code of codes) {
-        if (code === 0) {
-          // Reset
-          currentStyle = { fg: null, bg: null, bold: false };
-        } else if (code === 1) {
-          currentStyle.bold = true;
-        } else if (code >= 30 && code <= 37) {
-          currentStyle.fg = this.colorMap[code];
-        } else if (code >= 40 && code <= 47) {
-          currentStyle.bg = this.colorMap[String(code - 10)];
-        } else if (code >= 90 && code <= 97) {
-          currentStyle.fg = this.colorMap[code];
-        }
-      }
-
-      lastIndex = pattern.lastIndex;
-    }
-
-    // Add remaining text
-    if (lastIndex < text.length) {
-      result += this.escapeHtml(text.substring(lastIndex));
-    }
-
-    return result;
-  }
-
-  /**
-   * Transform unified diff format
-   */
-  transformDiff(diffText) {
-    if (typeof diffText !== 'string') {
-      return diffText;
-    }
-
-    const lines = diffText.split('\n');
-    const parsed = {
-      headers: [],
-      hunks: []
-    };
-
-    let currentHunk = null;
-
-    for (const line of lines) {
-      if (line.startsWith('---') || line.startsWith('+++')) {
-        parsed.headers.push(line);
-      } else if (line.startsWith('@@')) {
-        if (currentHunk) {
-          parsed.hunks.push(currentHunk);
-        }
-        currentHunk = {
-          header: line,
-          changes: []
-        };
-      } else if (currentHunk) {
-        if (line.startsWith('-')) {
-          currentHunk.changes.push({ type: 'deleted', line: line.substring(1) });
-        } else if (line.startsWith('+')) {
-          currentHunk.changes.push({ type: 'added', line: line.substring(1) });
-        } else if (line.startsWith(' ')) {
-          currentHunk.changes.push({ type: 'context', line: line.substring(1) });
-        }
-      }
-    }
-
-    if (currentHunk) {
-      parsed.hunks.push(currentHunk);
-    }
-
-    return parsed;
-  }
-
-  /**
-   * Convert markdown to HTML (simple implementation)
-   */
-  transformMarkdown(markdown) {
-    if (!this.config.enableMarkdown || typeof markdown !== 'string') {
-      return markdown;
-    }
-
-    let html = this.escapeHtml(markdown);
-
-    // Bold
-    html = html.replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>');
-
-    // Italic
-    html = html.replace(/\*(.+?)\*/g, '<em>$1</em>');
-
-    // Code
-    html = html.replace(/`(.+?)`/g, '<code>$1</code>');
-
-    // Links
-    html = html.replace(/\[(.+?)\]\((.+?)\)/g, '<a href="$2" target="_blank">$1</a>');
-
-    // Headings
-    html = html.replace(/^### (.+)$/gm, '<h3>$1</h3>');
-    html = html.replace(/^## (.+)$/gm, '<h2>$1</h2>');
-    html = html.replace(/^# (.+)$/gm, '<h1>$1</h1>');
-
-    // Line breaks
-    html = html.replace(/\n/g, '<br>');
-
-    return html;
-  }
-
   /**
    * Detect language from content or hint
    */
@@ -379,40 +157,6 @@ class EventProcessor {
     return match ? match[1].toLowerCase() : null;
   }
 
-  /**
-   * Determine syntax highlighter language from file extension
-   */
-  getLanguageFromExtension(ext) {
-    const extMap = {
-      'js': 'javascript',
-      'jsx': 'jsx',
-      'ts': 'typescript',
-      'tsx': 'typescript',
-      'py': 'python',
-      'java': 'java',
-      'cpp': 'cpp',
-      'c': 'c',
-      'cs': 'csharp',
-      'php': 'php',
-      'rb': 'ruby',
-      'go': 'go',
-      'rs': 'rust',
-      'json': 'json',
-      'xml': 'xml',
-      'html': 'html',
-      'css': 'css',
-      'scss': 'scss',
-      'yaml': 'yaml',
-      'yml': 'yaml',
-      'sql': 'sql',
-      'sh': 'bash',
-      'bash': 'bash',
-      'zsh': 'bash'
-    };
-
-    return extMap[ext?.toLowerCase()] || 'plaintext';
-  }
-
   /**
    * Truncate text with ellipsis
    */

package/static/js/streaming-renderer.js

@@ -4,15 +4,6 @@
  * for Claude Code streaming execution display
  */
 
-function pathSplit(p) {
-  return p.split(/[\/\\]/).filter(Boolean);
-}
-
-function pathBasename(p) {
-  const parts = pathSplit(p);
-  return parts.length ? parts.pop() : '';
-}
-
 class StreamingRenderer {
   constructor(config = {}) {
     // Configuration

package/static/js/sync-debug.js

@@ -133,16 +133,14 @@ class SyncDebugger {
   }
 }
 
-// Create global instance
-window.syncDebugger = new SyncDebugger();
-
-// Expose commands
-window.debugSync = {
-  enable: () => window.syncDebugger.enable(),
-  disable: () => window.syncDebugger.disable(),
-  report: () => window.syncDebugger.printReport(),
-  clear: () => window.syncDebugger.clearLogs(),
-  get: () => window.syncDebugger.getReport()
-};
-
-console.log('[SyncDebug] Available. Use: debugSync.enable(), debugSync.report(), debugSync.clear()');
+if (window.__DEBUG__) {
+  window.syncDebugger = new SyncDebugger();
+  window.debugSync = {
+    enable: () => window.syncDebugger.enable(),
+    disable: () => window.syncDebugger.disable(),
+    report: () => window.syncDebugger.printReport(),
+    clear: () => window.syncDebugger.clearLogs(),
+    get: () => window.syncDebugger.getReport()
+  };
+  console.log('[SyncDebug] Available. Use: debugSync.enable(), debugSync.report(), debugSync.clear()');
+}

package/lib/compressor.js

@@ -1,125 +0,0 @@
-/**
- * Compressor: tokenize text fields → msgpackr → optional gzip
- *
- * Transport:  event → msgpackr.pack() → gzip if >512B → binary WS frame
- * Storage:    text  → token array (Uint32) → msgpackr.pack() → BLOB
- */
-import zlib from 'zlib';
-import { pack, unpack } from 'msgpackr';
-import { encode as encodeTokens, decode as decodeTokens } from 'gpt-tokenizer';
-
-// Magic prefix stored at start of compressed BLOBs so we can detect them
-const MAGIC = Buffer.from([0xC0, 0xDE]); // "CODE"
-const GZIP_MAGIC = Buffer.from([0x1f, 0x8b]);
-
-// ── Token helpers ─────────────────────────────────────────────────────────────
-
-export function tokenize(text) {
-  if (typeof text !== 'string' || text.length === 0) return null;
-  try {
-    return new Uint32Array(encodeTokens(text));
-  } catch {
-    return null;
-  }
-}
-
-export function detokenize(tokens) {
-  try {
-    const arr = tokens instanceof Uint32Array ? Array.from(tokens) : tokens;
-    return decodeTokens(arr);
-  } catch {
-    return null;
-  }
-}
-
-// ── Storage compression (text → tokens → msgpack BLOB) ────────────────────────
-
-/**
- * Compress a string for database storage.
- * Returns a Buffer starting with MAGIC prefix.
- */
-export function compressForStorage(text) {
-  if (typeof text !== 'string') return null;
-  const tokens = tokenize(text);
-  if (!tokens) return null;
-  const packed = pack({ t: Array.from(tokens) });
-  return Buffer.concat([MAGIC, packed]);
-}
-
-/**
- * Decompress a storage BLOB back to a string.
- * Returns null if not a compressed BLOB (caller should use raw value).
- */
-export function decompressFromStorage(buf) {
-  if (!Buffer.isBuffer(buf) && !(buf instanceof Uint8Array)) return null;
-  const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf);
-  if (b.length < MAGIC.length || b[0] !== MAGIC[0] || b[1] !== MAGIC[1]) return null;
-  try {
-    const { t } = unpack(b.slice(MAGIC.length));
-    return detokenize(t);
-  } catch {
-    return null;
-  }
-}
-
-// ── Transport compression (event → msgpack → gzip → binary frame) ─────────────
-
-const GZ_THRESHOLD = 512; // bytes — compress if msgpack payload exceeds this
-
-/**
- * Pack one event (or array of events) into a binary buffer for WebSocket transport.
- * Format: [ 0x01 ] + gzip(msgpack(data))  when compressed
- *         [ 0x00 ] + msgpack(data)         when not compressed
- */
-export function packForTransport(data) {
-  const packed = pack(data);
-  if (packed.length > GZ_THRESHOLD) {
-    try {
-      const compressed = zlib.gzipSync(packed, { level: 6 });
-      if (compressed.length < packed.length * 0.9) {
-        const out = Buffer.allocUnsafe(1 + compressed.length);
-        out[0] = 0x01; // flag: gzipped
-        compressed.copy(out, 1);
-        return out;
-      }
-    } catch (_) {}
-  }
-  const out = Buffer.allocUnsafe(1 + packed.length);
-  out[0] = 0x00; // flag: plain msgpack
-  packed.copy(out, 1);
-  return out;
-}
-
-/**
- * Unpack a binary buffer received from WebSocket transport.
- */
-export function unpackFromTransport(buf) {
-  const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf);
-  if (b.length < 2) return null;
-  const flag = b[0];
-  const payload = b.slice(1);
-  if (flag === 0x01) {
-    return unpack(zlib.gunzipSync(payload));
-  }
-  return unpack(payload);
-}
-
-// ── Tokenize specific fields in an event object (for storage) ─────────────────
-
-const TEXT_FIELDS = ['content', 'text', 'data', 'output', 'input', 'message', 'prompt', 'response'];
-
-/**
- * Walk an event object and compress any large text fields in-place for storage.
- * Returns the (possibly mutated) object — safe to pass to JSON.stringify or pack().
- */
-export function compressEventFields(obj) {
-  if (!obj || typeof obj !== 'object') return obj;
-  for (const key of TEXT_FIELDS) {
-    const val = obj[key];
-    if (typeof val === 'string' && val.length > 64) {
-      const buf = compressForStorage(val);
-      if (buf) obj[key] = buf;
-    }
-  }
-  return obj;
-}

package/static/js/request-manager.js

@@ -1,138 +0,0 @@
-/**
- * Request Manager - Phase 2: Request Lifetime Management
- * Tracks in-flight requests with unique IDs, enables cancellation on navigation
- * Prevents race conditions where older requests complete after newer ones
- */
-
-class RequestManager {
-  constructor() {
-    this._requestId = 0;
-    this._inflightRequests = new Map(); // requestId -> { conversationId, abortController, timestamp, priority }
-    this._activeLoadId = null; // Track which request is currently being rendered
-  }
-
-  /**
-   * Start a new load request for a conversation
-   * Returns a request token that must be verified before rendering
-   */
-  startLoadRequest(conversationId, priority = 'normal') {
-    const requestId = ++this._requestId;
-    const abortController = new AbortController();
-
-    this._inflightRequests.set(requestId, {
-      conversationId,
-      abortController,
-      timestamp: Date.now(),
-      priority,
-      status: 'pending'
-    });
-
-    return {
-      requestId,
-      abortSignal: abortController.signal,
-      cancel: () => this._cancelRequest(requestId),
-      verify: () => this._verifyRequest(requestId, conversationId)
-    };
-  }
-
-  /**
-   * Mark request as completed (allows rendering)
-   */
-  completeRequest(requestId) {
-    const req = this._inflightRequests.get(requestId);
-    if (req) {
-      req.status = 'completed';
-      this._activeLoadId = requestId;
-    }
-  }
-
-  /**
-   * Verify request is still valid before rendering
-   * Returns true only if this is the most recent request for this conversation
-   */
-  _verifyRequest(requestId, conversationId) {
-    const req = this._inflightRequests.get(requestId);
-
-    // Request not found or cancelled
-    if (!req) return false;
-
-    // Request is for different conversation
-    if (req.conversationId !== conversationId) return false;
-
-    // Find all requests for this conversation
-    const allForConv = Array.from(this._inflightRequests.entries())
-      .filter(([_, r]) => r.conversationId === conversationId && r.status === 'completed')
-      .sort((a, b) => b[0] - a[0]); // Sort by requestId descending (newest first)
-
-    // This request is the newest completed one for this conversation
-    return allForConv.length > 0 && allForConv[0][0] === requestId;
-  }
-
-  /**
-   * Cancel a request (aborts any pending network operations)
-   */
-  _cancelRequest(requestId) {
-    const req = this._inflightRequests.get(requestId);
-    if (req) {
-      req.status = 'cancelled';
-      req.abortController.abort();
-    }
-  }
-
-  /**
-   * Cancel all pending requests for a conversation
-   */
-  cancelConversationRequests(conversationId) {
-    for (const [id, req] of this._inflightRequests.entries()) {
-      if (req.conversationId === conversationId && req.status !== 'completed') {
-        this._cancelRequest(id);
-      }
-    }
-  }
-
-  /**
-   * Cancel all in-flight requests
-   */
-  cancelAllRequests() {
-    for (const [id, req] of this._inflightRequests.entries()) {
-      if (req.status !== 'completed') {
-        this._cancelRequest(id);
-      }
-    }
-  }
-
-  /**
-   * Clean up old requests to prevent memory leak
-   */
-  cleanup() {
-    const now = Date.now();
-    const maxAge = 60000; // Keep requests for 60 seconds
-
-    for (const [id, req] of this._inflightRequests.entries()) {
-      if (now - req.timestamp > maxAge) {
-        this._inflightRequests.delete(id);
-      }
-    }
-  }
-
-  /**
-   * Get debug info about in-flight requests
-   */
-  getDebugInfo() {
-    return {
-      activeLoadId: this._activeLoadId,
-      inflightRequests: Array.from(this._inflightRequests.entries()).map(([id, req]) => ({
-        requestId: id,
-        conversationId: req.conversationId,
-        timestamp: req.timestamp,
-        status: req.status,
-        priority: req.priority,
-        age: Date.now() - req.timestamp
-      }))
-    };
-  }
-}
-
-if (typeof window !== 'undefined') {
-  window.RequestManager = new RequestManager();
-}