agentgui 1.0.64 → 1.0.66

package/lib/types.ts

@@ -0,0 +1,245 @@
+/**
+ * TYPES.TS - Complete type definitions for the separated data and sync system
+ * Guarantees type safety across CLI tests, server, and client
+ * Immutable by design - all structures are readonly
+ */
+
+// ============================================================================
+// CONVERSATION TYPES
+// ============================================================================
+
+export interface Conversation {
+  readonly id: string;
+  readonly agentId: string;
+  readonly title: string | null;
+  readonly created_at: number;
+  readonly updated_at: number;
+  readonly status: ConversationStatus;
+  readonly agentType?: string;
+  readonly source?: 'gui' | 'imported';
+  readonly externalId?: string;
+  readonly firstPrompt?: string;
+  readonly messageCount?: number;
+  readonly projectPath?: string;
+  readonly gitBranch?: string;
+  readonly sourcePath?: string;
+  readonly lastSyncedAt?: number;
+}
+
+export type ConversationStatus = 'active' | 'archived' | 'deleted';
+
+export interface ConversationCreateInput {
+  agentId: string;
+  title?: string | null;
+}
+
+export interface ConversationUpdateInput {
+  title?: string;
+  status?: ConversationStatus;
+}
+
+// ============================================================================
+// MESSAGE TYPES
+// ============================================================================
+
+export interface Message {
+  readonly id: string;
+  readonly conversationId: string;
+  readonly role: MessageRole;
+  readonly content: string;
+  readonly created_at: number;
+}
+
+export type MessageRole = 'user' | 'assistant' | 'system';
+
+export interface MessageCreateInput {
+  conversationId: string;
+  role: MessageRole;
+  content: string;
+  idempotencyKey?: string;
+}
+
+// ============================================================================
+// SESSION TYPES (for message processing)
+// ============================================================================
+
+export interface Session {
+  readonly id: string;
+  readonly conversationId: string;
+  readonly status: SessionStatus;
+  readonly started_at: number;
+  readonly completed_at?: number;
+  readonly response?: SessionResponse;
+  readonly error?: string;
+}
+
+export type SessionStatus = 'pending' | 'processing' | 'completed' | 'error' | 'cancelled';
+
+export interface SessionResponse {
+  readonly text: string;
+  readonly messageId: string;
+}
+
+// ============================================================================
+// SYNC STATE TYPES
+// ============================================================================
+
+export type SyncState = 'idle' | 'loading' | 'synced' | 'error' | 'offline' | 'reconciling';
+
+export interface SyncStatus {
+  readonly state: SyncState;
+  readonly lastSyncTime?: number;
+  readonly nextRetryTime?: number;
+  readonly error?: string;
+  readonly retryCount: number;
+  readonly maxRetries: number;
+}
+
+export interface SyncEvent {
+  readonly type: SyncEventType;
+  readonly timestamp: number;
+  readonly data: Record<string, unknown>;
+}
+
+export type SyncEventType =
+  | 'conversation_created'
+  | 'conversation_updated'
+  | 'conversation_deleted'
+  | 'message_created'
+  | 'message_updated'
+  | 'message_deleted'
+  | 'sync_started'
+  | 'sync_completed'
+  | 'sync_failed'
+  | 'offline_detected'
+  | 'online_detected';
+
+// ============================================================================
+// PAGINATION TYPES
+// ============================================================================
+
+export interface PaginationParams {
+  readonly limit: number;
+  readonly offset: number;
+}
+
+export interface PaginatedResult<T> {
+  readonly items: readonly T[];
+  readonly total: number;
+  readonly limit: number;
+  readonly offset: number;
+  readonly hasMore: boolean;
+}
+
+// ============================================================================
+// IDEMPOTENCY TYPES
+// ============================================================================
+
+export interface IdempotencyKey {
+  readonly key: string;
+  readonly value: string;
+  readonly created_at: number;
+  readonly ttl: number;
+}
+
+// ============================================================================
+// ERROR TYPES
+// ============================================================================
+
+export class SyncError extends Error {
+  constructor(
+    public code: string,
+    public message: string,
+    public retryable: boolean = false,
+    public context?: Record<string, unknown>
+  ) {
+    super(message);
+    this.name = 'SyncError';
+  }
+}
+
+export type ErrorCode =
+  | 'DATABASE_ERROR'
+  | 'NETWORK_ERROR'
+  | 'SYNC_CONFLICT'
+  | 'VALIDATION_ERROR'
+  | 'NOT_FOUND'
+  | 'UNAUTHORIZED'
+  | 'TIMEOUT'
+  | 'UNKNOWN';
+
+// ============================================================================
+// STATE MACHINE CONTEXT
+// ============================================================================
+
+export interface SyncMachineContext {
+  readonly conversationId?: string;
+  readonly messageId?: string;
+  readonly lastError?: Error;
+  readonly retryCount: number;
+  readonly syncData: Record<string, unknown>;
+}
+
+// ============================================================================
+// API RESPONSE TYPES
+// ============================================================================
+
+export interface ApiResponse<T> {
+  readonly data?: T;
+  readonly error?: string;
+  readonly timestamp: number;
+}
+
+export interface ConversationsListResponse {
+  readonly conversations: readonly Conversation[];
+  readonly total: number;
+}
+
+export interface MessagesListResponse {
+  readonly messages: readonly Message[];
+  readonly total: number;
+  readonly hasMore: boolean;
+}
+
+// ============================================================================
+// VALIDATION RESULT TYPES
+// ============================================================================
+
+export interface ValidationResult {
+  readonly valid: boolean;
+  readonly errors: readonly ValidationError[];
+}
+
+export interface ValidationError {
+  readonly field: string;
+  readonly message: string;
+  readonly value?: unknown;
+}
+
+// ============================================================================
+// CONFLICT RESOLUTION TYPES
+// ============================================================================
+
+export type ConflictResolutionStrategy = 'last-write-wins' | 'server-wins' | 'client-wins';
+
+export interface ConflictInfo {
+  readonly localVersion: unknown;
+  readonly remoteVersion: unknown;
+  readonly resolution: ConflictResolutionStrategy;
+}
+
+// ============================================================================
+// RECOVERY TYPES
+// ============================================================================
+
+export interface RecoveryCheckpoint {
+  readonly timestamp: number;
+  readonly synced: boolean;
+  readonly data: Record<string, unknown>;
+}
+
+export interface RecoveryState {
+  readonly lastCheckpoint?: RecoveryCheckpoint;
+  readonly pendingOperations: readonly unknown[];
+  readonly offline: boolean;
+}

