agentgui 1.0.833 → 1.0.834

package/CHANGELOG.md

@@ -3,6 +3,7 @@
 ### Refactor
 - Split database.js (651L) into database.js (81L) + database-schema.js (176L) + database-migrations.js (150L) + database-migrations-acp.js (134L); all files ≤200L; no circular imports; migration functions receive db as parameter
 - Split claude-runner.js (1267L) into claude-runner.js (56L, AgentRunner class+helpers), claude-runner-direct.js (117L, runDirect method), claude-runner-acp.js (156L, runACP+_runACPOnce methods), claude-runner-agents.js (105L, AgentRegistry+registrations using acp-protocol.js), claude-runner-run.js (50L, runClaudeWithStreaming export); server.js updated to import from claude-runner-run.js
+- Split db-queries.js (1413L) into db-queries.js (93L, factory + conv queries), db-queries-messages.js (103L), db-queries-sessions.js (113L), db-queries-events.js (69L), db-queries-del.js (143L), db-queries-cleanup.js (86L), db-queries-import.js (134L), db-queries-streams.js (101L), db-queries-chunks.js (196L), db-queries-chunks2.js (83L), db-queries-voice.js (86L), db-queries-tools.js (128L); all ≤200L; each exports addXxxQueries(q, db, prep, generateId); factory calls all helpers and returns q
 
 ## 2026-04-12
 - refactor: reduce speech-manager.js from 207L to 200L by removing excess blank lines

package/lib/db-queries-chunks.js

