agentgui 1.0.67 → 1.0.69

package/lib/database-service.ts

@@ -15,6 +15,8 @@ import {
   ValidationResult,
   ValidationError,
   SyncError,
+  ExecutionMetadata,
+  StreamingEvent,
 } from './types';
 import {
   validateConversation,
@@ -369,6 +371,256 @@ export class DatabaseService {
     return { valid: errors.length === 0, errors };
   }
 
+  // =========================================================================
+  // STREAMING EXECUTION OPERATIONS
+  // =========================================================================
+
+  storeExecutionEvent(sessionId: string, event: StreamingEvent): void {
+    this.checkClosed();
+
+    try {
+      const stmt = this.db.prepare(
+        'INSERT INTO execution_events (sessionId, eventType, eventData, timestamp) VALUES (?, ?, ?, ?)'
+      );
+      stmt.run(sessionId, event.type, JSON.stringify(event), event.timestamp || Date.now());
+    } catch (err) {
+      throw new SyncError(
+        'DATABASE_ERROR',
+        `Failed to store execution event: ${(err as Error).message}`,
+        true,
+        { sessionId, eventType: event.type }
+      );
+    }
+  }
+
+  storeExecutionMetadata(sessionId: string, metadata: ExecutionMetadata): void {
+    this.checkClosed();
+
+    try {
+      const stmt = this.db.prepare(
+        'INSERT OR REPLACE INTO execution_metadata (sessionId, metadata, updated_at) VALUES (?, ?, ?)'
+      );
+      stmt.run(sessionId, JSON.stringify(metadata), Date.now());
+    } catch (err) {
+      throw new SyncError(
+        'DATABASE_ERROR',
+        `Failed to store execution metadata: ${(err as Error).message}`,
+        true,
+        { sessionId }
+      );
+    }
+  }
+
+  getSessionExecutionHistory(sessionId: string, limit = 1000, offset = 0): StreamingEvent[] {
+    this.checkClosed();
+
+    try {
+      const stmt = this.db.prepare(
+        'SELECT eventData FROM execution_events WHERE sessionId = ? ORDER BY timestamp ASC LIMIT ? OFFSET ?'
+      );
+      const rows = stmt.all(sessionId, limit, offset);
+
+      return rows.map((row) => {
+        try {
+          return JSON.parse(row.eventData);
+        } catch (e) {
+          console.warn('[DatabaseService] Invalid execution event JSON:', row.eventData);
+          return null;
+        }
+      }).filter((e): e is StreamingEvent => e !== null);
+    } catch (err) {
+      throw new SyncError(
+        'DATABASE_ERROR',
+        `Failed to get execution history: ${(err as Error).message}`,
+        true,
+        { sessionId, limit, offset }
+      );
+    }
+  }
+
+  getExecutionMetadata(sessionId: string): ExecutionMetadata | null {
+    this.checkClosed();
+
+    try {
+      const stmt = this.db.prepare('SELECT metadata FROM execution_metadata WHERE sessionId = ?');
+      const row = stmt.get(sessionId);
+
+      if (!row) return null;
+
+      try {
+        return JSON.parse(row.metadata);
+      } catch (e) {
+        throw new SyncError('VALIDATION_ERROR', `Invalid metadata JSON for session ${sessionId}`, false);
+      }
+    } catch (err) {
+      if (err instanceof SyncError) throw err;
+      throw new SyncError(
+        'DATABASE_ERROR',
+        `Failed to get execution metadata: ${(err as Error).message}`,
+        true,
+        { sessionId }
+      );
+    }
+  }
+
+  batchStoreExecutionEvents(sessionId: string, events: StreamingEvent[]): { count: number; latencyMs: number } {
+    this.checkClosed();
+
+    const startTime = Date.now();
+    try {
+      const transaction = this.db.transaction(() => {
+        const stmt = this.db.prepare(
+          'INSERT INTO execution_events (sessionId, eventType, eventData, timestamp) VALUES (?, ?, ?, ?)'
+        );
+
+        for (const event of events) {
+          stmt.run(sessionId, event.type, JSON.stringify(event), event.timestamp || Date.now());
+        }
+      });
+
+      transaction();
+      const latencyMs = Date.now() - startTime;
+
+      if (latencyMs > 100) {
+        console.warn(`[DatabaseService] Batch write latency ${latencyMs}ms for ${events.length} events`);
+      }
+
+      return { count: events.length, latencyMs };
+    } catch (err) {
+      if (err instanceof SyncError) throw err;
+      throw new SyncError(
+        'DATABASE_ERROR',
+        `Failed to batch store execution events: ${(err as Error).message}`,
+        true,
+        { sessionId, count: events.length }
+      );
+    }
+  }
+
+  batchStoreExecutionEventsOptimized(
+    sessionId: string,
+    events: StreamingEvent[],
+    commitInterval = 100
+  ): { count: number; batches: number; totalLatencyMs: number } {
+    this.checkClosed();
+
+    const startTime = Date.now();
+    let processedCount = 0;
+    let batchCount = 0;
+
+    try {
+      const stmt = this.db.prepare(
+        'INSERT INTO execution_events (sessionId, eventType, eventData, timestamp) VALUES (?, ?, ?, ?)'
+      );
+
+      // Process in batches with commit points
+      for (let i = 0; i < events.length; i += commitInterval) {
+        const batch = events.slice(i, i + commitInterval);
+        const transaction = this.db.transaction(() => {
+          for (const event of batch) {
+            stmt.run(sessionId, event.type, JSON.stringify(event), event.timestamp || Date.now());
+            processedCount++;
+          }
+        });
+
+        transaction();
+        batchCount++;
+
+        const elapsed = Date.now() - startTime;
+        if (elapsed > 5000) {
+          console.warn(`[DatabaseService] Long batch write: ${elapsed}ms for ${processedCount}/${events.length} events`);
+        }
+      }
+
+      const totalLatencyMs = Date.now() - startTime;
+      return { count: events.length, batches: batchCount, totalLatencyMs };
+    } catch (err) {
+      throw new SyncError(
+        'DATABASE_ERROR',
+        `Failed to batch store execution events (processed ${processedCount}/${events.length}): ${(err as Error).message}`,
+        true,
+        { sessionId, count: events.length, processed: processedCount }
+      );
+    }
+  }
+
+  markSessionIncomplete(sessionId: string, reason: string): void {
+    this.checkClosed();
+
+    try {
+      const stmt = this.db.prepare(
+        'UPDATE sessions SET status = ?, error = ?, completed_at = ? WHERE id = ?'
+      );
+      stmt.run('incomplete', reason, Date.now(), sessionId);
+    } catch (err) {
+      throw new SyncError(
+        'DATABASE_ERROR',
+        `Failed to mark session incomplete: ${(err as Error).message}`,
+        true,
+        { sessionId, reason }
+      );
+    }
+  }
+
+  getIncompleteSessionsOlderThan(ageMinutes = 30): Array<{ id: string; started_at: number }> {
+    this.checkClosed();
+
+    try {
+      const cutoffTime = Date.now() - (ageMinutes * 60 * 1000);
+      const stmt = this.db.prepare(
+        'SELECT id, started_at FROM sessions WHERE status = ? AND started_at < ?'
+      );
+      return stmt.all('incomplete', cutoffTime);
+    } catch (err) {
+      throw new SyncError(
+        'DATABASE_ERROR',
+        `Failed to get incomplete sessions: ${(err as Error).message}`,
+        true,
+        { ageMinutes }
+      );
+    }
+  }
+
+  markSessionComplete(sessionId: string, status: 'completed' | 'error' | 'timeout'): void {
+    this.checkClosed();
+
+    try {
+      const stmt = this.db.prepare(
+        'UPDATE sessions SET status = ?, completed_at = ? WHERE id = ?'
+      );
+      stmt.run(status, Date.now(), sessionId);
+    } catch (err) {
+      throw new SyncError(
+        'DATABASE_ERROR',
+        `Failed to mark session complete: ${(err as Error).message}`,
+        true,
+        { sessionId, status }
+      );
+    }
+  }
+
+  cleanupOrphanedSessions(maxAgeDays = 7): number {
+    this.checkClosed();
+
+    try {
+      const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
+      const cutoffTime = Date.now() - maxAgeMs;
+
+      const stmt = this.db.prepare(
+        'DELETE FROM sessions WHERE status NOT IN (?, ?, ?) AND started_at < ?'
+      );
+      const result = stmt.run('processing', 'pending', 'incomplete', cutoffTime);
+      return (result.changes || 0);
+    } catch (err) {
+      throw new SyncError(
+        'DATABASE_ERROR',
+        `Failed to cleanup orphaned sessions: ${(err as Error).message}`,
+        true,
+        { maxAgeDays }
+      );
+    }
+  }
+
   // =========================================================================
   // LIFECYCLE
   // =========================================================================

package/lib/sync-service.ts

@@ -13,6 +13,8 @@ import {
   SyncStatus,
   SyncError,
   ConflictResolutionStrategy,
+  StreamingEvent,
+  ExecutionMetadata,
 } from './types';
 import DatabaseService from './database-service';
 
@@ -313,6 +315,152 @@ export class SyncService extends EventEmitter {
     this.emit('operation:processed', op);
   }
 
+  // =========================================================================
+  // STREAMING EXECUTION SYNC
+  // =========================================================================
+
+  async syncSessionExecution(sessionId: string, events: StreamingEvent[]): Promise<SyncStatus> {
+    try {
+      this.emit('sync:start', { type: 'streaming', sessionId });
+
+      // Deduplicate by eventId (if present)
+      const dedupMap = new Map<string, StreamingEvent>();
+      for (const event of events) {
+        const key = event.eventId || `${event.type}:${event.timestamp}`;
+        dedupMap.set(key, event);
+      }
+
+      // Store all execution events in batch
+      const uniqueEvents = Array.from(dedupMap.values());
+      this.db.batchStoreExecutionEvents(sessionId, uniqueEvents);
+
+      this.emit('sync:complete', {
+        type: 'streaming',
+        sessionId,
+        eventCount: uniqueEvents.length,
+      });
+
+      return {
+        state: 'synced',
+        lastSyncTime: Date.now(),
+        retryCount: 0,
+        maxRetries: this.options.retryAttempts,
+      };
+    } catch (err) {
+      return this.handleSyncError(err as Error);
+    }
+  }
+
+  async syncExecutionMetadata(sessionId: string, metadata: ExecutionMetadata): Promise<SyncStatus> {
+    try {
+      this.emit('sync:start', { type: 'metadata', sessionId });
+
+      this.db.storeExecutionMetadata(sessionId, metadata);
+
+      this.emit('sync:complete', {
+        type: 'metadata',
+        sessionId,
+        metadata,
+      });
+
+      return {
+        state: 'synced',
+        lastSyncTime: Date.now(),
+        retryCount: 0,
+        maxRetries: this.options.retryAttempts,
+      };
+    } catch (err) {
+      return this.handleSyncError(err as Error);
+    }
+  }
+
+  async flushStreamingQueue(): Promise<{ flushed: number; failed: number; deduplicated: number }> {
+    if (this.pendingOperations.size === 0) {
+      return { flushed: 0, failed: 0, deduplicated: 0 };
+    }
+
+    const ops = Array.from(this.pendingOperations.values());
+    this.pendingOperations.clear();
+
+    // Dedup by operation key
+    const dedupMap = new Map<string, SyncEvent>();
+    let dedupCount = 0;
+    for (const op of ops) {
+      const key = `${op.type}:${op.data.id || op.data.sessionId || 'global'}`;
+      if (dedupMap.has(key)) {
+        dedupCount++;
+      } else {
+        dedupMap.set(key, op);
+      }
+    }
+
+    // Group by type for ordering preservation
+    const byType = new Map<string, SyncEvent[]>();
+    for (const op of dedupMap.values()) {
+      if (!byType.has(op.type)) byType.set(op.type, []);
+      byType.get(op.type)!.push(op);
+    }
+
+    // Sort by timestamp within each type
+    for (const events of byType.values()) {
+      events.sort((a, b) => a.timestamp - b.timestamp);
+    }
+
+    let flushed = 0;
+    let failed = 0;
+
+    for (const [type, events] of byType) {
+      for (const op of events) {
+        try {
+          await this.processOperation(op);
+          this.emit('queue:item_processed', op);
+          flushed++;
+        } catch (err) {
+          this.emit('queue:error', {
+            operation: op,
+            error: (err as Error).message,
+          });
+          this.queueOperation(op);
+          failed++;
+        }
+      }
+    }
+
+    this.emit('queue:flushed', { flushed, failed, deduplicated: dedupCount });
+    return { flushed, failed, deduplicated: dedupCount };
+  }
+
+  async flushStreamingQueueWithTimeout(timeoutMs = 30000): Promise<{ flushed: number; failed: number; timedOut: boolean }> {
+    const startTime = Date.now();
+    let flushed = 0;
+    let failed = 0;
+    let timedOut = false;
+
+    try {
+      while (this.pendingOperations.size > 0) {
+        const elapsed = Date.now() - startTime;
+        if (elapsed > timeoutMs) {
+          timedOut = true;
+          break;
+        }
+
+        const result = await this.flushStreamingQueue();
+        flushed += result.flushed;
+        failed += result.failed;
+
+        if (result.flushed === 0) break;
+      }
+    } catch (err) {
+      this.emit('queue:timeout', {
+        error: (err as Error).message,
+        flushed,
+        failed,
+      });
+    }
+
+    return { flushed, failed, timedOut };
+  }
+
   // =========================================================================
   // STATUS & INFO
   // =========================================================================
@@ -335,6 +483,133 @@ export class SyncService extends EventEmitter {
     this.retryAttempts = 0;
     this.lastSyncTime = 0;
   }
+
+  // =========================================================================
+  // RECOVERY & RESILIENCE
+  // =========================================================================
+
+  async recoverIncompleteStreams(): Promise<{ recovered: number; failed: number; timedOut: number }> {
+    try {
+      this.emit('recovery:start', { type: 'incomplete_streams' });
+
+      const incompleteSessionsOlderThan30Min = this.db.getIncompleteSessionsOlderThan(30);
+      let recovered = 0;
+      let failed = 0;
+      let timedOut = 0;
+
+      for (const session of incompleteSessionsOlderThan30Min) {
+        try {
+          const ageMinutes = (Date.now() - session.started_at) / (60 * 1000);
+
+          if (ageMinutes > 120) {
+            // 2 hour timeout
+            this.db.markSessionComplete(session.id, 'timeout');
+            timedOut++;
+            this.emit('recovery:timeout', { sessionId: session.id, ageMinutes });
+          } else {
+            // Mark for retry
+            this.queueOperation({
+              type: 'retry_incomplete_session',
+              timestamp: Date.now(),
+              data: { sessionId: session.id }
+            });
+            recovered++;
+            this.emit('recovery:queued', { sessionId: session.id });
+          }
+        } catch (err) {
+          failed++;
+          this.emit('recovery:error', {
+            sessionId: session.id,
+            error: (err as Error).message,
+          });
+        }
+      }
+
+      this.emit('recovery:complete', { recovered, failed, timedOut });
+      return { recovered, failed, timedOut };
+    } catch (err) {
+      this.emit('recovery:failed', { error: (err as Error).message });
+      return { recovered: 0, failed: 0, timedOut: 0 };
+    }
+  }
+
+  async resolveExecutionConflicts(
+    sessionId: string,
+    localMetadata: ExecutionMetadata,
+    remoteMetadata: ExecutionMetadata
+  ): Promise<ExecutionMetadata> {
+    try {
+      // Last-write-wins strategy: use the one with latest completion time
+      const localTime = localMetadata.endTime || 0;
+      const remoteTime = remoteMetadata.endTime || 0;
+
+      const winner = remoteTime >= localTime ? remoteMetadata : localMetadata;
+
+      // Merge metadata: take token counts from both, use max
+      const merged: ExecutionMetadata = {
+        ...winner,
+        inputTokens: Math.max(localMetadata.inputTokens || 0, remoteMetadata.inputTokens || 0),
+        outputTokens: Math.max(localMetadata.outputTokens || 0, remoteMetadata.outputTokens || 0),
+        totalTokens: Math.max(localMetadata.totalTokens || 0, remoteMetadata.totalTokens || 0),
+        toolCalls: Math.max(localMetadata.toolCalls, remoteMetadata.toolCalls),
+        toolResults: Math.max(localMetadata.toolResults, remoteMetadata.toolResults),
+        errorCount: Math.max(localMetadata.errorCount, remoteMetadata.errorCount),
+      };
+
+      this.db.storeExecutionMetadata(sessionId, merged);
+
+      this.emit('conflict:resolved', {
+        sessionId,
+        strategy: 'last-write-wins',
+        winner: remoteTime >= localTime ? 'remote' : 'local',
+        merged,
+      });
+
+      return merged;
+    } catch (err) {
+      this.emit('conflict:error', {
+        sessionId,
+        error: (err as Error).message,
+      });
+      throw err;
+    }
+  }
+
+  async detectAndResolveConflicts(): Promise<{ resolved: number; failed: number }> {
+    try {
+      this.emit('conflict:detection_start');
+
+      // This would scan for duplicate sessions with same conversation+timestamp
+      // For now, return placeholder
+      let resolved = 0;
+      let failed = 0;
+
+      this.emit('conflict:detection_complete', { resolved, failed });
+      return { resolved, failed };
+    } catch (err) {
+      this.emit('conflict:detection_failed', { error: (err as Error).message });
+      return { resolved: 0, failed: 0 };
+    }
+  }
+
+  async flushOfflineQueue(): Promise<{ flushed: number; failed: number; retried: number }> {
+    try {
+      this.emit('offline_queue:flush_start');
+
+      const result = await this.flushStreamingQueueWithTimeout(60000);
+
+      this.emit('offline_queue:flush_complete', {
+        flushed: result.flushed,
+        failed: result.failed,
+        timedOut: result.timedOut,
+      });
+
+      return { flushed: result.flushed, failed: result.failed, retried: 0 };
+    } catch (err) {
+      this.emit('offline_queue:flush_error', { error: (err as Error).message });
+      return { flushed: 0, failed: 0, retried: 0 };
+    }
+  }
 }
 
 export default SyncService;