agentgui 1.0.930 → 1.0.932

package/lib/db-queries.js

@@ -1,89 +0,0 @@
-import { createACPQueries } from '../acp-queries.js';
-import { addMessageQueries } from './db-queries-messages.js';
-import { addSessionQueries } from './db-queries-sessions.js';
-import { addEventQueries } from './db-queries-events.js';
-import { addDeleteQueries } from './db-queries-del.js';
-import { addCleanupQueries } from './db-queries-cleanup.js';
-import { addImportQueries } from './db-queries-import.js';
-import { addStreamQueries } from './db-queries-streams.js';
-import { addChunkQueries } from './db-queries-chunks.js';
-import { addChunkQueries2 } from './db-queries-chunks2.js';
-
-export function createQueries(db, prep, generateId) {
-  const q = {
-  _db: db,
-  createConversation(agentType, title = null, workingDirectory = null, model = null, subAgent = null) {
-    const id = generateId('conv');
-    const now = Date.now();
-    const stmt = prep(
-      `INSERT INTO conversations (id, agentId, agentType, title, created_at, updated_at, status, workingDirectory, model, subAgent) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    );
-    stmt.run(id, agentType, agentType, title, now, now, 'active', workingDirectory, model, subAgent);
-    return { id, agentType, title, workingDirectory, model, subAgent, created_at: now, updated_at: now, status: 'active' };
-  },
-  getConversation(id) { return prep('SELECT * FROM conversations WHERE id = ?').get(id); },
-  getAllConversations() { return prep('SELECT * FROM conversations WHERE status != ? ORDER BY updated_at DESC').all('deleted'); },
-  getConversationsList() {
-    return prep('SELECT id, agentId, title, agentType, created_at, updated_at, messageCount, workingDirectory, isStreaming, model, subAgent, pinned, sortOrder, tags FROM conversations WHERE status NOT IN (?, ?) ORDER BY pinned DESC, sortOrder ASC, updated_at DESC').all('deleted', 'archived');
-  },
-  getConversations() { return prep('SELECT * FROM conversations WHERE status NOT IN (?, ?) ORDER BY pinned DESC, sortOrder ASC, updated_at DESC').all('deleted', 'archived'); },
-  updateConversationSortOrder(id, sortOrder) { prep('UPDATE conversations SET sortOrder = ? WHERE id = ?').run(sortOrder, id); },
-  getArchivedConversations() { return prep('SELECT id, agentId, title, agentType, created_at, updated_at, messageCount, workingDirectory, model, subAgent FROM conversations WHERE status = ? ORDER BY updated_at DESC').all('archived'); },
-  archiveConversation(id) {
-    const conv = this.getConversation(id);
-    if (!conv) return null;
-    prep('UPDATE conversations SET status = ?, updated_at = ? WHERE id = ?').run('archived', Date.now(), id);
-    return this.getConversation(id);
-  },
-  restoreConversation(id) {
-    const conv = this.getConversation(id);
-    if (!conv) return null;
-    prep('UPDATE conversations SET status = ?, updated_at = ? WHERE id = ?').run('active', Date.now(), id);
-    return this.getConversation(id);
-  },
-  updateConversation(id, data) {
-    const conv = this.getConversation(id);
-    if (!conv) return null;
-    const now = Date.now();
-    const title = data.title !== undefined ? data.title : conv.title;
-    const status = data.status !== undefined ? data.status : conv.status;
-    const agentId = data.agentId !== undefined ? data.agentId : conv.agentId;
-    const agentType = data.agentType !== undefined ? data.agentType : conv.agentType;
-    const model = data.model !== undefined ? data.model : conv.model;
-    const subAgent = data.subAgent !== undefined ? data.subAgent : conv.subAgent;
-    const pinned = data.pinned !== undefined ? (data.pinned ? 1 : 0) : (conv.pinned || 0);
-    const tags = data.tags !== undefined ? (Array.isArray(data.tags) ? data.tags.join(',') : data.tags) : (conv.tags || null);
-    prep(`UPDATE conversations SET title = ?, status = ?, agentId = ?, agentType = ?, model = ?, subAgent = ?, pinned = ?, tags = ?, updated_at = ? WHERE id = ?`).run(title, status, agentId, agentType, model, subAgent, pinned, tags, now, id);
-    return { ...conv, title, status, agentId, agentType, model, subAgent, pinned, tags, updated_at: now };
-  },
-  setClaudeSessionId(conversationId, claudeSessionId, sessionId = null) {
-    prep('UPDATE conversations SET claudeSessionId = ?, updated_at = ? WHERE id = ?').run(claudeSessionId, Date.now(), conversationId);
-    if (sessionId) prep('UPDATE sessions SET claudeSessionId = ? WHERE id = ?').run(claudeSessionId, sessionId);
-  },
-  getConversationByClaudeSessionId(claudeSessionId) { return prep('SELECT * FROM conversations WHERE claudeSessionId = ? AND status NOT IN (?, ?) LIMIT 1').get(claudeSessionId, 'deleted', 'archived') || null; },
-  getClaudeSessionId(conversationId) { const row = prep('SELECT claudeSessionId FROM conversations WHERE id = ?').get(conversationId); return row?.claudeSessionId || null; },
-  setIsStreaming(conversationId, isStreaming) { prep('UPDATE conversations SET isStreaming = ?, updated_at = ? WHERE id = ?').run(isStreaming ? 1 : 0, Date.now(), conversationId); },
-  getIsStreaming(conversationId) { const row = prep('SELECT isStreaming FROM conversations WHERE id = ?').get(conversationId); return row?.isStreaming === 1; },
-  getStreamingConversations() { return prep('SELECT id, title, claudeSessionId, agentId, agentType, model, subAgent FROM conversations WHERE isStreaming = 1').all(); },
-  getResumableConversations(withinMs = 600000) {
-    const cutoff = Date.now() - withinMs;
-    return prep(`SELECT DISTINCT c.id, c.title, c.claudeSessionId, c.agentId, c.agentType, c.workingDirectory, c.model, c.subAgent FROM conversations c WHERE EXISTS (SELECT 1 FROM sessions s WHERE s.conversationId = c.id AND s.status IN ('active', 'pending', 'interrupted') AND s.started_at > ?)`).all(cutoff);
-  },
-  clearAllStreamingFlags() { return prep('UPDATE conversations SET isStreaming = 0 WHERE isStreaming = 1').run().changes; },
-  markSessionIncomplete(sessionId, errorMsg) { prep('UPDATE sessions SET status = ?, error = ?, completed_at = ? WHERE id = ?').run('incomplete', errorMsg || 'unknown', Date.now(), sessionId); },
-  getSessionsProcessingLongerThan(minutes) { const cutoff = Date.now() - (minutes * 60 * 1000); return prep("SELECT * FROM sessions WHERE status IN ('active', 'pending') AND started_at < ?").all(cutoff); },
-  cleanupOrphanedSessions(days) { const cutoff = Date.now() - (days * 24 * 60 * 60 * 1000); return prep("DELETE FROM sessions WHERE status IN ('active', 'pending') AND started_at < ?").run(cutoff).changes || 0; },
-  };
-
-  addMessageQueries(q, db, prep, generateId);
-  addSessionQueries(q, db, prep, generateId);
-  addEventQueries(q, db, prep, generateId);
-  addDeleteQueries(q, db, prep, generateId);
-  addCleanupQueries(q, db, prep, generateId);
-  addImportQueries(q, db, prep, generateId);
-  addStreamQueries(q, db, prep, generateId);
-  addChunkQueries(q, db, prep, generateId);
-  addChunkQueries2(q, db, prep, generateId);
-  Object.assign(q, createACPQueries(db, prep));
-  return q;
-}

package/lib/jsonl-parser.js

@@ -1,190 +0,0 @@
-import path from 'path';
-
-export class JsonlParser {
-  constructor({ broadcastSync, queries }) {
-    this._bc = broadcastSync;
-    this._q = queries;
-    this._convMap = new Map();
-    this._emitted = new Map();
-    this._seqs = new Map();
-    this._streaming = new Set();
-    this._sessions = new Map();
-  }
-
-  /**
-   * Pre-register a GUI-spawned session so _conv finds the right conversation
-   * and _dbSession reuses the existing session ID instead of creating a new one.
-   * Must be called as soon as session_id is obtained from Claude stdout, before
-   * the 16ms file-watcher debounce fires.
-   */
-  registerSession(claudeSessionId, convId, dbSessionId) {
-    this._convMap.set(claudeSessionId, convId);
-    if (dbSessionId) this._sessions.set(claudeSessionId, dbSessionId);
-  }
-
-  clear() {
-    this._convMap.clear();
-    this._emitted.clear();
-    this._seqs.clear();
-    this._streaming.clear();
-    this._sessions.clear();
-  }
-
-  removeSid(sid) {
-    this._convMap.delete(sid);
-    this._seqs.delete(sid);
-    this._streaming.delete(sid);
-    this._sessions.delete(sid);
-    for (const key of [...this._emitted.keys()]) if (key.startsWith(`${sid}:`)) this._emitted.delete(key);
-  }
-
-  endAllStreaming() {
-    for (const sid of [...this._streaming]) this._endStreaming(this._convMap.get(sid), sid);
-  }
-
-  _conv(sid, e, fp) {
-    if (this._convMap.has(sid)) return this._convMap.get(sid);
-    const found = this._q.getConversationByClaudeSessionId(sid);
-    if (found) { this._convMap.set(sid, found.id); return found.id; }
-    if (e.type === 'queue-operation' || e.type === 'last-prompt') return null;
-    if (e.type === 'user' && e.isMeta) return null;
-
-    // Resolve workingDirectory: event cwd → decode encoded directory name
-    let cwd = e.cwd || null;
-    if (!cwd && fp) {
-      const projectDir = path.dirname(fp);
-      // Decode encoded directory name (replace leading '-' with '/', rest '-' → '/')
-      const dirName = path.basename(projectDir);
-      if (dirName.startsWith('-')) cwd = '/' + dirName.slice(1).replace(/-/g, '/');
-    }
-    cwd = cwd || process.cwd();
-
-    const branch = e.gitBranch || '';
-    const base = path.basename(cwd);
-    const title = branch ? `${branch} @ ${base}` : base;
-    const conv = this._q.createConversation('claude-code', title, cwd);
-    this._q.setClaudeSessionId(conv.id, sid);
-    this._convMap.set(sid, conv.id);
-    this._bc({ type: 'conversation_created', conversation: conv, timestamp: Date.now() });
-    return conv.id;
-  }
-
-  _seq(sid) { const n = (this._seqs.get(sid) || 0) + 1; this._seqs.set(sid, n); return n; }
-
-  _dbSession(cid, sid) {
-    if (this._sessions.has(sid)) return this._sessions.get(sid);
-    const sess = this._q.createSession(cid);
-    this._q.updateSession(sess.id, { status: 'active' });
-    this._sessions.set(sid, sess.id);
-    return sess.id;
-  }
-
-  _emit(cid, sid, block, role, extra) {
-    const dbSid = this._dbSession(cid, sid);
-    const seq = this._seq(sid);
-    try { this._q.createChunk(dbSid, cid, seq, block.type || 'unknown', block); } catch (_) {}
-    this._bc({ type: 'streaming_progress', sessionId: dbSid, conversationId: cid, block, blockRole: role, seq, timestamp: Date.now(), ...extra });
-  }
-
-  _emitBlocks(cid, sid, blocks, role) {
-    for (const b of blocks) {
-      if (!b || !b.type) continue;
-      this._emit(cid, sid, b, role);
-    }
-  }
-
-  _startStreaming(cid, sid) {
-    if (this._streaming.has(sid)) return;
-    this._streaming.add(sid);
-    const dbSid = this._dbSession(cid, sid);
-    this._q.setIsStreaming(cid, true);
-    this._bc({ type: 'streaming_start', sessionId: dbSid, conversationId: cid, agentId: 'cli-claude', timestamp: Date.now() });
-  }
-
-  _endStreaming(cid, sid) {
-    if (!this._streaming.has(sid)) return;
-    this._streaming.delete(sid);
-    const dbSid = this._sessions.get(sid);
-    if (dbSid) {
-      try { this._q.updateSession(dbSid, { status: 'completed', completed_at: Date.now() }); } catch (_) {}
-    }
-    this._q.setIsStreaming(cid, false);
-    this._bc({ type: 'streaming_complete', sessionId: dbSid || sid, conversationId: cid, agentId: 'cli-claude', eventCount: 0, seq: this._seq(sid), timestamp: Date.now() });
-    this._sessions.delete(sid);
-  }
-
-  _route(cid, sid, e) {
-    if (e.type === 'queue-operation' || e.type === 'last-prompt' || (e.type === 'user' && e.isMeta)) return;
-
-    if (e.isApiErrorMessage && e.error === 'rate_limit') {
-      this._bc({ type: 'streaming_error', sessionId: this._sessions.get(sid) || sid, conversationId: cid, error: 'Rate limit hit', recoverable: true, timestamp: Date.now() });
-      return;
-    }
-
-    if (e.type === 'system') {
-      if (e.subtype === 'init') { this._startStreaming(cid, sid); return; }
-      if (e.subtype === 'turn_duration' || e.subtype === 'stop_hook_summary') { this._endStreaming(cid, sid); return; }
-      this._startStreaming(cid, sid);
-      this._emit(cid, sid, { type: 'system', subtype: e.subtype, model: e.model, cwd: e.cwd, tools: e.tools, preTokens: e.compactMetadata?.preTokens }, 'system');
-      return;
-    }
-
-    if (e.type === 'assistant' && e.message?.content) {
-      this._startStreaming(cid, sid);
-      const key = `${sid}:${e.message.id}`;
-      const prev = this._emitted.get(key) || 0;
-      const content = e.message.content;
-      const newBlocks = content.slice(prev);
-      if (newBlocks.length > 0) {
-        this._emitted.set(key, content.length);
-        this._emitBlocks(cid, sid, newBlocks, 'assistant');
-      }
-      if (e.message.stop_reason) this._emitted.delete(key);
-      return;
-    }
-
-    if (e.type === 'user' && e.message?.content) {
-      if (e.isCompactSummary) { this._emit(cid, sid, { type: 'compact_summary', content: e.message.content }, 'system'); return; }
-      this._startStreaming(cid, sid);
-      const content = e.message.content;
-      const textParts = Array.isArray(content)
-        ? content.filter(b => b.type === 'text' && b.text && !b.text.startsWith('<task-notification>')).map(b => b.text).join('\n')
-        : (typeof content === 'string' && !content.startsWith('<task-notification>') ? content : '');
-      if (textParts) {
-        try { this._q.createMessage(cid, 'user', textParts); } catch (_) {}
-      }
-      const blocks = Array.isArray(content) ? content : [];
-      for (const b of blocks) if (b.type === 'tool_result') this._emit(cid, sid, b, 'tool_result');
-      return;
-    }
-
-    if (e.type === 'progress') {
-      this._startStreaming(cid, sid);
-      const d = e.data || {};
-      if (d.type === 'agent_progress') {
-        const inner = d.message?.message || d.message;
-        const content = inner?.content;
-        if (Array.isArray(content)) {
-          const role = inner.role === 'user' ? 'tool_result' : 'assistant';
-          this._emitBlocks(cid, sid, content, role);
-        }
-        return;
-      }
-      if (d.type === 'hook_progress') {
-        this._emit(cid, sid, { type: 'hook_progress', hookEvent: d.hookEvent, hookName: d.hookName }, 'system');
-        return;
-      }
-      if (d.type === 'mcp_progress') {
-        this._emit(cid, sid, { type: 'mcp_progress', status: d.status, serverName: d.serverName, toolName: d.toolName }, 'system');
-        return;
-      }
-      this._emit(cid, sid, { type: d.type || e.subtype || 'progress', content: e.content || d }, 'progress');
-      return;
-    }
-
-    if (e.type === 'result') {
-      this._emit(cid, sid, { type: 'result', result: e.result, subtype: e.subtype, duration_ms: e.duration_ms, total_cost_usd: e.total_cost_usd, is_error: e.is_error || false }, 'result', { isResult: true });
-      this._endStreaming(cid, sid);
-    }
-  }
-}

package/lib/jsonl-watcher.js

@@ -1,64 +0,0 @@
-import fs from 'fs';
-import { JsonlWatcher as CCFWatcher } from 'ccfollow';
-import { JsonlParser } from './jsonl-parser.js';
-
-export class JsonlWatcher extends CCFWatcher {
-  constructor({ broadcastSync, queries }) {
-    super();
-    this._parser = new JsonlParser({ broadcastSync, queries });
-    this._currentFp = null;
-  }
-
-  /** Override _read to capture the current file path for project-folder resolution in _conv */
-  _read(fp) {
-    this._currentFp = fp;
-    super._read(fp);
-    this._currentFp = null;
-  }
-
-  _line(line) {
-    line = line.trim();
-    if (!line) return;
-    let e;
-    try { e = JSON.parse(line); } catch (_) { return; }
-    if (!e || !e.sessionId) return;
-    const cid = this._parser._conv(e.sessionId, e, this._currentFp);
-    if (cid) this._parser._route(cid, e.sessionId, e);
-  }
-
-  /**
-   * Pre-register a GUI-spawned session so the parser uses the correct existing
-   * conversation and session ID rather than creating duplicates.
-   * Call this as soon as session_id is obtained from Claude stdout.
-   */
-  registerSession(claudeSessionId, convId, dbSessionId) {
-    this._parser.registerSession(claudeSessionId, convId, dbSessionId);
-  }
-
-  stop() {
-    super.stop();
-    this._parser.endAllStreaming();
-  }
-
-  removeConversation(conversationId) {
-    const sids = [...this._parser._convMap.entries()].filter(([, cid]) => cid === conversationId).map(([sid]) => sid);
-    for (const sid of sids) {
-      this._parser.removeSid(sid);
-      for (const [fp, s] of this._tails.entries()) {
-        if (!fp.includes(sid)) continue;
-        if (s.fd !== null) try { fs.closeSync(s.fd); } catch (_) {}
-        this._tails.delete(fp);
-        const t = this._timers.get(fp);
-        if (t) { clearTimeout(t); this._timers.delete(fp); }
-      }
-    }
-  }
-
-  removeAllConversations() {
-    for (const s of this._tails.values()) if (s.fd !== null) try { fs.closeSync(s.fd); } catch (_) {}
-    for (const t of this._timers.values()) clearTimeout(t);
-    this._tails.clear();
-    this._timers.clear();
-    this._parser.clear();
-  }
-}

package/lib/routes-agent-actions.js

@@ -1,61 +0,0 @@
-import os from 'os';
-import { spawn } from 'child_process';
-
-export function register(deps) {
-  const { sendJSON, queries, broadcastSync, discoveredAgents, activeScripts, modelCache } = deps;
-
-  const routes = {};
-
-  routes['_match'] = (method, pathOnly) => {
-    let m;
-    if (method === 'POST' && (m = pathOnly.match(/^\/api\/agents\/([^/]+)\/auth$/))) return (req, res) => handleAgentAuth(req, res, m[1]);
-    if (method === 'POST' && (m = pathOnly.match(/^\/api\/agents\/([^/]+)\/update$/))) return (req, res) => handleAgentUpdate(req, res, m[1]);
-    return null;
-  };
-
-  async function handleAgentAuth(req, res, agentId) {
-    const agent = discoveredAgents.find(a => a.id === agentId);
-    if (!agent) { sendJSON(req, res, 404, { error: 'Agent not found' }); return; }
-
-    const authCommands = {
-      'claude-code': { cmd: 'claude', args: ['setup-token'] },
-      'opencode': { cmd: 'opencode', args: ['auth', 'login'] },
-    };
-    const authCmd = authCommands[agentId];
-    if (!authCmd) { sendJSON(req, res, 400, { error: 'No auth command for this agent (OAuth flows removed; configure provider key via /api/auth/save-config)' }); return; }
-    const conversationId = '__agent_auth__';
-    if (activeScripts.has(conversationId)) { sendJSON(req, res, 409, { error: 'Auth process already running' }); return; }
-    const child = spawn(authCmd.cmd, authCmd.args, { stdio: ['pipe', 'pipe', 'pipe'], env: { ...process.env, FORCE_COLOR: '1' }, shell: os.platform() === 'win32' });
-    activeScripts.set(conversationId, { process: child, script: 'auth-' + agentId, startTime: Date.now() });
-    broadcastSync({ type: 'script_started', conversationId, script: 'auth-' + agentId, agentId, timestamp: Date.now() });
-    const onData = (stream) => (chunk) => broadcastSync({ type: 'script_output', conversationId, data: chunk.toString(), stream, timestamp: Date.now() });
-    child.stdout.on('data', onData('stdout'));
-    child.stderr.on('data', onData('stderr'));
-    child.stdout.on('error', () => {});
-    child.stderr.on('error', () => {});
-    child.on('error', (err) => { activeScripts.delete(conversationId); broadcastSync({ type: 'script_stopped', conversationId, code: 1, error: err.message, timestamp: Date.now() }); });
-    child.on('close', (code) => { activeScripts.delete(conversationId); broadcastSync({ type: 'script_stopped', conversationId, code: code || 0, timestamp: Date.now() }); });
-    sendJSON(req, res, 200, { ok: true, agentId, pid: child.pid });
-  }
-
-  async function handleAgentUpdate(req, res, agentId) {
-    const updateCommands = { 'claude-code': { cmd: 'claude', args: ['update', '--yes'] } };
-    const updateCmd = updateCommands[agentId];
-    if (!updateCmd) { sendJSON(req, res, 400, { error: 'No update command for this agent' }); return; }
-    const conversationId = '__agent_update__';
-    if (activeScripts.has(conversationId)) { sendJSON(req, res, 409, { error: 'Update already running' }); return; }
-    const child = spawn(updateCmd.cmd, updateCmd.args, { stdio: ['pipe', 'pipe', 'pipe'], env: { ...process.env, FORCE_COLOR: '1' }, shell: os.platform() === 'win32' });
-    activeScripts.set(conversationId, { process: child, script: 'update-' + agentId, startTime: Date.now() });
-    broadcastSync({ type: 'script_started', conversationId, script: 'update-' + agentId, agentId, timestamp: Date.now() });
-    const onData = (stream) => (chunk) => broadcastSync({ type: 'script_output', conversationId, data: chunk.toString(), stream, timestamp: Date.now() });
-    child.stdout.on('data', onData('stdout'));
-    child.stderr.on('data', onData('stderr'));
-    child.stdout.on('error', () => {});
-    child.stderr.on('error', () => {});
-    child.on('error', (err) => { activeScripts.delete(conversationId); broadcastSync({ type: 'script_stopped', conversationId, code: 1, error: err.message, timestamp: Date.now() }); });
-    child.on('close', (code) => { activeScripts.delete(conversationId); modelCache.delete(agentId); broadcastSync({ type: 'script_stopped', conversationId, code: code || 0, timestamp: Date.now() }); });
-    sendJSON(req, res, 200, { ok: true, agentId, pid: child.pid });
-  }
-
-  return routes;
-}

package/lib/routes-auth-config.js

@@ -1,30 +0,0 @@
-export function register(deps) {
-  const { sendJSON, parseBody, getProviderConfigs, saveProviderConfig } = deps;
-
-  const routes = {};
-
-  routes['GET /api/auth/configs'] = (req, res) => {
-    sendJSON(req, res, 200, getProviderConfigs());
-  };
-
-  routes['POST /api/auth/save-config'] = async (req, res) => {
-    try {
-      const body = await parseBody(req);
-      const { providerId, apiKey, defaultModel } = body || {};
-      if (typeof providerId !== 'string' || !providerId.length || providerId.length > 100) { sendJSON(req, res, 400, { error: 'Invalid providerId' }); return; }
-      if (typeof apiKey !== 'string' || !apiKey.length || apiKey.length > 10000) { sendJSON(req, res, 400, { error: 'Invalid apiKey' }); return; }
-      if (defaultModel !== undefined && (typeof defaultModel !== 'string' || defaultModel.length > 200)) { sendJSON(req, res, 400, { error: 'Invalid defaultModel' }); return; }
-      const configPath = saveProviderConfig(providerId, apiKey, defaultModel || '');
-      sendJSON(req, res, 200, { success: true, path: configPath });
-    } catch (err) {
-      sendJSON(req, res, 400, { error: err.message });
-    }
-  };
-
-  routes['_match'] = (method, pathOnly) => {
-    const key = `${method} ${pathOnly}`;
-    return routes[key] || null;
-  };
-
-  return routes;
-}

package/lib/routes-conversations.js

@@ -1,96 +0,0 @@
-import path from 'path';
-import os from 'os';
-
-function expandTilde(p) { return p && p.startsWith('~') ? path.join(os.homedir(), p.slice(1)) : p; }
-
-export function register(deps) {
-  const { sendJSON, parseBody, queries, activeExecutions, broadcastSync } = deps;
-  const routes = {};
-
-  routes['GET /api/conversations'] = async (req, res) => {
-    const conversations = queries.getConversationsList();
-    for (const conv of conversations) {
-      if (conv.isStreaming && !activeExecutions.has(conv.id)) {
-        conv.isStreaming = 0;
-        try {
-          queries.setIsStreaming(conv.id, false);
-          for (const s of queries.getSessionsByConversation(conv.id, 5)) {
-            if (s.status === 'active' || s.status === 'pending') {
-              queries.updateSession(s.id, { status: 'interrupted', error: 'Reconciled: no active execution', completed_at: Date.now() });
-            }
-          }
-        } catch (err) { console.error(`[conv-list-reconcile] ${conv.id}:`, err.message); }
-      }
-    }
-    sendJSON(req, res, 200, { conversations });
-  };
-
-  routes['POST /api/conversations'] = async (req, res) => {
-    const body = await parseBody(req);
-    const normalizedWorkingDir = body.workingDirectory ? path.resolve(expandTilde(body.workingDirectory)) : null;
-    const conversation = queries.createConversation(body.agentId, body.title, normalizedWorkingDir, body.model || null);
-    queries.createEvent('conversation.created', { agentId: body.agentId, workingDirectory: conversation.workingDirectory, model: conversation.model }, conversation.id);
-    broadcastSync({ type: 'conversation_created', conversation });
-    sendJSON(req, res, 201, { conversation });
-  };
-
-  routes['GET /api/conversations/archived'] = async (req, res) => {
-    sendJSON(req, res, 200, { conversations: queries.getArchivedConversations() });
-  };
-
-  routes['_match'] = (method, pathOnly) => {
-    const key = `${method} ${pathOnly}`;
-    if (routes[key]) return routes[key];
-    let m;
-    if ((m = pathOnly.match(/^\/api\/conversations\/([^/]+)$/))) {
-      if (method === 'GET') return (req, res) => handleGetConv(req, res, m[1]);
-      if (method === 'POST' || method === 'PUT') return (req, res) => handleUpdateConv(req, res, m[1]);
-      if (method === 'DELETE') return (req, res) => handleDeleteConv(req, res, m[1]);
-    }
-    if (method === 'POST' && (m = pathOnly.match(/^\/api\/conversations\/([^/]+)\/archive$/)))
-      return (req, res) => handleArchive(req, res, m[1]);
-    if (method === 'POST' && (m = pathOnly.match(/^\/api\/conversations\/([^/]+)\/restore$/)))
-      return (req, res) => handleRestore(req, res, m[1]);
-    return null;
-  };
-
-  async function handleGetConv(req, res, id) {
-    const conv = queries.getConversation(id);
-    if (!conv) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
-    const latestSession = queries.getLatestSession(id);
-    sendJSON(req, res, 200, { conversation: conv, isActivelyStreaming: activeExecutions.has(id), latestSession });
-  }
-
-  async function handleUpdateConv(req, res, id) {
-    const body = await parseBody(req);
-    if (body.workingDirectory) body.workingDirectory = path.resolve(expandTilde(body.workingDirectory));
-    const conv = queries.updateConversation(id, body);
-    if (!conv) { sendJSON(req, res, 404, { error: 'Conversation not found' }); return; }
-    queries.createEvent('conversation.updated', body, id);
-    broadcastSync({ type: 'conversation_updated', conversation: conv });
-    sendJSON(req, res, 200, { conversation: conv });
-  }
-
-  async function handleDeleteConv(req, res, id) {
-    const deleted = queries.deleteConversation(id);
-    if (!deleted) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
-    broadcastSync({ type: 'conversation_deleted', conversationId: id });
-    sendJSON(req, res, 200, { deleted: true });
-  }
-
-  async function handleArchive(req, res, id) {
-    const conv = queries.archiveConversation(id);
-    if (!conv) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
-    broadcastSync({ type: 'conversation_updated', conversation: conv, archived: true });
-    sendJSON(req, res, 200, { conversation: conv });
-  }
-
-  async function handleRestore(req, res, id) {
-    const conv = queries.restoreConversation(id);
-    if (!conv) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
-    broadcastSync({ type: 'conversation_updated', conversation: conv, restored: true });
-    sendJSON(req, res, 200, { conversation: conv });
-  }
-
-  return routes;
-}

package/lib/routes-debug.js

@@ -1,119 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import * as execMachine from './execution-machine.js';
-import * as acpServerMachine from './acp-server-machine.js';
-
-function collectMachineSnapshots(activeExecutions) {
-  const execution = {};
-  for (const id of activeExecutions.keys()) {
-    const s = execMachine.snapshot(id);
-    if (s) execution[id] = { state: s.value, context: { pid: s.context.pid, sessionId: s.context.sessionId, queueLen: s.context.queue?.length } };
-  }
-  const acpServer = {};
-  for (const [id, actor] of acpServerMachine.getMachineActors()) {
-    const s = actor.getSnapshot();
-    acpServer[id] = { state: s.value, context: { pid: s.context.pid, healthy: s.context.healthy, startedAt: s.context.startedAt, lastUsed: s.context.lastUsed, restarts: s.context.restarts?.length || 0, providerInfo: s.context.providerInfo } };
-  }
-  return { execution, acpServer };
-}
-
-function readRecentErrors(errLogPath, limit = 50) {
-  try {
-    const raw = fs.readFileSync(errLogPath, 'utf8');
-    return raw.trim().split('\n').slice(-limit).map(l => { try { return JSON.parse(l); } catch { return l; } });
-  } catch { return []; }
-}
-
-export function register(deps) {
-  const { sendJSON, queries, activeExecutions, messageQueues, syncClients, wsOptimizer, _errLogPath } = deps;
-  const routes = {};
-
-  function snapshotExecutions() {
-    const o = {};
-    for (const [k, v] of activeExecutions) o[k] = { pid: v.pid, startTime: v.startTime, sessionId: v.sessionId, lastActivity: v.lastActivity };
-    return o;
-  }
-  function snapshotQueues() {
-    const o = {};
-    for (const [k, v] of messageQueues) o[k] = { length: v.length, messageIds: v.map(m => m.messageId) };
-    return o;
-  }
-  function snapshotWsClients() {
-    const out = [];
-    for (const ws of syncClients) out.push({ clientId: ws.clientId, subs: ws.subscriptions ? [...ws.subscriptions] : [] });
-    return out;
-  }
-  function streamingConvs() {
-    try { return queries.getConversationsList().filter(c => c.isStreaming).map(c => ({ id: c.id, isStreaming: c.isStreaming })); }
-    catch { return []; }
-  }
-
-  routes['GET /api/debug'] = async (req, res) => {
-    sendJSON(req, res, 200, {
-      activeExecutions: snapshotExecutions(),
-      messageQueues: snapshotQueues(),
-      streamingConversations: streamingConvs(),
-      wsClients: snapshotWsClients(),
-      recentErrors: readRecentErrors(_errLogPath, 20),
-    });
-  };
-
-  routes['GET /api/debug/state'] = async (req, res) => {
-    if (!process.env.DEBUG) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
-    sendJSON(req, res, 200, {
-      activeExecutions: snapshotExecutions(),
-      messageQueues: snapshotQueues(),
-      streamingConversations: streamingConvs(),
-      wsClients: snapshotWsClients(),
-      machines: collectMachineSnapshots(activeExecutions),
-      wsStats: wsOptimizer.getStats(),
-      recentErrors: readRecentErrors(_errLogPath, 50),
-      uptime: process.uptime(),
-      memory: process.memoryUsage(),
-    });
-  };
-
-  routes['GET /api/debug/machines'] = async (req, res) => {
-    if (!process.env.DEBUG) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
-    sendJSON(req, res, 200, collectMachineSnapshots(activeExecutions));
-  };
-
-  routes['GET /api/ws-stats'] = async (req, res) => {
-    sendJSON(req, res, 200, wsOptimizer.getStats());
-  };
-
-  routes['GET /api/debug/ws-stats'] = routes['GET /api/ws-stats'];
-
-  routes['GET /api/backup'] = async (req, res) => {
-    const dbPath = path.join(os.homedir(), '.gmgui', 'data.db');
-    if (!fs.existsSync(dbPath)) { sendJSON(req, res, 404, { error: 'Database not found' }); return; }
-    const stat = fs.statSync(dbPath);
-    res.writeHead(200, { 'Content-Type': 'application/octet-stream', 'Content-Disposition': 'attachment; filename="agentgui-backup.db"', 'Content-Length': stat.size });
-    fs.createReadStream(dbPath).pipe(res);
-  };
-
-  routes['POST /api/restore'] = async (req, res) => {
-    const dbPath = path.join(os.homedir(), '.gmgui', 'data.db');
-    const backupPath = dbPath + '.bak-' + Date.now();
-    const chunks = [];
-    req.on('data', (chunk) => chunks.push(chunk));
-    req.on('end', () => {
-      try {
-        const body = Buffer.concat(chunks);
-        if (body.length < 100 || body.slice(0, 16).toString() !== 'SQLite format 3\0') {
-          sendJSON(req, res, 400, { error: 'Invalid SQLite database file' }); return;
-        }
-        fs.copyFileSync(dbPath, backupPath);
-        fs.writeFileSync(dbPath, body);
-        sendJSON(req, res, 200, { success: true, backupPath, size: body.length });
-      } catch (e) {
-        sendJSON(req, res, 500, { error: e.message });
-      }
-    });
-  };
-
-  routes['_match'] = (method, pathOnly) => routes[`${method} ${pathOnly}`] || null;
-
-  return routes;
-}