@mrxkun/mcfast-mcp 3.5.12 → 4.0.1

package/src/memory/utils/sync-engine.js

@@ -0,0 +1,373 @@
+/**
+ * Sync Engine
+ * Local ↔ Cloud synchronization for memory
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+
+export class SyncEngine {
+  constructor(options = {}) {
+    this.memoryPath = options.memoryPath || path.join(os.homedir(), '.mcfast', 'memory');
+    this.cloudEndpoint = options.cloudEndpoint || null;
+    this.apiKey = options.apiKey || null;
+    this.syncInterval = options.syncInterval || 5 * 60 * 1000; // 5 minutes
+    this.lastSyncTime = null;
+    this.syncQueue = [];
+    this.isOnline = true;
+    this.isSyncing = false;
+    this.listeners = new Set();
+
+    // Check online status
+    if (typeof window !== 'undefined') {
+      this.isOnline = navigator.onLine;
+      window.addEventListener('online', () => this.handleOnline());
+      window.addEventListener('offline', () => this.handleOffline());
+    }
+  }
+
+  /**
+   * Initialize sync engine
+   */
+  async initialize() {
+    // Load last sync time
+    const syncMetaPath = path.join(this.memoryPath, '.sync-meta.json');
+    if (fs.existsSync(syncMetaPath)) {
+      try {
+        const meta = JSON.parse(fs.readFileSync(syncMetaPath, 'utf-8'));
+        this.lastSyncTime = meta.lastSyncTime || null;
+      } catch (e) {
+        console.warn('[SyncEngine] Failed to load sync metadata');
+      }
+    }
+
+    // Start periodic sync
+    this.startPeriodicSync();
+    
+    console.log(`[SyncEngine] Initialized. Last sync: ${this.lastSyncTime ? new Date(this.lastSyncTime).toISOString() : 'Never'}`);
+  }
+
+  /**
+   * Start periodic sync
+   */
+  startPeriodicSync() {
+    if (this.syncTimer) {
+      clearInterval(this.syncTimer);
+    }
+    
+    this.syncTimer = setInterval(() => {
+      this.sync().catch(err => {
+        console.warn('[SyncEngine] Periodic sync failed:', err.message);
+      });
+    }, this.syncInterval);
+  }
+
+  /**
+   * Stop periodic sync
+   */
+  stopPeriodicSync() {
+    if (this.syncTimer) {
+      clearInterval(this.syncTimer);
+      this.syncTimer = null;
+    }
+  }
+
+  /**
+   * Handle online event
+   */
+  handleOnline() {
+    console.log('[SyncEngine] Back online, triggering sync...');
+    this.isOnline = true;
+    this.sync().catch(err => console.warn('[SyncEngine] Sync after reconnect failed:', err.message));
+    this.emit('online');
+  }
+
+  /**
+   * Handle offline event
+   */
+  handleOffline() {
+    console.log('[SyncEngine] Went offline');
+    this.isOnline = false;
+    this.emit('offline');
+  }
+
+  /**
+   * Queue a change for sync
+   */
+  queueChange(change) {
+    const changeItem = {
+      ...change,
+      timestamp: Date.now(),
+      id: crypto.randomUUID()
+    };
+    
+    this.syncQueue.push(changeItem);
+    
+    // Persist queue
+    this.persistQueue();
+    
+    // Trigger immediate sync if online
+    if (this.isOnline) {
+      this.sync().catch(err => console.warn('[SyncEngine] Immediate sync failed:', err.message));
+    }
+  }
+
+  /**
+   * Persist sync queue to disk
+   */
+  persistQueue() {
+    const queuePath = path.join(this.memoryPath, '.sync-queue.json');
+    try {
+      fs.writeFileSync(queuePath, JSON.stringify(this.syncQueue));
+    } catch (e) {
+      console.warn('[SyncEngine] Failed to persist queue:', e.message);
+    }
+  }
+
+  /**
+   * Load persisted queue
+   */
+  loadQueue() {
+    const queuePath = path.join(this.memoryPath, '.sync-queue.json');
+    if (fs.existsSync(queuePath)) {
+      try {
+        this.syncQueue = JSON.parse(fs.readFileSync(queuePath, 'utf-8'));
+      } catch (e) {
+        this.syncQueue = [];
+      }
+    }
+  }
+
+  /**
+   * Perform sync
+   */
+  async sync() {
+    if (!this.isOnline || this.isSyncing || !this.cloudEndpoint) {
+      return { status: this.isOnline ? 'idle' : 'offline', queued: this.syncQueue.length };
+    }
+
+    this.isSyncing = true;
+    const startTime = Date.now();
+
+    try {
+      // 1. Get local changes since last sync
+      const localChanges = await this.getLocalChanges();
+      
+      // 2. Push local changes to cloud
+      if (localChanges.length > 0) {
+        await this.pushToCloud(localChanges);
+      }
+
+      // 3. Pull cloud changes
+      const cloudChanges = await this.pullFromCloud();
+      
+      // 4. Apply cloud changes to local
+      if (cloudChanges.length > 0) {
+        await this.applyCloudChanges(cloudChanges);
+      }
+
+      // 5. Update last sync time
+      this.lastSyncTime = Date.now();
+      this.saveSyncMeta();
+
+      // 6. Clear queue after successful sync
+      this.syncQueue = [];
+      this.persistQueue();
+
+      const duration = Date.now() - startTime;
+      const result = {
+        status: 'success',
+        pushed: localChanges.length,
+        pulled: cloudChanges.length,
+        duration: `${duration}ms`
+      };
+
+      console.log(`[SyncEngine] ✅ Sync complete:`, result);
+      this.emit('sync', result);
+      
+      return result;
+
+    } catch (error) {
+      console.error('[SyncEngine] ❌ Sync failed:', error.message);
+      this.emit('error', error);
+      throw error;
+    } finally {
+      this.isSyncing = false;
+    }
+  }
+
+  /**
+   * Get local changes since last sync
+   */
+  async getLocalChanges() {
+    this.loadQueue();
+    
+    const changes = [...this.syncQueue];
+    
+    // Also check for new/modified files
+    if (fs.existsSync(this.memoryPath)) {
+      const files = fs.readdirSync(this.memoryPath)
+        .filter(f => f.endsWith('.md') && !f.startsWith('.'));
+      
+      for (const file of files) {
+        const filePath = path.join(this.memoryPath, file);
+        const stats = fs.statSync(filePath);
+        
+        // If file modified after last sync
+        if (!this.lastSyncTime || stats.mtimeMs > this.lastSyncTime) {
+          const content = fs.readFileSync(filePath, 'utf-8');
+          changes.push({
+            type: 'file',
+            action: 'upsert',
+            path: file,
+            content,
+            timestamp: stats.mtimeMs
+          });
+        }
+      }
+    }
+
+    return changes;
+  }
+
+  /**
+   * Push changes to cloud
+   */
+  async pushToCloud(changes) {
+    const response = await fetch(`${this.cloudEndpoint}/sync/push`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        changes,
+        lastSyncTime: this.lastSyncTime
+      })
+    });
+
+    if (!response.ok) {
+      throw new Error(`Cloud push failed: ${response.status}`);
+    }
+
+    return response.json();
+  }
+
+  /**
+   * Pull changes from cloud
+   */
+  async pullFromCloud() {
+    const response = await fetch(`${this.cloudEndpoint}/sync/pull?since=${this.lastSyncTime || 0}`, {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${this.apiKey}`
+      }
+    });
+
+    if (!response.ok) {
+      throw new Error(`Cloud pull failed: ${response.status}`);
+    }
+
+    const data = await response.json();
+    return data.changes || [];
+  }
+
+  /**
+   * Apply cloud changes to local
+   */
+  async applyCloudChanges(changes) {
+    for (const change of changes) {
+      if (change.type === 'file') {
+        const filePath = path.join(this.memoryPath, change.path);
+        
+        if (change.action === 'delete') {
+          if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+          }
+        } else {
+          // Ensure directory exists
+          const dir = path.dirname(filePath);
+          if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+          }
+          fs.writeFileSync(filePath, change.content);
+        }
+      }
+    }
+  }
+
+  /**
+   * Save sync metadata
+   */
+  saveSyncMeta() {
+    const syncMetaPath = path.join(this.memoryPath, '.sync-meta.json');
+    fs.writeFileSync(syncMetaPath, JSON.stringify({
+      lastSyncTime: this.lastSyncTime,
+      updatedAt: new Date().toISOString()
+    }));
+  }
+
+  /**
+   * Force full resync
+   */
+  async fullResync() {
+    this.lastSyncTime = 0;
+    this.saveSyncMeta();
+    return this.sync();
+  }
+
+  /**
+   * Get sync status
+   */
+  getStatus() {
+    return {
+      isOnline: this.isOnline,
+      isSyncing: this.isSyncing,
+      lastSyncTime: this.lastSyncTime,
+      queueLength: this.syncQueue.length,
+      syncInterval: this.syncInterval
+    };
+  }
+
+  /**
+   * Add event listener
+   */
+  on(event, callback) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set());
+    }
+    this.listeners.get(event).add(callback);
+  }
+
+  /**
+   * Remove event listener
+   */
+  off(event, callback) {
+    if (this.listeners.has(event)) {
+      this.listeners.get(event).delete(callback);
+    }
+  }
+
+  /**
+   * Emit event
+   */
+  emit(event, data) {
+    if (this.listeners.has(event)) {
+      for (const callback of this.listeners.get(event)) {
+        callback(data);
+      }
+    }
+  }
+
+  /**
+   * Shutdown sync engine
+   */
+  shutdown() {
+    this.stopPeriodicSync();
+    this.persistQueue();
+  }
+}
+
+export default SyncEngine;