package/package.json

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

package/server.js

@@ -3,14 +3,9 @@ import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { WebSocketServer } from 'ws';
-import os from 'os';
 import { execSync } from 'child_process';
 import { queries } from './database.js';
-import ACPConnection from './acp-launcher.js';
-import { SessionStateStore } from './state-manager.js';
-import { StreamHandler } from './stream-handler.js';
-import { StateValidator } from './state-validator.js';
-import { getConversationSync } from './conversation-sync.js';
+import { runClaudeWithStreaming } from './lib/claude-runner.js';
 
 // Debug logging to file
 const debugLog = (msg) => {
@@ -26,71 +21,6 @@ const watch = process.argv.includes('--no-watch') ? false : (process.argv.includ
 const staticDir = path.join(__dirname, 'static');
 if (!fs.existsSync(staticDir)) fs.mkdirSync(staticDir, { recursive: true });
 
-// ACP connection pool keyed by agentId
-const acpPool = new Map();
-
-// Global session state store - tracks ALL prompt processing with explicit states
-const sessionStateStore = new SessionStateStore();
-
-// Periodic cleanup of old sessions
-setInterval(() => {
-  sessionStateStore.cleanup(3600000); // Clean sessions older than 1 hour
-}, 600000); // Run every 10 minutes
-
-/**
- * Get or create ACP connection with timeout protection
- */
-async function getACP(agentId, cwd) {
-  let conn = acpPool.get(agentId);
-  if (conn?.isRunning()) {
-    console.log(`[getACP] Returning cached connection for ${agentId}`);
-    return conn;
-  }
-
-  console.log(`[getACP] Creating new ACP connection for ${agentId}`);
-  conn = new ACPConnection();
-  const agentType = agentId === 'opencode' ? 'opencode' : 'claude-code';
-  
-  // Wrap entire init in timeout to prevent indefinite hangs
-  return Promise.race([
-    initializeACP(conn, agentType, cwd, agentId),
-    new Promise((_, reject) => 
-      setTimeout(() => reject(new Error('ACP initialization timeout (>60s)')), 60000)
-    )
-  ]);
-}
-
-/**
- * Initialize ACP with all steps
- */
-async function initializeACP(conn, agentType, cwd, agentId) {
-  try {
-    console.log(`[getACP] Step 1: Connecting to ${agentType}...`);
-    await conn.connect(agentType, cwd);
-    console.log(`[getACP] Step 2: Connected, initializing...`);
-    await conn.initialize();
-    console.log(`[getACP] Step 3: Initialized, creating session...`);
-    await conn.newSession(cwd);
-    console.log(`[getACP] Step 4: Session created, setting mode...`);
-    await conn.setSessionMode('bypassPermissions');
-    console.log(`[getACP] Step 5: Injecting skills...`);
-    // Inject system prompt to ensure HTML/RippleUI formatting
-    await conn.injectSkills();
-    console.log(`[getACP] Step 6: Injecting system context...`);
-    await conn.injectSystemContext();
-    console.log(`[getACP] Step 7: All initialization complete, caching connection`);
-    acpPool.set(agentId, conn);
-    console.log(`[getACP] ✅ ACP connection ready for ${agentId} in ${cwd}`);
-    return conn;
-  } catch (err) {
-    console.error(`[getACP] ❌ ERROR: Failed to initialize ACP connection for ${agentId}: ${err.message}`);
-    console.error(`[getACP] Stack: ${err.stack}`);
-    acpPool.delete(agentId);
-    if (conn) await conn.terminate();
-    throw new Error(`ACP initialization failed for ${agentId}: ${err.message}`);
-  }
-}
-
 function discoverAgents() {
   const agents = [];
   const binaries = [
@@ -199,13 +129,13 @@ const server = http.createServer(async (req, res) => {
         const idempotencyKey = body.idempotencyKey || null;
         const message = queries.createMessage(conversationId, 'user', body.content, idempotencyKey);
         queries.createEvent('message.created', { role: 'user', messageId: message.id }, conversationId);
-        broadcastSync({ type: 'message_created', conversationId, message });
+        broadcastSync({ type: 'message_created', conversationId, message, timestamp: Date.now() });
         const session = queries.createSession(conversationId);
         queries.createEvent('session.created', { messageId: message.id, sessionId: session.id }, conversationId, session.id);
          res.writeHead(201, { 'Content-Type': 'application/json' });
          res.end(JSON.stringify({ message, session, idempotencyKey }));
          // Fire-and-forget with proper error handling
-         processMessage(conversationId, message.id, session.id, body.content, body.agentId, body.folderContext)
+         processMessage(conversationId, message.id, body.content, body.agentId)
            .catch(err => debugLog(`[processMessage] Uncaught error: ${err.message}`));
          return;
       }
@@ -250,45 +180,6 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
-    // Diagnostics endpoint - shows ALL active and recent sessions
-    if (routePath === '/api/diagnostics/sessions' && req.method === 'GET') {
-      const diagnostics = sessionStateStore.getDiagnostics();
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify(diagnostics, null, 2));
-      return;
-    }
-
-    const streamUpdatesMatch = routePath.match(/^\/api\/sessions\/([^/]+)\/stream-updates$/);
-    if (streamUpdatesMatch && req.method === 'GET') {
-      const sessionId = streamUpdatesMatch[1];
-      const updates = queries.getSessionStreamUpdates(sessionId);
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ sessionId, updates, count: updates.length }));
-      return;
-    }
-
-    const stateRecoveryMatch = routePath.match(/^\/api\/sessions\/([^/]+)\/state-recovery$/);
-    if (stateRecoveryMatch && req.method === 'GET') {
-      const sessionId = stateRecoveryMatch[1];
-      const state = StateValidator.getSessionState(sessionId);
-      if (!state) {
-        res.writeHead(404, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Session not found' }));
-        return;
-      }
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify(state));
-      return;
-    }
-
-    const stateValidationMatch = routePath.match(/^\/api\/sessions\/([^/]+)\/validate$/);
-    if (stateValidationMatch && req.method === 'GET') {
-      const sessionId = stateValidationMatch[1];
-      const validation = StateValidator.validateSession(sessionId);
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify(validation));
-      return;
-    }
 
     if (routePath === '/api/import/claude-code' && req.method === 'GET') {
       const result = queries.importClaudeCodeConversations();
@@ -396,157 +287,90 @@ function serveFile(filePath, res) {
   });
 }
 