@@ -0,0 +1,195 @@
+export function addChunkQueries(q, db, prep, generateId) {
+  q.createChunk = function(sessionId, conversationId, sequence, type, data) {
+    const id = generateId('chunk');
+    const now = Date.now();
+    const dataBlob = typeof data === 'string' ? data : JSON.stringify(data);
+
+    const stmt = prep(
+      `INSERT INTO chunks (id, sessionId, conversationId, sequence, type, data, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`
+    );
+    stmt.run(id, sessionId, conversationId, sequence, type, dataBlob, now);
+
+    return {
+      id,
+      sessionId,
+      conversationId,
+      sequence,
+      type,
+      data,
+      created_at: now
+    };
+  };
+
+  q.getChunk = function(id) {
+    const stmt = prep(
+      `SELECT id, sessionId, conversationId, sequence, type, data, created_at FROM chunks WHERE id = ?`
+    );
+    const row = stmt.get(id);
+    if (!row) return null;
+
+    try {
+      return {
+        ...row,
+        data: typeof row.data === 'string' ? JSON.parse(row.data) : row.data
+      };
+    } catch (e) {
+      return row;
+    }
+  };
+
+  q.getSessionChunks = function(sessionId) {
+    const stmt = prep(
+      `SELECT id, sessionId, conversationId, sequence, type, data, created_at
+       FROM chunks WHERE sessionId = ? ORDER BY sequence ASC`
+    );
+    const rows = stmt.all(sessionId);
+    return rows.map(row => {
+      try {
+        return {
+          ...row,
+          data: typeof row.data === 'string' ? JSON.parse(row.data) : row.data
+        };
+      } catch (e) {
+        return row;
+      }
+    });
+  };
+
+  q.getConversationChunkCount = function(conversationId) {
+    const stmt = prep('SELECT COUNT(*) as count FROM chunks WHERE conversationId = ?');
+    return stmt.get(conversationId).count;
+  };
+
+  q.getConversationChunks = function(conversationId) {
+    const stmt = prep(
+      `SELECT id, sessionId, conversationId, sequence, type, data, created_at
+       FROM chunks WHERE conversationId = ? ORDER BY created_at ASC`
+    );
+    const rows = stmt.all(conversationId);
+    return rows.map(row => {
+      try {
+        return {
+          ...row,
+          data: typeof row.data === 'string' ? JSON.parse(row.data) : row.data
+        };
+      } catch (e) {
+        return row;
+      }
+    });
+  };
+
+  q.getConversationChunksSince = function(conversationId, since) {
+    const stmt = prep(
+      `SELECT id, sessionId, conversationId, sequence, type, data, created_at
+       FROM chunks WHERE conversationId = ? AND created_at > ? ORDER BY created_at ASC`
+    );
+    const rows = stmt.all(conversationId, since);
+    return rows.map(row => {
+      try { return { ...row, data: typeof row.data === 'string' ? JSON.parse(row.data) : row.data }; }
+      catch (e) { return row; }
+    });
+  };
+
+  q.getRecentConversationChunks = function(conversationId, limit = 500) {
+    const sessions = prep(
+      `SELECT sessionId, COUNT(*) as n FROM chunks WHERE conversationId = ?
+       GROUP BY sessionId ORDER BY MAX(created_at) DESC`
+    ).all(conversationId);
+    if (!sessions.length) return [];
+    const included = [];
+    let total = 0;
+    for (const s of sessions) {
+      if (total + s.n > limit && included.length > 0) break;
+      included.unshift(s.sessionId);
+      total += s.n;
+    }
+    const placeholders = included.map(() => '?').join(',');
+    const rows = prep(
+      `SELECT id, sessionId, conversationId, sequence, type, data, created_at
+       FROM chunks WHERE conversationId = ? AND sessionId IN (${placeholders})
+       ORDER BY created_at ASC`
+    ).all(conversationId, ...included);
+    return rows.map(row => {
+      try { return { ...row, data: typeof row.data === 'string' ? JSON.parse(row.data) : row.data }; }
+      catch (e) { return row; }
+    });
+  };
+
+  q.getRecentMessages = function(conversationId, limit = 20) {
+    const countStmt = prep('SELECT COUNT(*) as count FROM messages WHERE conversationId = ?');
+    const total = countStmt.get(conversationId).count;
+
+    const stmt = prep(
+      'SELECT * FROM messages WHERE conversationId = ? ORDER BY created_at DESC LIMIT ? '
+    );
+    const messages = stmt.all(conversationId, limit).reverse();
+
+    return {
+      messages: messages.map(msg => {
+        if (typeof msg.content === 'string') {
+          try {
+            msg.content = JSON.parse(msg.content);
+          } catch (_) {}
+        }
+        return msg;
+      }),
+      total,
+      limit,
+      offset: Math.max(0, total - limit),
+      hasMore: total > limit
+    };
+  };
+
+  q.getMessagesBefore = function(conversationId, beforeId, limit = 50) {
+    const countStmt = prep('SELECT COUNT(*) as count FROM messages WHERE conversationId = ?');
+    const total = countStmt.get(conversationId).count;
+
+    const stmt = prep(`
+      SELECT * FROM messages
+      WHERE conversationId = ? AND id < (SELECT id FROM messages WHERE id = ?)
+      ORDER BY created_at DESC LIMIT ?
+    `);
+    const messages = stmt.all(conversationId, beforeId, limit).reverse();
+
+    return {
+      messages: messages.map(msg => {
+        if (typeof msg.content === 'string') {
+          try {
+            msg.content = JSON.parse(msg.content);
+          } catch (_) {}
+        }
+        return msg;
+      }),
+      total,
+      limit,
+      hasMore: total > (limit + 1)
+    };
+  };
+
+  q.getChunksBefore = function(conversationId, beforeTimestamp, limit = 500) {
+    const total = prep('SELECT COUNT(*) as count FROM chunks WHERE conversationId = ? AND created_at < ?')
+      .get(conversationId, beforeTimestamp).count;
+
+    const rows = prep(`
+      SELECT id, sessionId, conversationId, sequence, type, data, created_at
+      FROM chunks
+      WHERE conversationId = ? AND created_at < ?
+      ORDER BY created_at DESC LIMIT ?
+    `).all(conversationId, beforeTimestamp, limit);
+    rows.reverse();
+
+    return {
+      chunks: rows.map(row => {
+        try {
+          return { ...row, data: typeof row.data === 'string' ? JSON.parse(row.data) : row.data };
+        } catch (e) {
+          return row;
+        }
+      }),
+      total,
+      limit,
+      hasMore: rows.length === limit
+    };
+  };
+}

package/lib/db-queries-chunks2.js

