agentgui 1.0.387 → 1.0.389

package/.prd

@@ -12,32 +12,6 @@ Transform AgentGUI into a fully ACP (Agent Connect Protocol) v0.2.3 compliant se
 
 ## Dependency Graph & Execution Waves
 
-### WAVE 3: Streaming & Run Control (2 items - after Wave 2)
-
-**3.1** SSE (Server-Sent Events) Streaming
-- BLOCKS: 2.1, 2.2, 2.3
-- BLOCKED_BY: 4.1
-- Implement SSE endpoint format (Content-Type: text/event-stream)
-- Stream run outputs as ACP `RunOutputStream` format
-- Support both `ValueRunResultUpdate` and `CustomRunResultUpdate` modes
-- Event types: data, error, done
-- Keep-alive pings every 15 seconds
-- Handle client disconnect gracefully
-- Convert existing chunk/event stream to SSE format
-- Parallel SSE + WebSocket support (both work simultaneously)
-
-**3.2** Run Cancellation & Control
-- BLOCKS: 1.1, 1.2
-- BLOCKED_BY: 4.1
-- Implement run status state machine: pending → active → completed/error/cancelled
-- Cancel endpoint kills agent process (SIGTERM then SIGKILL)
-- Update run status to 'cancelled' in database
-- Broadcast cancellation via WebSocket
-- Clean up active execution tracking
-- Return 409 if run already completed/cancelled
-- Wait endpoint implements long-polling (30s timeout, return current status)
-- Handle graceful degradation if agent doesn't support cancellation
-
 ### WAVE 4: UI Fixes & Optimization (3 items - after Wave 3)
 
 **4.1** Thread Sidebar UI Consistency

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.387",
+  "version": "1.0.389",
   "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;

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);
-});