agentgui 1.0.383 → 1.0.385

package/package.json

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

package/server.js

@@ -12,7 +12,8 @@ import { OAuth2Client } from 'google-auth-library';
 import express from 'express';
 import Busboy from 'busboy';
 import fsbrowse from 'fsbrowse';
-import { queries } from './database.js';
+import { queries, db, prepare } from './database.js';
+import { createACPQueries } from './acp-queries.js';
 import { runClaudeWithStreaming } from './lib/claude-runner.js';
 import { initializeDescriptors, getAgentDescriptor } from './lib/agent-descriptors.js';
 
@@ -340,6 +341,8 @@ function discoverAgents() {
 
 const discoveredAgents = discoverAgents();
 initializeDescriptors(discoveredAgents);
+const acpQueries = createACPQueries(db, prepare);
+acpQueries.getAgentDescriptor = getAgentDescriptor;
 
 const modelCache = new Map();
 
@@ -1512,7 +1515,7 @@ const server = http.createServer(async (req, res) => {
     }
 
     const oldRunCancelMatch = pathOnly.match(/^\/api\/runs\/([^/]+)\/cancel$/);
-    if (runCancelMatch && req.method === 'POST') {
+    if (oldRunCancelMatch && req.method === 'POST') {
       const runId = oldRunCancelMatch[1];
       const session = queries.getSession(runId);
       
@@ -2073,7 +2076,7 @@ const server = http.createServer(async (req, res) => {
     }
 
     const oldRunCancelMatch1 = pathOnly.match(/^\/api\/runs\/([^/]+)\/cancel$/);
-    if (runCancelMatch && req.method === 'POST') {
+    if (oldRunCancelMatch1 && req.method === 'POST') {
       const runId = oldRunCancelMatch1[1];
       try {
         const run = acpQueries.cancelRun(runId);
@@ -2323,573 +2326,6 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
-    const threadsMatch = pathOnly.match(/^\/api\/threads$/);
-    if (threadsMatch && req.method === 'POST') {
-      let body = '';
-      for await (const chunk of req) { body += chunk; }
-      let parsed = {};
-      try { parsed = body ? JSON.parse(body) : {}; } catch {}
-
-      const thread = queries.createConversation(parsed.agentId || 'claude-code', parsed.title || 'New Thread', parsed.workingDirectory || STARTUP_CWD);
-      sendJSON(req, res, 200, { 
-        id: thread.id, 
-        agentId: thread.agentId, 
-        title: thread.title,
-        created_at: thread.created_at,
-        status: thread.status,
-        state: null
-      });
-      return;
-    }
-
-    const threadsSearchMatch = pathOnly.match(/^\/api\/threads\/search$/);
-    if (threadsSearchMatch && req.method === 'POST') {
-      const conversations = queries.getConversations();
-      const threads = conversations.map(c => ({
-        id: c.id,
-        agentId: c.agentId,
-        title: c.title,
-        created_at: c.created_at,
-        updated_at: c.updated_at,
-        status: c.status,
-        state: null
-      }));
-      sendJSON(req, res, 200, threads);
-      return;
-    }
-
-    const oldThreadByIdMatch = pathOnly.match(/^\/api\/threads\/([^/]+)$/);
-    if (oldThreadByIdMatch) {
-    const threadId = oldThreadByIdMatch[1];
-      const conv = queries.getConversation(threadId);
-      
-      if (!conv) {
-        sendJSON(req, res, 404, { error: 'Thread not found' });
-        return;
-      }
-
-      if (req.method === 'GET') {
-        sendJSON(req, res, 200, {
-          id: conv.id,
-          agentId: conv.agentId,
-          title: conv.title,
-          created_at: conv.created_at,
-          updated_at: conv.updated_at,
-          status: conv.status,
-          state: null
-        });
-        return;
-      }
-
-      if (req.method === 'DELETE') {
-        const activeEntry = activeExecutions.get(threadId);
-        if (activeEntry) {
-          sendJSON(req, res, 409, { error: 'Thread has an active run, cannot delete' });
-          return;
-        }
-        queries.deleteConversation(threadId);
-        sendJSON(req, res, 204, {});
-        return;
-      }
-
-      if (req.method === 'PATCH') {
-        let body = '';
-        for await (const chunk of req) { body += chunk; }
-        let parsed = {};
-        try { parsed = body ? JSON.parse(body) : {}; } catch {}
-
-        const updates = {};
-        if (parsed.title !== undefined) updates.title = parsed.title;
-        if (parsed.state !== undefined) updates.state = parsed.state;
-        
-        if (Object.keys(updates).length > 0) {
-          queries.updateConversation(threadId, updates);
-        }
-        
-        const updated = queries.getConversation(threadId);
-        sendJSON(req, res, 200, {
-          id: updated.id,
-          agentId: updated.agentId,
-          title: updated.title,
-          created_at: updated.created_at,
-          updated_at: updated.updated_at,
-          status: updated.status,
-          state: updated.state
-        });
-        return;
-      }
-    }
-
-    const oldThreadHistoryMatch = pathOnly.match(/^\/api\/threads\/([^/]+)\/history$/);
-    if (threadHistoryMatch && req.method === 'GET') {
-      const threadId = oldThreadHistoryMatch[1];
-      const conv = queries.getConversation(threadId);
-      
-      if (!conv) {
-        sendJSON(req, res, 404, { error: 'Thread not found' });
-        return;
-      }
-
-      const limit = parseInt(new URL(req.url, 'http://localhost').searchParams.get('limit') || '10', 10);
-      const sessions = queries.getSessionsByConversation(threadId, limit);
-      
-      const history = sessions.map(s => ({
-        checkpoint: s.id,
-        state: null,
-        created_at: s.started_at,
-        runId: s.id,
-        status: s.status
-      })).reverse();
-
-      sendJSON(req, res, 200, history);
-      return;
-    }
-
-    const oldThreadCopyMatch = pathOnly.match(/^\/api\/threads\/([^/]+)\/copy$/);
-    if (threadCopyMatch && req.method === 'POST') {
-      const threadId = threadCopyMatch[1];
-      const original = queries.getConversation(threadId);
-      
-      if (!original) {
-        sendJSON(req, res, 404, { error: 'Thread not found' });
-        return;
-      }
-
-      const newThread = queries.createConversation(original.agentId, original.title + ' (copy)', original.workingDirectory);
-
-      const messages = queries.getMessages(threadId, 1000, 0);
-      for (const msg of messages) {
-        queries.createMessage(newThread.id, msg.role, msg.content);
-      }
-
-      sendJSON(req, res, 200, {
-        id: newThread.id,
-        agentId: newThread.agentId,
-        title: newThread.title,
-        created_at: newThread.created_at,
-        status: newThread.status,
-        state: null
-      });
-      return;
-    }
-
-    const threadRunsMatch = pathOnly.match(/^\/api\/threads\/([^/]+)\/runs$/);
-    if (threadRunsMatch) {
-      const threadId = threadRunsMatch[1];
-      const conv = queries.getConversation(threadId);
-      
-      if (!conv) {
-        sendJSON(req, res, 404, { error: 'Thread not found' });
-        return;
-      }
-
-      if (req.method === 'GET') {
-        const limit = parseInt(new URL(req.url, 'http://localhost').searchParams.get('limit') || '10', 10);
-        const offset = parseInt(new URL(req.url, 'http://localhost').searchParams.get('offset') || '0', 10);
-        const sessions = queries.getSessionsByConversation(threadId, limit, offset);
-        
-        const runs = sessions.map(s => ({
-          id: s.id,
-          threadId: s.conversationId,
-          status: s.status,
-          started_at: s.started_at,
-          completed_at: s.completed_at,
-          agentId: s.agentId,
-          input: null,
-          output: null
-        }));
-
-        sendJSON(req, res, 200, runs);
-        return;
-      }
-
-      if (req.method === 'POST') {
-        const activeEntry = activeExecutions.get(threadId);
-        if (activeEntry) {
-          sendJSON(req, res, 409, { error: 'Thread already has an active run' });
-          return;
-        }
-
-        let body = '';
-        for await (const chunk of req) { body += chunk; }
-        let parsed = {};
-        try { parsed = body ? JSON.parse(body) : {}; } catch {}
-
-        const { input, agentId, webhook } = parsed;
-        if (!input) {
-          sendJSON(req, res, 400, { error: 'Missing input in request body' });
-          return;
-        }
-
-        const resolvedAgentId = agentId || conv.agentId || 'claude-code';
-        const resolvedModel = parsed.model || conv.model || null;
-        const cwd = conv.workingDirectory || STARTUP_CWD;
-
-        const session = queries.createSession(threadId, resolvedAgentId, 'pending');
-        const message = queries.createMessage(threadId, 'user', typeof input === 'string' ? input : JSON.stringify(input));
-
-        processMessageWithStreaming(threadId, message.id, session.id, typeof input === 'string' ? input : JSON.stringify(input), resolvedAgentId, resolvedModel);
-
-        sendJSON(req, res, 200, {
-          id: session.id,
-          threadId: threadId,
-          status: 'pending',
-          started_at: session.started_at,
-          agentId: resolvedAgentId
-        });
-        return;
-      }
-    }
-
-    const threadRunsStreamMatch = pathOnly.match(/^\/api\/threads\/([^\/]+)\/runs\/stream$/);
-    if (threadRunsStreamMatch && req.method === 'POST') {
-      const threadId = threadRunsStreamMatch[1];
-      const conv = queries.getConversation(threadId);
-
-      if (!conv) {
-        sendJSON(req, res, 404, { error: 'Thread not found' });
-        return;
-      }
-
-      const activeEntry = activeExecutions.get(threadId);
-      if (activeEntry) {
-        sendJSON(req, res, 409, { error: 'Thread already has an active run' });
-        return;
-      }
-
-      let body = '';
-      for await (const chunk of req) { body += chunk; }
-      let parsed = {};
-      try { parsed = body ? JSON.parse(body) : {}; } catch {}
-
-      const { input, agentId } = parsed;
-      if (!input) {
-        sendJSON(req, res, 400, { error: 'Missing input in request body' });
-        return;
-      }
-
-      const resolvedAgentId = agentId || conv.agentId || 'claude-code';
-      const resolvedModel = parsed.model || conv.model || null;
-
-      const session = queries.createSession(threadId, resolvedAgentId, 'pending');
-      const message = queries.createMessage(threadId, 'user', typeof input === 'string' ? input : JSON.stringify(input));
-
-      res.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        'Connection': 'keep-alive'
-      });
-
-      const eventListeners = [];
-      const broadcastListener = (event) => {
-        if (event.sessionId === session.id) {
-          if (event.type === 'streaming_progress') {
-            res.write(`event: message\ndata: ${JSON.stringify(event)}\n\n`);
-          } else if (event.type === 'streaming_complete') {
-            res.write(`event: done\ndata: ${JSON.stringify({ status: 'completed' })}\n\n`);
-            res.end();
-          } else if (event.type === 'streaming_error') {
-            res.write(`event: error\ndata: ${JSON.stringify({ error: event.error })}\n\n`);
-            res.end();
-          }
-        }
-      };
-      eventListeners.push(broadcastListener);
-
-      req.on('close', () => {
-        eventListeners.length = 0;
-      });
-
-      processMessageWithStreaming(threadId, message.id, session.id, typeof input === 'string' ? input : JSON.stringify(input), resolvedAgentId, resolvedModel);
-      return;
-    }
-
-    const threadRunsWaitMatch = pathOnly.match(/^\/api\/threads\/([^\/]+)\/runs\/wait$/);
-    if (threadRunsWaitMatch && req.method === 'POST') {
-      const threadId = threadRunsWaitMatch[1];
-      const conv = queries.getConversation(threadId);
-
-      if (!conv) {
-        sendJSON(req, res, 404, { error: 'Thread not found' });
-        return;
-      }
-
-      const activeEntry = activeExecutions.get(threadId);
-      if (activeEntry) {
-        sendJSON(req, res, 409, { error: 'Thread already has an active run' });
-        return;
-      }
-
-      let body = '';
-      for await (const chunk of req) { body += chunk; }
-      let parsed = {};
-      try { parsed = body ? JSON.parse(body) : {}; } catch {}
-
-      const { input, agentId } = parsed;
-      if (!input) {
-        sendJSON(req, res, 400, { error: 'Missing input in request body' });
-        return;
-      }
-
-      const resolvedAgentId = agentId || conv.agentId || 'claude-code';
-      const resolvedModel = parsed.model || conv.model || null;
-
-      const session = queries.createSession(threadId, resolvedAgentId, 'pending');
-      const message = queries.createMessage(threadId, 'user', typeof input === 'string' ? input : JSON.stringify(input));
-
-      const waitPromise = new Promise((resolve, reject) => {
-        const checkInterval = setInterval(() => {
-          const updatedSession = queries.getSession(session.id);
-          if (!updatedSession) {
-            clearInterval(checkInterval);
-            reject(new Error('Session not found'));
-            return;
-          }
-          if (['success', 'error', 'interrupted', 'cancelled'].includes(updatedSession.status)) {
-            clearInterval(checkInterval);
-            resolve(updatedSession);
-          }
-        }, 500);
-
-        setTimeout(() => {
-          clearInterval(checkInterval);
-          const updatedSession = queries.getSession(session.id);
-          resolve(updatedSession || session);
-        }, 300000);
-      });
-
-      processMessageWithStreaming(threadId, message.id, session.id, typeof input === 'string' ? input : JSON.stringify(input), resolvedAgentId, resolvedModel);
-
-      try {
-        const completedSession = await waitPromise;
-        sendJSON(req, res, 200, {
-          id: completedSession.id,
-          threadId: threadId,
-          status: completedSession.status,
-          started_at: completedSession.started_at,
-          completed_at: completedSession.completed_at,
-          agentId: resolvedAgentId,
-          output: completedSession.response || null
-        });
-      } catch (err) {
-        sendJSON(req, res, 500, { error: err.message });
-      }
-      return;
-    }
-
-
-    const threadRunByIdMatch = pathOnly.match(/^\/api\/threads\/([^/]+)\/runs\/([^/]+)$/);
-    if (threadRunByIdMatch) {
-      const threadId = threadRunByIdMatch[1];
-      const runId = threadRunByIdMatch[2];
-      const session = queries.getSession(runId);
-      
-      if (!session || session.conversationId !== threadId) {
-        sendJSON(req, res, 404, { error: 'Run not found' });
-        return;
-      }
-
-      if (req.method === 'GET') {
-        sendJSON(req, res, 200, {
-          id: session.id,
-          threadId: session.conversationId,
-          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(threadId);
-        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(threadId, 'user', typeof input === 'string' ? input : JSON.stringify(input));
-
-        processMessageWithStreaming(threadId, message.id, runId, typeof input === 'string' ? input : JSON.stringify(input), resolvedAgentId, resolvedModel);
-
-        sendJSON(req, res, 200, {
-          id: session.id,
-          threadId: threadId,
-          status: 'pending',
-          started_at: session.started_at,
-          agentId: resolvedAgentId
-        });
-        return;
-      }
-    }
-
-    const threadRunWaitMatch = pathOnly.match(/^\/api\/threads\/([^\/]+)\/runs\/([^\/]+)\/wait$/);
-    if (threadRunWaitMatch && req.method === 'GET') {
-      const threadId = threadRunWaitMatch[1];
-      const runId = threadRunWaitMatch[2];
-      const session = queries.getSession(runId);
-
-      if (!session || session.conversationId !== threadId) {
-        sendJSON(req, res, 404, { error: 'Run not found' });
-        return;
-      }
-
-      const waitPromise = new Promise((resolve) => {
-        const checkInterval = setInterval(() => {
-          const updatedSession = queries.getSession(runId);
-          if (!updatedSession) {
-            clearInterval(checkInterval);
-            resolve(session);
-            return;
-          }
-          if (['success', 'error', 'interrupted', 'cancelled'].includes(updatedSession.status)) {
-            clearInterval(checkInterval);
-            resolve(updatedSession);
-          }
-        }, 500);
-
-        setTimeout(() => {
-          clearInterval(checkInterval);
-          const updatedSession = queries.getSession(runId) || session;
-          resolve(updatedSession);
-        }, 30000);
-      });
-
-      try {
-        const completedSession = await waitPromise;
-        sendJSON(req, res, 200, {
-          id: completedSession.id,
-          threadId: threadId,
-          status: completedSession.status,
-          started_at: completedSession.started_at,
-          completed_at: completedSession.completed_at,
-          agentId: completedSession.agentId,
-          output: completedSession.response || null
-        });
-      } catch (err) {
-        sendJSON(req, res, 500, { error: err.message });
-      }
-      return;
-    }
-
-    const threadRunStreamMatch = pathOnly.match(/^\/api\/threads\/([^\/]+)\/runs\/([^\/]+)\/stream$/);
-    if (threadRunStreamMatch && req.method === 'GET') {
-      const threadId = threadRunStreamMatch[1];
-      const runId = threadRunStreamMatch[2];
-      const session = queries.getSession(runId);
-
-      if (!session || session.conversationId !== threadId) {
-        sendJSON(req, res, 404, { error: 'Run not found' });
-        return;
-      }
-
-      res.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        'Connection': 'keep-alive'
-      });
-
-      const chunks = queries.getSessionChunks(runId, 0);
-      for (const chunk of chunks) {
-        res.write(`event: message\ndata: ${JSON.stringify(chunk)}\n\n`);
-      }
-
-      const eventListeners = [];
-      const broadcastListener = (event) => {
-        if (event.sessionId === runId) {
-          if (event.type === 'streaming_progress') {
-            res.write(`event: message\ndata: ${JSON.stringify(event)}\n\n`);
-          } else if (event.type === 'streaming_complete') {
-            res.write(`event: done\ndata: ${JSON.stringify({ status: 'completed' })}\n\n`);
-            res.end();
-          } else if (event.type === 'streaming_error') {
-            res.write(`event: error\ndata: ${JSON.stringify({ error: event.error })}\n\n`);
-            res.end();
-          }
-        }
-      };
-      eventListeners.push(broadcastListener);
-
-      req.on('close', () => {
-        eventListeners.length = 0;
-      });
-
-      if (['success', 'error', 'interrupted', 'cancelled'].includes(session.status)) {
-        res.write(`event: done\ndata: ${JSON.stringify({ status: session.status })}\n\n`);
-        res.end();
-      }
-
-      return;
-    }
-
-
-    const threadRunCancelMatch = pathOnly.match(/^\/api\/threads\/([^/]+)\/runs\/([^/]+)\/cancel$/);
-    if (threadRunCancelMatch && req.method === 'POST') {
-      const threadId = threadRunCancelMatch[1];
-      const runId = threadRunCancelMatch[2];
-      const session = queries.getSession(runId);
-      
-      if (!session || session.conversationId !== threadId) {
-        sendJSON(req, res, 404, { error: 'Run not found' });
-        return;
-      }
-
-      const entry = activeExecutions.get(threadId);
-      
-      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(threadId, false);
-      activeExecutions.delete(threadId);
-
-      broadcastSync({
-        type: 'streaming_complete',
-        sessionId: runId,
-        conversationId: threadId,
-        interrupted: true,
-        timestamp: Date.now()
-      });
-
-      sendJSON(req, res, 204, {});
-      return;
-    }
-
     if (pathOnly === '/api/stt' && req.method === 'POST') {
       try {
         const chunks = [];
@@ -3198,7 +2634,7 @@ const server = http.createServer(async (req, res) => {
     // GET /threads/{thread_id} - Get thread by ID
     const acpThreadMatch = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})$/);
     if (acpThreadMatch && req.method === 'GET') {
-      const threadId = threadByIdMatch[1];
+      const threadId = acpThreadMatch[1];
       try {
         const thread = queries.getThread(threadId);
         if (!thread) {
@@ -3214,7 +2650,7 @@ const server = http.createServer(async (req, res) => {
 
     // PATCH /threads/{thread_id} - Update thread metadata
     if (acpThreadMatch && req.method === 'PATCH') {
-      const threadId = threadByIdMatch[1];
+      const threadId = acpThreadMatch[1];
       try {
         const body = await parseBody(req);
         const thread = queries.patchThread(threadId, body);
@@ -3231,7 +2667,7 @@ const server = http.createServer(async (req, res) => {
 
     // DELETE /threads/{thread_id} - Delete thread (fail if pending runs exist)
     if (acpThreadMatch && req.method === 'DELETE') {
-      const threadId = threadByIdMatch[1];
+      const threadId = acpThreadMatch[1];
       try {
         queries.deleteThread(threadId);
         res.writeHead(204);