@@ -0,0 +1,82 @@
+export function addChunkQueries2(q, db, prep, generateId) {
+  q.getChunksSince = function(sessionId, timestamp) {
+    const stmt = prep(
+      `SELECT id, sessionId, conversationId, sequence, type, data, created_at
+       FROM chunks WHERE sessionId = ? AND created_at > ? ORDER BY sequence ASC`
+    );
+    const rows = stmt.all(sessionId, timestamp);
+    return rows.map(row => {
+      try {
+        return {
+          ...row,
+          data: typeof row.data === 'string' ? JSON.parse(row.data) : row.data
+        };
+      } catch (e) {
+        return row;
+      }
+    });
+  };
+
+  q.getChunksSinceSeq = function(sessionId, sinceSeq) {
+    const stmt = prep(
+      `SELECT id, sessionId, conversationId, sequence, type, data, created_at
+       FROM chunks WHERE sessionId = ? AND sequence > ? ORDER BY sequence ASC`
+    );
+    const rows = stmt.all(sessionId, sinceSeq);
+    return rows.map(row => {
+      try {
+        return {
+          ...row,
+          data: typeof row.data === 'string' ? JSON.parse(row.data) : row.data
+        };
+      } catch (e) {
+        return row;
+      }
+    });
+  };
+
+  q.deleteSessionChunks = function(sessionId) {
+    const stmt = prep('DELETE FROM chunks WHERE sessionId = ?');
+    const result = stmt.run(sessionId);
+    return result.changes || 0;
+  };
+
+  q.getMaxSequence = function(sessionId) {
+    const stmt = prep('SELECT MAX(sequence) as max FROM chunks WHERE sessionId = ?');
+    const result = stmt.get(sessionId);
+    return result?.max ?? -1;
+  };
+
+  q.getEmptyConversations = function() {
+    const stmt = prep(`
+      SELECT c.* FROM conversations c
+      LEFT JOIN messages m ON c.id = m.conversationId
+      WHERE c.status != 'deleted'
+      GROUP BY c.id
+      HAVING COUNT(m.id) = 0
+    `);
+    return stmt.all();
+  };
+
+  q.permanentlyDeleteConversation = function(id) {
+    return this.deleteConversation(id);
+  };
+
+  q.cleanupEmptyConversations = function() {
+    const emptyConvs = this.getEmptyConversations();
+    let deletedCount = 0;
+
+    for (const conv of emptyConvs) {
+      console.log(`[cleanup] Deleting empty conversation: ${conv.id} (${conv.title || 'Untitled'})`);
+      if (this.permanentlyDeleteConversation(conv.id)) {
+        deletedCount++;
+      }
+    }
+
+    if (deletedCount > 0) {
+      console.log(`[cleanup] Deleted ${deletedCount} empty conversation(s)`);
+    }
+
+    return deletedCount;
+  };
+}

package/lib/db-queries-cleanup.js