-/**
- * Process a user message through the Claude Code ACP with real-time streaming
- * Updates are persisted to database and broadcast to clients immediately
- */
-async function processMessage(conversationId, messageId, sessionId, content, agentId, folderContext) {
-  // Create state manager for this session
-  const stateManager = sessionStateStore.create(sessionId, conversationId, messageId, 120000);
-
+async function processMessage(conversationId, messageId, content, agentId) {
   try {
-    console.log(`[processMessage] Starting: conversationId=${conversationId}, sessionId=${sessionId}`);
-    console.log(`[processMessage] Initial state: ${stateManager.getState()}`);
-
-    // STATE: PENDING → ACQUIRING_ACP
-    stateManager.transition(stateManager.constructor.STATES.ACQUIRING_ACP, {
-      reason: 'Connecting to ACP',
-      data: {}
-    });
+    debugLog(`[processMessage] Starting: conversationId=${conversationId}, agentId=${agentId}`);
 
-    const cwd = folderContext?.path || '/config';
+    const cwd = '/config';
     const actualAgentId = agentId || 'claude-code';
 
-    try {
-      const conn = await getACP(actualAgentId, cwd);
-
-      // STATE: ACQUIRING_ACP → ACP_ACQUIRED
-      stateManager.transition(stateManager.constructor.STATES.ACP_ACQUIRED, {
-        reason: 'ACP connection established',
-        data: { acpConnectionTime: Date.now() }
-      });
-
-      // Create stream handler for real-time persistence and broadcasting
-      const streamHandler = new StreamHandler(sessionId, conversationId, broadcastSync);
-      let fullText = '';
-
-      // Setup response streaming
-      conn.onUpdate = (params) => {
-        streamHandler.handleUpdate(params, BASE_URL);
-        const u = params.update;
-        if (u?.sessionUpdate === 'agent_message_chunk' && u.content?.text) {
-          fullText += u.content.text;
-        }
-      };
-
-      // STATE: ACP_ACQUIRED → SENDING_PROMPT
-      stateManager.transition(stateManager.constructor.STATES.SENDING_PROMPT, {
-        reason: 'Sending prompt to ACP',
-        data: {}
-      });
-
-      console.log(`[processMessage] Sending prompt to ACP (${content.length} chars)`);
-      const result = await conn.sendPrompt(content);
-      conn.onUpdate = null;
-
-      // STATE: SENDING_PROMPT → PROCESSING
-      stateManager.transition(stateManager.constructor.STATES.PROCESSING, {
-        reason: 'ACP processing complete, formatting response',
-        data: { promptSentTime: Date.now(), responseReceivedTime: Date.now() }
-      });
-
-       console.log(`[processMessage] ACP returned: stopReason=${result?.stopReason}, streamUpdates=${streamHandler.getUpdateCount()}`);
-
-       // Save agent's complete response as-is, without any processing
-       // The agent workflow must flow naturally - no HTML extraction or interference
-       const responseText = fullText || result?.result || 'No response.';
-
-       const messageContent = {
-         text: responseText,
-         streamUpdatesCount: streamHandler.getUpdateCount()
-       };
-
-      // Save consolidated response to database
-      const assistantMessage = queries.createMessage(conversationId, 'assistant', messageContent);
-      queries.updateSession(sessionId, {
-        status: 'completed',
-        response: { text: responseText, messageId: assistantMessage.id },
-        completed_at: Date.now()
-      });
-      queries.createEvent('session.completed', { messageId: assistantMessage.id }, conversationId, sessionId);
+    debugLog(`[processMessage] Calling runClaudeWithStreaming with prompt: "${content.substring(0, 50)}..."`);
+    const outputs = await runClaudeWithStreaming(content, cwd, actualAgentId);
+    debugLog(`[processMessage] Claude returned ${outputs.length} outputs`);
+
+    // Collect all message blocks to preserve full execution details
+    let allBlocks = [];
+    let lastAssistantMessage = null;
+
+    for (const output of outputs) {
+      if (output.type === 'assistant' && output.message?.content) {
+        debugLog(`[processMessage] Found assistant message with ${output.message.content.length} content blocks`);
+        lastAssistantMessage = output.message;
+        allBlocks.push(...(output.message.content || []));
+      } else if (output.type === 'tool_result' && output.result) {
+        debugLog(`[processMessage] Found tool result: ${typeof output.result}`);
+        allBlocks.push({
+          type: 'tool_result',
+          result: output.result,
+          tool_use_id: output.tool_use_id
+        });
+      }
+    }
 
-      // Broadcast final consolidated response
-      broadcastSync({
-        type: 'session_updated',
-        sessionId,
-        status: 'completed',
-        message: assistantMessage
-      });
+    // Store full message structure if we have execution data, otherwise fallback to text
+    let messageContent = null;
 
-      // STATE: PROCESSING → COMPLETED
-      stateManager.transition(stateManager.constructor.STATES.COMPLETED, {
-        reason: 'Response successfully generated and saved',
-        data: {
-          responseLength: responseText.length,
-          messageId: assistantMessage.id,
-          streamUpdates: streamHandler.getUpdateCount()
-        }
+    if (allBlocks.length > 0) {
+      // Store full message structure as JSON for proper rendering
+      messageContent = JSON.stringify({
+        type: 'claude_execution',
+        blocks: allBlocks,
+        timestamp: Date.now()
       });
-
-      console.log(`[processMessage] ✅ Session completed with ${streamHandler.getUpdateCount()} stream updates: ${stateManager.getSummary().duration}`);
-
-    } catch (acpError) {
-      console.error(`[processMessage] ACP Error: ${acpError.message}`);
-      console.error(`[processMessage] Stack: ${acpError.stack}`);
-
-      // STATE: → ERROR
-      stateManager.transition(stateManager.constructor.STATES.ERROR, {
-        reason: `ACP error: ${acpError.message}`,
-        data: {
-          error: acpError.message,
-          stackTrace: acpError.stack
+      debugLog(`[processMessage] Storing full execution with ${allBlocks.length} blocks`);
+    } else {
+      // Fallback: extract text for simple responses
+      let textParts = [];
+      for (const output of outputs) {
+        if (typeof output === 'string') {
+          textParts.push(output);
+        } else if (output.text) {
+          textParts.push(output.text);
+        } else if (output.content?.text) {
+          textParts.push(output.content.text);
+        } else if (output.result) {
+          textParts.push(String(output.result));
         }
-      });
-
-      // Save error to database
-      const errorMsg = `ACP Error: ${acpError.message}`;
-      queries.createMessage(conversationId, 'assistant', errorMsg);
-      queries.updateSession(sessionId, { status: 'error', error: acpError.message, completed_at: Date.now() });
-      queries.createEvent('session.error', { error: acpError.message, stack: acpError.stack }, conversationId, sessionId);
-      broadcastSync({ type: 'session_updated', sessionId, status: 'error', error: acpError.message });
-
-      // Clean up ACP connection on error
-      acpPool.delete(actualAgentId);
-      throw acpError;
+      }
+      messageContent = textParts.join('\n').trim();
+      debugLog(`[processMessage] Storing text response: "${messageContent.substring(0, 100)}..."`);
     }
 
-  } catch (fatalError) {
-    console.error(`[processMessage] ❌ Fatal error: ${fatalError.message}`);
-    console.error(`[processMessage] Stack: ${fatalError.stack}`);
-
-    // Ensure state is in error
-    if (!stateManager.isTerminal()) {
-      stateManager.transition(stateManager.constructor.STATES.ERROR, {
-        reason: `Fatal error: ${fatalError.message}`,
-        data: {
-          error: fatalError.message,
-          stackTrace: fatalError.stack
-        }
+    if (messageContent) {
+      debugLog(`[processMessage] Creating assistant message`);
+      const assistantMessage = queries.createMessage(conversationId, 'assistant', messageContent);
+      debugLog(`[processMessage] Created message with id: ${assistantMessage.id}`);
+      broadcastSync({
+        type: 'message_created',
+        conversationId,
+        message: assistantMessage,
+        timestamp: Date.now()
       });
+    } else {
+      debugLog(`[processMessage] No response content extracted!`);
     }
 
-    // Log full state history for debugging
-    const summary = stateManager.getSummary();
-    console.error(`[processMessage] State history: ${JSON.stringify(summary, null, 2)}`);
-
-  } finally {
-    // Cleanup: remove from state store immediately (async to not block)
-    setImmediate(() => {
-      sessionStateStore.remove(sessionId);
+    debugLog(`[processMessage] ✅ Completed: ${outputs.length} outputs received`);
+  } catch (error) {
+    debugLog(`[processMessage] Error: ${error.message}`);
+    debugLog(`[processMessage] Stack: ${error.stack}`);
+    const errorMessage = queries.createMessage(conversationId, 'assistant', `Error: ${error.message}`);
+    broadcastSync({
+      type: 'message_created',
+      conversationId,
+      message: errorMessage,
+      timestamp: Date.now()
     });
-
-    // Log final state
-    console.log(`[processMessage] Final state: ${stateManager.getState()}`);
   }
 }
 
@@ -577,29 +401,8 @@ wss.on('connection', (ws, req) => {
         const data = JSON.parse(msg);
         if (data.type === 'subscribe') {
           ws.subscriptions.add(data.sessionId);
-          // On subscribe, send current state for recovery
-          const state = StateValidator.getSessionState(data.sessionId);
-          if (state) {
-            ws.send(JSON.stringify({
-              type: 'state_snapshot',
-              sessionId: data.sessionId,
-              state,
-              timestamp: Date.now()
-            }));
-          }
         } else if (data.type === 'unsubscribe') {
           ws.subscriptions.delete(data.sessionId);
-        } else if (data.type === 'recovery_request') {
-          // Client asking to recover from a checkpoint
-          const state = StateValidator.getSessionState(data.sessionId);
-          if (state) {
-            ws.send(JSON.stringify({
-              type: 'recovery_response',
-              sessionId: data.sessionId,
-              state,
-              timestamp: Date.now()
-            }));
-          }
         }
       } catch (e) {
         console.error('WebSocket message parse error:', e.message);
@@ -657,8 +460,6 @@ if (watch) {
 }
 
 process.on('SIGTERM', async () => {
-  for (const conn of acpPool.values()) await conn.terminate();
-  acpPool.clear();
   wss.close(() => server.close(() => process.exit(0)));
 });
 
@@ -685,13 +486,6 @@ function onServerReady() {
   // Then run it every 30 seconds (constant automatic importing)
   setInterval(performAutoImport, 30000);
 
-  // Start conversation sync to watch for changes
-  try {
-    const sync = getConversationSync();
-    sync.start();
-  } catch (err) {
-    console.error('[SERVER] Error starting conversation sync:', err.message);
-  }
 }
 
 function performAutoImport() {