agentgui 1.0.388 → 1.0.390

package/package.json

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

package/server.js

@@ -1447,6 +1447,56 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    // POST /runs/stream - Create stateless run and stream output (MUST be before generic /runs/:id route)
+    if (pathOnly === '/api/runs/stream' && req.method === 'POST') {
+      const body = await parseBody(req);
+      const { agent_id, input, config } = body;
+      if (!agent_id) {
+        sendJSON(req, res, 422, { error: 'agent_id is required' });
+        return;
+      }
+      const agent = discoveredAgents.find(a => a.id === agent_id);
+      if (!agent) {
+        sendJSON(req, res, 404, { error: 'Agent not found' });
+        return;
+      }
+      const run = queries.createRun(agent_id, null, input, config);
+      const sseManager = new SSEStreamManager(res, run.run_id);
+      sseManager.start();
+      sseManager.sendProgress({ type: 'run_created', run_id: run.run_id });
+
+      const eventHandler = (eventData) => {
+        if (eventData.sessionId === run.run_id || eventData.conversationId === run.thread_id) {
+          if (eventData.type === 'streaming_progress' && eventData.block) {
+            sseManager.sendProgress(eventData.block);
+          } else if (eventData.type === 'streaming_error') {
+            sseManager.sendError(eventData.error || 'Execution error');
+          } else if (eventData.type === 'streaming_complete') {
+            sseManager.sendComplete({ eventCount: eventData.eventCount }, { timestamp: eventData.timestamp });
+            sseManager.cleanup();
+          }
+        }
+      };
+
+      sseStreamHandlers.set(run.run_id, eventHandler);
+      req.on('close', () => {
+        sseStreamHandlers.delete(run.run_id);
+        sseManager.cleanup();
+      });
+
+      const statelessThreadId = queries.getRun(run.run_id)?.thread_id;
+      if (statelessThreadId) {
+        const conv = queries.getConversation(statelessThreadId);
+        if (conv && input?.content) {
+          runClaudeWithStreaming(agent_id, statelessThreadId, input.content, config?.model || null).catch((err) => {
+            sseManager.sendError(err.message);
+            sseManager.cleanup();
+          });
+        }
+      }
+      return;
+    }
+
     const oldRunByIdMatch = pathOnly.match(/^\/api\/runs\/([^/]+)$/);
     if (oldRunByIdMatch) {
     const runId = oldRunByIdMatch[1];
@@ -1918,59 +1968,6 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
-    if (pathOnly === '/api/runs/stream' && req.method === 'POST') {
-      const body = await parseBody(req);
-      const { agent_id, input, config } = body;
-      if (!agent_id) {
-        sendJSON(req, res, 422, { error: 'agent_id is required' });
-        return;
-      }
-      const agent = discoveredAgents.find(a => a.id === agent_id);
-      if (!agent) {
-        sendJSON(req, res, 404, { error: 'Agent not found' });
-        return;
-      }
-      const run = queries.createRun(agent_id, null, input, config);
-      const sseManager = new SSEStreamManager(res, run.run_id);
-      sseManager.start();
-      sseManager.sendProgress({ type: 'run_created', run_id: run.run_id });
-
-      const eventHandler = (eventData) => {
-        if (eventData.sessionId === run.run_id || eventData.conversationId === run.thread_id) {
-          if (eventData.type === 'streaming_progress' && eventData.block) {
-            sseManager.sendProgress(eventData.block);
-          } else if (eventData.type === 'streaming_error') {
-            sseManager.sendError(eventData.error || 'Execution error');
-          } else if (eventData.type === 'streaming_complete') {
-            sseManager.sendComplete({ eventCount: eventData.eventCount }, { timestamp: eventData.timestamp });
-            sseManager.cleanup();
-          }
-        }
-      };
-
-      sseStreamHandlers.set(run.run_id, eventHandler);
-      req.on('close', () => {
-        sseStreamHandlers.delete(run.run_id);
-        sseManager.cleanup();
-      });
-
-      const statelessThreadId = queries.getRun(run.run_id)?.thread_id;
-      if (statelessThreadId) {
-        const conv = queries.getConversation(statelessThreadId);
-        if (conv && input?.content) {
-          const session = queries.createSession(statelessThreadId);
-          acpQueries.updateRunStatus(run.run_id, 'active');
-          activeExecutions.set(statelessThreadId, { pid: null, startTime: Date.now(), sessionId: session.id, lastActivity: Date.now() });
-          activeProcessesByRunId.set(run.run_id, { threadId: statelessThreadId, sessionId: session.id });
-          queries.setIsStreaming(statelessThreadId, true);
-          processMessageWithStreaming(statelessThreadId, null, session.id, input.content, agent_id, config?.model || null)
-            .then(() => { acpQueries.updateRunStatus(run.run_id, 'success'); activeProcessesByRunId.delete(run.run_id); })
-            .catch((err) => { acpQueries.updateRunStatus(run.run_id, 'error'); activeProcessesByRunId.delete(run.run_id); sseManager.sendError(err.message); sseManager.cleanup(); });
-        }
-      }
-      return;
-    }
-
     if (pathOnly === '/api/runs/wait' && req.method === 'POST') {
       const body = await parseBody(req);
       const { agent_id, input, config } = body;
@@ -2234,15 +2231,11 @@ const server = http.createServer(async (req, res) => {
         }
 
         activeExecutions.delete(threadId);
+        activeProcessesByRunId.delete(runId);
         queries.setIsStreaming(threadId, false);
 
-        broadcastSync({
-          type: 'streaming_cancelled',
-          sessionId: execution?.sessionId || runId,
-          conversationId: threadId,
-          runId: runId,
-          timestamp: Date.now()
-        });
+        broadcastSync({ type: 'run_cancelled', runId, threadId, sessionId: execution?.sessionId, timestamp: Date.now() });
+        broadcastSync({ type: 'streaming_cancelled', sessionId: execution?.sessionId || runId, conversationId: threadId, runId, timestamp: Date.now() });
 
         sendJSON(req, res, 200, cancelledRun);
       } catch (err) {
@@ -2276,9 +2269,14 @@ const server = http.createServer(async (req, res) => {
       const startTime = Date.now();
       const pollInterval = setInterval(() => {
         const currentRun = queries.getRun(runId);
-        if (!currentRun || ['success', 'error', 'cancelled'].includes(currentRun.status) || (Date.now() - startTime) > 30000) {
+        const elapsed = Date.now() - startTime;
+        const done = currentRun && ['success', 'error', 'cancelled'].includes(currentRun.status);
+        if (done) {
           clearInterval(pollInterval);
-          sendJSON(req, res, 200, currentRun || run);
+          sendJSON(req, res, 200, currentRun);
+        } else if (elapsed > 30000) {
+          clearInterval(pollInterval);
+          sendJSON(req, res, 408, { error: 'Run still pending after 30s', run_id: runId, status: currentRun?.status || run.status });
         }
       }, 500);
       req.on('close', () => clearInterval(pollInterval));
@@ -3037,70 +3035,6 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
-    // POST /threads/{thread_id}/runs/{run_id}/cancel - Cancel a run on a thread
-    const threadRunCancelMatch = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})\/runs\/([a-f0-9-]{36})\/cancel$/);
-    if (threadRunCancelMatch && req.method === 'POST') {
-      const threadId = threadRunCancelMatch[1];
-      const runId = threadRunCancelMatch[2];
-      try {
-        const run = queries.getRun(runId);
-        if (!run || run.thread_id !== threadId) {
-          sendJSON(req, res, 404, { error: 'Run not found on thread', type: 'not_found' });
-          return;
-        }
-        if (['success', 'error', 'cancelled'].includes(run.status)) {
-          sendJSON(req, res, 409, { error: 'Run already completed or cancelled', type: 'conflict' });
-          return;
-        }
-        const cancelledRun = queries.cancelRun(runId);
-        const execution = activeExecutions.get(threadId);
-        if (execution?.pid) {
-          try { process.kill(-execution.pid, 'SIGTERM'); } catch { try { process.kill(execution.pid, 'SIGTERM'); } catch (e) {} }
-          setTimeout(() => {
-            try { process.kill(-execution.pid, 'SIGKILL'); } catch { try { process.kill(execution.pid, 'SIGKILL'); } catch (e) {} }
-          }, 3000);
-        }
-        if (execution?.sessionId) {
-          queries.updateSession(execution.sessionId, { status: 'error', error: 'Cancelled by user', completed_at: Date.now() });
-        }
-        activeExecutions.delete(threadId);
-        activeProcessesByRunId.delete(runId);
-        queries.setIsStreaming(threadId, false);
-        broadcastSync({ type: 'run_cancelled', runId, threadId, sessionId: execution?.sessionId, timestamp: Date.now() });
-        sendJSON(req, res, 200, cancelledRun);
-      } catch (err) {
-        sendJSON(req, res, 500, { error: err.message, type: 'internal_error' });
-      }
-      return;
-    }
-
-    // GET /threads/{thread_id}/runs/{run_id}/wait - Long-poll for run completion on thread
-    const threadRunWaitMatch = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})\/runs\/([a-f0-9-]{36})\/wait$/);
-    if (threadRunWaitMatch && req.method === 'GET') {
-      const threadId = threadRunWaitMatch[1];
-      const runId = threadRunWaitMatch[2];
-      const run = queries.getRun(runId);
-      if (!run || run.thread_id !== threadId) {
-        sendJSON(req, res, 404, { error: 'Run not found on thread', type: 'not_found' });
-        return;
-      }
-      const startTime = Date.now();
-      const pollInterval = setInterval(() => {
-        const currentRun = queries.getRun(runId);
-        const elapsed = Date.now() - startTime;
-        const done = currentRun && ['success', 'error', 'cancelled'].includes(currentRun.status);
-        if (done) {
-          clearInterval(pollInterval);
-          sendJSON(req, res, 200, currentRun);
-        } else if (elapsed > 30000) {
-          clearInterval(pollInterval);
-          sendJSON(req, res, 408, { error: 'Run still pending after 30s', run_id: runId, status: currentRun?.status || run.status });
-        }
-      }, 500);
-      req.on('close', () => clearInterval(pollInterval));
-      return;
-    }
-
     if (routePath.startsWith('/api/image/')) {
       const imagePath = routePath.slice('/api/image/'.length);
       const decodedPath = decodeURIComponent(imagePath);

package/test-cancel.mjs

@@ -1,185 +0,0 @@
-// Integration test for run cancellation and control
-import http from 'http';
-import { randomUUID } from 'crypto';
-import Database from 'better-sqlite3';
-import path from 'path';
-import os from 'os';
-import { createACPQueries } from './acp-queries.js';
-
-const dbPath = path.join(os.homedir(), '.gmgui', 'data.db');
-const db = new Database(dbPath);
-const prep = (sql) => db.prepare(sql);
-const acpQueries = createACPQueries(db, prep);
-
-const BASE_URL = 'http://localhost:3000/gm';
-const testResults = {
-  passed: [],
-  failed: []
-};
-
-function testPass(name) {
-  testResults.passed.push(name);
-  console.log(`✓ ${name}`);
-}
-
-function testFail(name, error) {
-  testResults.failed.push({ name, error });
-  console.log(`✗ ${name}: ${error}`);
-}
-
-async function makeRequest(method, path, body = null) {
-  return new Promise((resolve, reject) => {
-    const fullPath = `/gm${path}`;
-    const options = {
-      method,
-      hostname: 'localhost',
-      port: 3000,
-      path: fullPath,
-      headers: {
-        'Content-Type': 'application/json'
-      }
-    };
-
-    const req = http.request(options, (res) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => {
-        try {
-          const parsed = data ? JSON.parse(data) : null;
-          resolve({ status: res.statusCode, data: parsed, headers: res.headers });
-        } catch {
-          resolve({ status: res.statusCode, data: data, headers: res.headers });
-        }
-      });
-    });
-
-    req.on('error', reject);
-    if (body) req.write(JSON.stringify(body));
-    req.end();
-  });
-}
-
-async function runTests() {
-  console.log('=== RUNNING INTEGRATION TESTS ===\n');
-
-  try {
-    // Test 1: Create a thread
-    console.log('[Test 1] Creating thread...');
-    const threadResp = await makeRequest('POST', '/api/threads', {});
-    if ((threadResp.status === 200 || threadResp.status === 201) && threadResp.data.thread_id) {
-      testPass('Thread creation');
-    } else {
-      testFail('Thread creation', `Status ${threadResp.status}`);
-      return;
-    }
-
-    const threadId = threadResp.data.thread_id;
-
-    // Test 2: Create a run (stateless, without thread)
-    console.log('[Test 2] Creating stateless run...');
-    const runResp = await makeRequest('POST', '/api/runs', {
-      agent_id: 'claude-code',
-      input: 'test input'
-    });
-    if (runResp.status === 200 && runResp.data.run_id) {
-      testPass('Stateless run creation');
-    } else {
-      testFail('Stateless run creation', `Status ${runResp.status}`);
-      return;
-    }
-
-    const runId = runResp.data.run_id;
-
-    // Test 3: Verify run status is pending
-    console.log('[Test 3] Verifying run status...');
-    const run = acpQueries.getRun(runId);
-    if (run && run.status === 'pending') {
-      testPass('Run status is pending');
-    } else {
-      testFail('Run status is pending', `Status is ${run?.status}`);
-    }
-
-    // Test 4: Cancel the run using /api/runs/{run_id}/cancel
-    console.log('[Test 4] Cancelling run via /api/runs/{run_id}/cancel...');
-    const cancelResp = await makeRequest('POST', `/api/runs/${runId}/cancel`);
-    if (cancelResp.status === 200 && cancelResp.data.status === 'cancelled') {
-      testPass('Run cancellation via /api/runs');
-    } else {
-      testFail('Run cancellation via /api/runs', `Status ${cancelResp.status}, run status ${cancelResp.data?.status}`);
-    }
-
-    // Test 5: Verify run status is cancelled in database
-    console.log('[Test 5] Verifying cancelled status in DB...');
-    const cancelledRun = acpQueries.getRun(runId);
-    if (cancelledRun && cancelledRun.status === 'cancelled') {
-      testPass('Cancelled status persisted in database');
-    } else {
-      testFail('Cancelled status persisted in database', `Status is ${cancelledRun?.status}`);
-    }
-
-    // Test 6: Try to cancel again - should get 409 conflict
-    console.log('[Test 6] Testing 409 conflict on re-cancel...');
-    const recancel = await makeRequest('POST', `/api/runs/${runId}/cancel`);
-    if (recancel.status === 409) {
-      testPass('409 conflict on already-cancelled run');
-    } else {
-      testFail('409 conflict on already-cancelled run', `Got status ${recancel.status}`);
-    }
-
-    // Test 7: Test wait endpoint with already-completed run
-    console.log('[Test 7] Testing wait endpoint with completed run...');
-    const waitStart = Date.now();
-    const waitResp = await makeRequest('GET', `/api/runs/${runId}/wait`);
-    const waitDuration = Date.now() - waitStart;
-    if (waitResp.status === 200 && waitDuration < 5000) {
-      testPass('Wait endpoint returns immediately for completed run');
-    } else {
-      testFail('Wait endpoint returns immediately for completed run', `Took ${waitDuration}ms`);
-    }
-
-    // Test 8: Test cancellation of non-existent run
-    console.log('[Test 8] Testing 404 on non-existent run...');
-    const fakeRunId = randomUUID();
-    const notFound = await makeRequest('POST', `/api/runs/${fakeRunId}/cancel`);
-    if (notFound.status === 404) {
-      testPass('404 on non-existent run');
-    } else {
-      testFail('404 on non-existent run', `Got status ${notFound.status}`);
-    }
-
-    // Cleanup
-    console.log('\n[Cleanup] Deleting test thread...');
-    try {
-      acpQueries.deleteThread(threadId);
-      console.log('Cleanup complete');
-    } catch (e) {
-      console.log('Cleanup warning:', e.message);
-    }
-
-  } catch (error) {
-    console.error('Test suite error:', error);
-    testFail('Test suite execution', error.message);
-  }
-
-  db.close();
-
-  // Summary
-  console.log('\n=== TEST SUMMARY ===');
-  console.log(`Passed: ${testResults.passed.length}`);
-  console.log(`Failed: ${testResults.failed.length}`);
-  if (testResults.failed.length > 0) {
-    console.log('\nFailed tests:');
-    testResults.failed.forEach(f => console.log(`  - ${f.name}: ${f.error}`));
-  }
-
-  return testResults.passed.length > 0 && testResults.failed.length === 0;
-}
-
-// Run the tests
-runTests().then(success => {
-  console.log(`\n${success ? '✓ ALL TESTS PASSED' : '✗ SOME TESTS FAILED'}`);
-  process.exit(success ? 0 : 1);
-}).catch(err => {
-  console.error('Fatal test error:', err);
-  process.exit(1);
-});