@@ -0,0 +1,85 @@
+export function addCleanupQueries(q, db, prep, generateId) {
+  q.cleanup = function() {
+    const thirtyDaysAgo = Date.now() - (30 * 24 * 60 * 60 * 1000);
+    const sevenDaysAgo = Date.now() - (7 * 24 * 60 * 60 * 1000);
+    const now = Date.now();
+
+    const cleanupStmt = db.transaction(() => {
+      prep('DELETE FROM events WHERE created_at < ?').run(thirtyDaysAgo);
+      prep('DELETE FROM sessions WHERE completed_at IS NOT NULL AND completed_at < ?').run(thirtyDaysAgo);
+      prep('DELETE FROM idempotencyKeys WHERE (created_at + ttl) < ?').run(now);
+
+      prep('DELETE FROM chunks WHERE sessionId IN (SELECT id FROM sessions WHERE completed_at IS NOT NULL AND completed_at < ?)').run(sevenDaysAgo);
+      prep('DELETE FROM stream_updates WHERE sessionId IN (SELECT id FROM sessions WHERE completed_at IS NOT NULL AND completed_at < ?)').run(sevenDaysAgo);
+
+      prep('DELETE FROM chunks WHERE created_at < ? AND sessionId NOT IN (SELECT id FROM sessions WHERE completed_at IS NULL AND started_at >= ?)').run(sevenDaysAgo, sevenDaysAgo);
+      prep('DELETE FROM stream_updates WHERE created_at < ? AND sessionId NOT IN (SELECT id FROM sessions WHERE completed_at IS NULL AND started_at >= ?)').run(sevenDaysAgo, sevenDaysAgo);
+
+      prep('DELETE FROM voice_cache WHERE expires_at <= ?').run(now);
+
+      const deletedConvIds = prep("SELECT id FROM conversations WHERE status = 'deleted' AND updated_at < ?").all(sevenDaysAgo).map(r => r.id);
+      for (const cid of deletedConvIds) {
+        prep('DELETE FROM stream_updates WHERE conversationId = ?').run(cid);
+        prep('DELETE FROM chunks WHERE conversationId = ?').run(cid);
+        prep('DELETE FROM events WHERE conversationId = ?').run(cid);
+        prep('DELETE FROM sessions WHERE conversationId = ?').run(cid);
+        prep('DELETE FROM messages WHERE conversationId = ?').run(cid);
+        prep('DELETE FROM voice_cache WHERE conversationId = ?').run(cid);
+        prep('DELETE FROM thread_states WHERE thread_id = ?').run(cid);
+        prep('DELETE FROM checkpoints WHERE thread_id = ?').run(cid);
+        prep('DELETE FROM run_metadata WHERE thread_id = ?').run(cid);
+        prep('DELETE FROM conversations WHERE id = ?').run(cid);
+      }
+
+      prep('DELETE FROM thread_states WHERE created_at < ?').run(thirtyDaysAgo);
+      prep('DELETE FROM checkpoints WHERE created_at < ?').run(thirtyDaysAgo);
+      prep('DELETE FROM run_metadata WHERE created_at < ? AND status NOT IN (?, ?)').run(thirtyDaysAgo, 'active', 'pending');
+
+      prep('DELETE FROM workflow_runs WHERE created_at < ?').run(thirtyDaysAgo);
+
+      const toolIds = prep('SELECT DISTINCT tool_id FROM tool_install_history').all().map(r => r.tool_id);
+      for (const tid of toolIds) {
+        prep(`DELETE FROM tool_install_history WHERE tool_id = ? AND id NOT IN (
+          SELECT id FROM tool_install_history WHERE tool_id = ? ORDER BY created_at DESC LIMIT 50
+        )`).run(tid, tid);
+      }
+    });
+
+    cleanupStmt();
+
+    try {
+      db.exec('PRAGMA incremental_vacuum(1000)');
+    } catch (_) {
+    }
+  };
+
+  q.setIdempotencyKey = function(key, value) {
+    const now = Date.now();
+    const ttl = 24 * 60 * 60 * 1000;
+
+    const stmt = prep(
+      'INSERT OR REPLACE INTO idempotencyKeys (key, value, created_at, ttl) VALUES (?, ?, ?, ?)'
+    );
+    stmt.run(key, JSON.stringify(value), now, ttl);
+  };
+
+  q.getIdempotencyKey = function(key) {
+    const stmt = prep('SELECT * FROM idempotencyKeys WHERE key = ?');
+    const entry = stmt.get(key);
+
+    if (!entry) return null;
+
+    const isExpired = Date.now() - entry.created_at > entry.ttl;
+    if (isExpired) {
+      db.run('DELETE FROM idempotencyKeys WHERE key = ?', [key]);
+      return null;
+    }
+
+    return entry.value;
+  };
+
+  q.clearIdempotencyKey = function(key) {
+    db.run('DELETE FROM idempotencyKeys WHERE key = ?', [key]);
+  };
+
+}

package/lib/db-queries-del.js

