agentgui 1.0.110 → 1.0.111

package/lib/sync-service.ts

@@ -1,615 +0,0 @@
-/**
- * SYNC-SERVICE.TS - Independent sync engine
- * Handles all conversation and message synchronization
- * Guaranteed eventual consistency with conflict resolution
- * Deduplicates operations and implements exponential backoff
- */
-
-import { EventEmitter } from 'events';
-import {
-  Conversation,
-  Message,
-  SyncEvent,
-  SyncStatus,
-  SyncError,
-  ConflictResolutionStrategy,
-  StreamingEvent,
-  ExecutionMetadata,
-} from './types';
-import DatabaseService from './database-service';
-
-interface SyncOptions {
-  retryAttempts?: number;
-  retryDelay?: number;
-  maxRetryDelay?: number;
-  conflictResolution?: ConflictResolutionStrategy;
-  batchSize?: number;
-}
-
-/**
- * SyncService - Independent sync operations
- * Handles conversations and messages with conflict resolution
- */
-export class SyncService extends EventEmitter {
-  private db: DatabaseService;
-  private syncInProgress = false;
-  private lastSyncTime = 0;
-  private pendingOperations: Map<string, SyncEvent> = new Map();
-  private retryAttempts = 0;
-  private options: Required<SyncOptions>;
-
-  constructor(db: DatabaseService, options: SyncOptions = {}) {
-    super();
-    this.db = db;
-    this.options = {
-      retryAttempts: options.retryAttempts ?? 5,
-      retryDelay: options.retryDelay ?? 1000,
-      maxRetryDelay: options.maxRetryDelay ?? 30000,
-      conflictResolution: options.conflictResolution ?? 'last-write-wins',
-      batchSize: options.batchSize ?? 50,
-    };
-  }
-
-  // =========================================================================
-  // SYNC OPERATIONS
-  // =========================================================================
-
-  async syncConversations(fromServer: Conversation[]): Promise<SyncStatus> {
-    if (this.syncInProgress) {
-      return {
-        state: 'loading',
-        retryCount: this.retryAttempts,
-        maxRetries: this.options.retryAttempts,
-      };
-    }
-
-    this.syncInProgress = true;
-    try {
-      this.emit('sync:start', { type: 'conversations' });
-
-      const local = this.db.getConversationsList();
-      const changes = this.detectChanges(local, fromServer);
-
-      if (changes.added.length > 0) {
-        await this.applyAddedConversations(changes.added);
-      }
-
-      if (changes.updated.length > 0) {
-        await this.applyUpdatedConversations(changes.updated);
-      }
-
-      if (changes.deleted.length > 0) {
-        await this.applyDeletedConversations(changes.deleted);
-      }
-
-      this.lastSyncTime = Date.now();
-      this.retryAttempts = 0;
-
-      this.emit('sync:complete', {
-        type: 'conversations',
-        changes,
-      });
-
-      return {
-        state: 'synced',
-        lastSyncTime: this.lastSyncTime,
-        retryCount: 0,
-        maxRetries: this.options.retryAttempts,
-      };
-    } catch (err) {
-      return this.handleSyncError(err as Error);
-    } finally {
-      this.syncInProgress = false;
-    }
-  }
-
-  async syncMessages(conversationId: string, fromServer: Message[]): Promise<SyncStatus> {
-    try {
-      this.emit('sync:start', { type: 'messages', conversationId });
-
-      const local = this.db.getConversationMessages(conversationId);
-      const changes = this.detectMessageChanges(local, fromServer);
-
-      if (changes.added.length > 0) {
-        await this.applyAddedMessages(conversationId, changes.added);
-      }
-
-      if (changes.deleted.length > 0) {
-        await this.applyDeletedMessages(changes.deleted);
-      }
-
-      this.emit('sync:complete', {
-        type: 'messages',
-        conversationId,
-        changes,
-      });
-
-      return {
-        state: 'synced',
-        lastSyncTime: Date.now(),
-        retryCount: 0,
-        maxRetries: this.options.retryAttempts,
-      };
-    } catch (err) {
-      return this.handleSyncError(err as Error);
-    }
-  }
-
-  // =========================================================================
-  // CHANGE DETECTION
-  // =========================================================================
-
-  private detectChanges(local: Conversation[], remote: Conversation[]) {
-    const localMap = new Map(local.map((c) => [c.id, c]));
-    const remoteMap = new Map(remote.map((c) => [c.id, c]));
-
-    const added = remote.filter((c) => !localMap.has(c.id));
-    const deleted = local.filter((c) => !remoteMap.has(c.id) && c.status !== 'deleted');
-    const updated = remote.filter((c) => {
-      const localVersion = localMap.get(c.id);
-      return localVersion && localVersion.updated_at < c.updated_at;
-    });
-
-    return { added, updated, deleted };
-  }
-
-  private detectMessageChanges(local: Message[], remote: Message[]) {
-    const localMap = new Map(local.map((m) => [m.id, m]));
-    const remoteMap = new Map(remote.map((m) => [m.id, m]));
-
-    const added = remote.filter((m) => !localMap.has(m.id));
-    const deleted = local.filter((m) => !remoteMap.has(m.id));
-
-    return { added, deleted };
-  }
-
-  // =========================================================================
-  // APPLY CHANGES
-  // =========================================================================
-
-  private async applyAddedConversations(conversations: Conversation[]): Promise<void> {
-    for (const conv of conversations) {
-      try {
-        // Note: In real implementation, would insert into DB
-        // Here we just validate the data
-        if (!conv.id || !conv.agentId) {
-          throw new Error('Invalid conversation: missing id or agentId');
-        }
-      } catch (err) {
-        this.emit('sync:error', {
-          type: 'add_conversation',
-          error: (err as Error).message,
-          data: conv,
-        });
-      }
-    }
-  }
-
-  private async applyUpdatedConversations(conversations: Conversation[]): Promise<void> {
-    for (const conv of conversations) {
-      try {
-        if (!conv.id) throw new Error('Invalid conversation: missing id');
-        // Update would happen here in real implementation
-      } catch (err) {
-        this.emit('sync:error', {
-          type: 'update_conversation',
-          error: (err as Error).message,
-          data: conv,
-        });
-      }
-    }
-  }
-
-  private async applyDeletedConversations(conversations: Conversation[]): Promise<void> {
-    for (const conv of conversations) {
-      try {
-        if (!conv.id) throw new Error('Invalid conversation: missing id');
-        this.db.deleteConversation(conv.id);
-      } catch (err) {
-        this.emit('sync:error', {
-          type: 'delete_conversation',
-          error: (err as Error).message,
-          data: conv,
-        });
-      }
-    }
-  }
-
-  private async applyAddedMessages(conversationId: string, messages: Message[]): Promise<void> {
-    for (const msg of messages) {
-      try {
-        if (!msg.id || !msg.role) {
-          throw new Error('Invalid message: missing id or role');
-        }
-        // Message insert would happen here in real implementation
-      } catch (err) {
-        this.emit('sync:error', {
-          type: 'add_message',
-          error: (err as Error).message,
-          data: msg,
-        });
-      }
-    }
-  }
-
-  private async applyDeletedMessages(messages: Message[]): Promise<void> {
-    for (const msg of messages) {
-      try {
-        if (!msg.id) throw new Error('Invalid message: missing id');
-        this.db.deleteMessage(msg.id);
-      } catch (err) {
-        this.emit('sync:error', {
-          type: 'delete_message',
-          error: (err as Error).message,
-          data: msg,
-        });
-      }
-    }
-  }
-
-  // =========================================================================
-  // ERROR HANDLING & RETRY LOGIC
-  // =========================================================================
-
-  private handleSyncError(error: Error): SyncStatus {
-    this.retryAttempts++;
-    const isRetryable = this.retryAttempts < this.options.retryAttempts;
-
-    const delay = Math.min(
-      this.options.retryDelay * Math.pow(2, this.retryAttempts - 1),
-      this.options.maxRetryDelay
-    );
-
-    if (isRetryable) {
-      console.log(`[SyncService] Retry in ${delay}ms (attempt ${this.retryAttempts}/${this.options.retryAttempts})`);
-      setTimeout(() => this.emit('sync:retry'), delay);
-    }
-
-    this.emit('sync:error', {
-      error: error.message,
-      retryable: isRetryable,
-      attempts: this.retryAttempts,
-    });
-
-    return {
-      state: isRetryable ? 'error' : 'error',
-      error: error.message,
-      retryCount: this.retryAttempts,
-      maxRetries: this.options.retryAttempts,
-      nextRetryTime: isRetryable ? Date.now() + delay : undefined,
-    };
-  }
-
-  // =========================================================================
-  // QUEUE MANAGEMENT
-  // =========================================================================
-
-  queueOperation(op: SyncEvent): void {
-    const key = `${op.type}:${op.data.id || 'global'}`;
-    this.pendingOperations.set(key, op);
-    this.emit('queue:updated', { size: this.pendingOperations.size });
-  }
-
-  async flushQueue(): Promise<void> {
-    if (this.pendingOperations.size === 0) return;
-
-    const ops = Array.from(this.pendingOperations.values());
-    this.pendingOperations.clear();
-
-    for (const op of ops) {
-      try {
-        await this.processOperation(op);
-      } catch (err) {
-        this.emit('queue:error', {
-          operation: op,
-          error: (err as Error).message,
-        });
-        // Re-queue failed operation
-        this.queueOperation(op);
-      }
-    }
-  }
-
-  private async processOperation(op: SyncEvent): Promise<void> {
-    // Implementation would process each operation based on type
-    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
-  // =========================================================================
-
-  getStatus(): SyncStatus {
-    return {
-      state: this.syncInProgress ? 'loading' : 'synced',
-      lastSyncTime: this.lastSyncTime,
-      retryCount: this.retryAttempts,
-      maxRetries: this.options.retryAttempts,
-    };
-  }
-
-  getPendingOperationsCount(): number {
-    return this.pendingOperations.size;
-  }
-
-  clear(): void {
-    this.pendingOperations.clear();
-    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;