package/verify-cancel-impl.mjs

@@ -1,119 +0,0 @@
-// Verify run cancellation implementation without needing running server
-import fs from 'fs';
-
-const serverContent = fs.readFileSync('/config/workspace/agentgui/server.js', 'utf-8');
-
-console.log('=== VERIFYING RUN CANCELLATION IMPLEMENTATION ===\n');
-
-const checks = [
-  {
-    name: 'Enhanced /api/runs/{run_id}/cancel endpoint',
-    test: () => {
-      const hasGetRun = serverContent.includes('acpQueries.getRun(runId)') || serverContent.includes('queries.getRun(runId)');
-      const hasStatusCheck = serverContent.includes("['success', 'error', 'cancelled'].includes");
-      const has409 = serverContent.includes('sendJSON(req, res, 409');
-      return hasGetRun && hasStatusCheck && has409;
-    }
-  },
-  {
-    name: 'Process termination with SIGTERM then SIGKILL',
-    test: () => {
-      const hasSigterm = serverContent.includes("process.kill(-execution.pid, 'SIGTERM')") ||
-                         serverContent.includes("process.kill(execution.pid, 'SIGTERM')");
-      const hasSigkill = serverContent.includes("'SIGKILL'");
-      const hasTimeout = serverContent.includes('setTimeout') && serverContent.includes('3000');
-      return hasSigterm && hasSigkill && hasTimeout;
-    }
-  },
-  {
-    name: 'WebSocket broadcast on cancellation',
-    test: () => {
-      return serverContent.includes("type: 'streaming_cancelled'") &&
-             serverContent.includes('broadcastSync');
-    }
-  },
-  {
-    name: 'Active executions cleanup',
-    test: () => {
-      return serverContent.includes('activeExecutions.delete(threadId)') &&
-             serverContent.includes('queries.setIsStreaming(threadId, false)');
-    }
-  },
-  {
-    name: 'Thread-based cancel endpoint /api/threads/{thread_id}/runs/{run_id}/cancel',
-    test: () => {
-      return serverContent.includes('threadRunCancelMatch') &&
-             serverContent.includes('/api/threads/([^/]+)/runs/([^/]+)/cancel');
-    }
-  },
-  {
-    name: 'Thread-based wait endpoint /api/threads/{thread_id}/runs/{run_id}/wait',
-    test: () => {
-      return serverContent.includes('threadRunWaitMatch') &&
-             serverContent.includes('/api/threads/([^/]+)/runs/([^/]+)/wait');
-    }
-  },
-  {
-    name: 'Wait endpoint long-polling (30s timeout, 500ms poll)',
-    test: () => {
-      const hasWait = serverContent.includes('/wait') && serverContent.includes('GET');
-      const hasPoll = serverContent.includes('setInterval') && serverContent.includes('500');
-      const hasTimeout = serverContent.includes('30000');
-      return hasWait && hasPoll && hasTimeout;
-    }
-  },
-  {
-    name: 'Thread validation in thread-based endpoints',
-    test: () => {
-      return serverContent.includes('run.thread_id !== threadId') &&
-             serverContent.includes('Run does not belong to specified thread');
-    }
-  },
-  {
-    name: 'Session status update on cancellation',
-    test: () => {
-      return serverContent.includes("status: 'error'") &&
-             serverContent.includes("error: 'Cancelled by user'");
-    }
-  },
-  {
-    name: 'Database run status update to cancelled',
-    test: () => {
-      const hasCancelRun = serverContent.includes('cancelRun(runId)') ||
-                           serverContent.includes('cancelledRun');
-      const hasUpdateStatus = serverContent.includes('updateRunStatus');
-      return hasCancelRun || hasUpdateStatus;
-    }
-  }
-];
-
-let passed = 0;
-let failed = 0;
-
-checks.forEach(check => {
-  try {
-    const result = check.test();
-    if (result) {
-      console.log(`✓ ${check.name}`);
-      passed++;
-    } else {
-      console.log(`✗ ${check.name}`);
-      failed++;
-    }
-  } catch (e) {
-    console.log(`✗ ${check.name} (error: ${e.message})`);
-    failed++;
-  }
-});
-
-console.log(`\n=== SUMMARY ===`);
-console.log(`Passed: ${passed}/${checks.length}`);
-console.log(`Failed: ${failed}/${checks.length}`);
-
-if (passed === checks.length) {
-  console.log('\n✓ ALL IMPLEMENTATION CHECKS PASSED');
-  process.exit(0);
-} else {
-  console.log('\n✗ SOME IMPLEMENTATION CHECKS FAILED');
-  process.exit(1);
-}