@@ -0,0 +1,142 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+export function addDeleteQueries(q, db, prep, generateId) {
+  q.deleteConversation = function(id) {
+    const conv = this.getConversation(id);
+    if (!conv) return false;
+
+    const sessionClaudeIds = prep('SELECT DISTINCT claudeSessionId FROM sessions WHERE conversationId = ? AND claudeSessionId IS NOT NULL').all(id).map(r => r.claudeSessionId);
+    if (conv.claudeSessionId && !sessionClaudeIds.includes(conv.claudeSessionId)) {
+      sessionClaudeIds.push(conv.claudeSessionId);
+    }
+    for (const csid of sessionClaudeIds) {
+      this.deleteClaudeSessionFile(csid);
+    }
+
+    const deleteStmt = db.transaction(() => {
+      const sessionIds = prep('SELECT id FROM sessions WHERE conversationId = ?').all(id).map(r => r.id);
+      prep('DELETE FROM stream_updates WHERE conversationId = ?').run(id);
+      prep('DELETE FROM chunks WHERE conversationId = ?').run(id);
+      prep('DELETE FROM events WHERE conversationId = ?').run(id);
+      if (sessionIds.length > 0) {
+        const placeholders = sessionIds.map(() => '?').join(',');
+        db.prepare(`DELETE FROM stream_updates WHERE sessionId IN (${placeholders})`).run(...sessionIds);
+        db.prepare(`DELETE FROM chunks WHERE sessionId IN (${placeholders})`).run(...sessionIds);
+        db.prepare(`DELETE FROM events WHERE sessionId IN (${placeholders})`).run(...sessionIds);
+      }
+      prep('DELETE FROM sessions WHERE conversationId = ?').run(id);
+      prep('DELETE FROM messages WHERE conversationId = ?').run(id);
+      prep('UPDATE conversations SET status = ?, updated_at = ? WHERE id = ?').run('deleted', Date.now(), id);
+    });
+
+    deleteStmt();
+    return true;
+  };
+
+  q.deleteClaudeSessionFile = function(sessionId) {
+    try {
+      const claudeDir = path.join(os.homedir(), '.claude');
+      const projectsDir = path.join(claudeDir, 'projects');
+
+      if (!fs.existsSync(projectsDir)) {
+        return false;
+      }
+
+      const projects = fs.readdirSync(projectsDir);
+      for (const project of projects) {
+        const projectPath = path.join(projectsDir, project);
+        const sessionFile = path.join(projectPath, `${sessionId}.jsonl`);
+
+        if (fs.existsSync(sessionFile)) {
+          fs.unlinkSync(sessionFile);
+          console.log(`[deleteClaudeSessionFile] Deleted Claude session file: ${sessionFile}`);
+
+          const indexPath = path.join(projectPath, 'sessions-index.json');
+          if (fs.existsSync(indexPath)) {
+            try {
+              const indexContent = fs.readFileSync(indexPath, 'utf8');
+              const index = JSON.parse(indexContent);
+              if (index.entries && Array.isArray(index.entries)) {
+                const originalLength = index.entries.length;
+                index.entries = index.entries.filter(entry => entry.sessionId !== sessionId);
+                if (index.entries.length < originalLength) {
+                  fs.writeFileSync(indexPath, JSON.stringify(index, null, 2), { encoding: 'utf8' });
+                  console.log(`[deleteClaudeSessionFile] Removed session ${sessionId} from sessions-index.json in ${projectPath}`);
+                }
+              }
+            } catch (indexErr) {
+              console.error(`[deleteClaudeSessionFile] Failed to update sessions-index.json in ${projectPath}:`, indexErr.message);
+            }
+          }
+
+          const sessionDir = path.join(projectPath, sessionId);
+          if (fs.existsSync(sessionDir)) {
+            try {
+              fs.rmSync(sessionDir, { recursive: true, force: true });
+              console.log(`[deleteClaudeSessionFile] Deleted Claude session dir: ${sessionDir}`);
+            } catch (dirErr) {
+              console.error(`[deleteClaudeSessionFile] Failed to delete session dir ${sessionDir}:`, dirErr.message);
+            }
+          }
+
+          return true;
+        }
+      }
+
+      return false;
+    } catch (err) {
+      console.error(`[deleteClaudeSessionFile] Error deleting session ${sessionId}:`, err.message);
+      return false;
+    }
+  };
+
+  q.deleteAllConversations = function() {
+    try {
+      const allClaudeSessionIds = prep('SELECT DISTINCT claudeSessionId FROM sessions WHERE claudeSessionId IS NOT NULL').all().map(r => r.claudeSessionId);
+      const convClaudeIds = prep('SELECT DISTINCT claudeSessionId FROM conversations WHERE claudeSessionId IS NOT NULL').all().map(r => r.claudeSessionId);
+      for (const csid of convClaudeIds) {
+        if (!allClaudeSessionIds.includes(csid)) allClaudeSessionIds.push(csid);
+      }
+      for (const csid of allClaudeSessionIds) {
+        this.deleteClaudeSessionFile(csid);
+      }
+
+      const deleteAllStmt = db.transaction(() => {
+        prep('DELETE FROM stream_updates').run();
+        prep('DELETE FROM chunks').run();
+        prep('DELETE FROM events').run();
+        prep('DELETE FROM voice_cache').run();
+        prep('DELETE FROM sessions').run();
+        prep('DELETE FROM messages').run();
+        prep('DELETE FROM conversations').run();
+      });
+
+      deleteAllStmt();
+      const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+      if (fs.existsSync(projectsDir)) {
+        for (const project of fs.readdirSync(projectsDir)) {
+          const pdir = path.join(projectsDir, project);
+          try {
+            if (!fs.statSync(pdir).isDirectory()) continue;
+            for (const entry of fs.readdirSync(pdir, { withFileTypes: true })) {
+              if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+                fs.unlinkSync(path.join(pdir, entry.name));
+              } else if (entry.isDirectory()) {
+                fs.rmSync(path.join(pdir, entry.name), { recursive: true, force: true });
+              }
+            }
+          } catch (err) {
+            console.error('[deleteAllConversations] Failed to clean project dir:', pdir, err.message);
+          }
+        }
+      }
+      console.log('[deleteAllConversations] Deleted all conversations and associated Claude Code files');
+      return true;
+    } catch (err) {
+      console.error('[deleteAllConversations] Error deleting all conversations:', err.message);
+      return false;
+    }
+  };
+}

package/lib/db-queries-events.js

@@ -0,0 +1,68 @@
+export function addEventQueries(q, db, prep, generateId) {
+  q.createEvent = function(type, data, conversationId = null, sessionId = null, idempotencyKey = null) {
+    if (idempotencyKey) {
+      const cached = this.getIdempotencyKey(idempotencyKey);
+      if (cached) {
+        console.log(`[event-idempotency] Event already exists for key ${idempotencyKey}, returning cached`);
+        return JSON.parse(cached);
+      }
+    }
+
+    const id = generateId('evt');
+    const now = Date.now();
+
+    const stmt = prep(
+      `INSERT INTO events (id, type, conversationId, sessionId, data, created_at) VALUES (?, ?, ?, ?, ?, ?)`
+    );
+    stmt.run(id, type, conversationId, sessionId, JSON.stringify(data), now);
+
+    const event = {
+      id,
+      type,
+      conversationId,
+      sessionId,
+      data,
+      created_at: now
+    };
+
+    if (idempotencyKey) {
+      this.setIdempotencyKey(idempotencyKey, event);
+    }
+
+    return event;
+  };
+
+  q.getEvent = function(id) {
+    const stmt = prep('SELECT * FROM events WHERE id = ?');
+    const row = stmt.get(id);
+    if (row) {
+      return {
+        ...row,
+        data: JSON.parse(row.data)
+      };
+    }
+    return undefined;
+  };
+
+  q.getConversationEvents = function(conversationId) {
+    const stmt = prep(
+      'SELECT * FROM events WHERE conversationId = ? ORDER BY created_at ASC'
+    );
+    const rows = stmt.all(conversationId);
+    return rows.map(row => ({
+      ...row,
+      data: JSON.parse(row.data)
+    }));
+  };
+
+  q.getSessionEvents = function(sessionId) {
+    const stmt = prep(
+      'SELECT * FROM events WHERE sessionId = ? ORDER BY created_at ASC'
+    );
+    const rows = stmt.all(sessionId);
+    return rows.map(row => ({
+      ...row,
+      data: JSON.parse(row.data)
+    }));
+  };
+}