sinapse-ai 1.12.2 → 1.14.0

package/.sinapse-ai/development/scripts/backup-manager.js

@@ -1,607 +0,0 @@
-const fs = require('fs').promises;
-const path = require('path');
-const chalk = require('chalk');
-const crypto = require('crypto');
-const tar = require('tar');
-const { promisify } = require('util');
-const zlib = require('zlib');
-const _gzip = promisify(zlib.gzip);
-const _gunzip = promisify(zlib.gunzip);
-
-/**
- * Manages backups for safe self-modification rollback
- */
-class BackupManager {
-  constructor(options = {}) {
-    this.rootPath = options.rootPath || process.cwd();
-    this.backupDir = path.join(this.rootPath, '.sinapse', 'backup');
-    this.maxBackups = options.maxBackups || 10;
-    this.compressionLevel = options.compressionLevel || 6;
-    
-    // Active backup tracking
-    this.activeBackup = null;
-    
-    // Backup metadata
-    this.metadataFile = path.join(this.backupDir, 'backup-metadata.json');
-  }
-
-  /**
-   * Initialize backup system
-   * @returns {Promise<void>}
-   */
-  async initialize() {
-    try {
-      await fs.mkdir(this.backupDir, { recursive: true });
-      
-      // Initialize metadata if not exists
-      try {
-        await fs.access(this.metadataFile);
-      } catch {
-        await this.saveMetadata({
-          version: '1.0.0',
-          backups: [],
-          statistics: {
-            total_backups: 0,
-            successful_restores: 0,
-            failed_restores: 0,
-            total_size: 0
-          }
-        });
-      }
-    } catch (error) {
-      console.error(chalk.red(`Failed to initialize backup system: ${error.message}`));
-    }
-  }
-
-  /**
-   * Create full backup of specified files
-   * @param {Object} params - Backup parameters
-   * @returns {Promise<string>} Backup ID
-   */
-  async createFullBackup(params) {
-    const { files, metadata = {} } = params;
-    
-    await this.initialize();
-    
-    console.log(chalk.blue('📦 Creating backup...'));
-    
-    const backupId = this.generateBackupId();
-    const backupPath = path.join(this.backupDir, `${backupId}.tar.gz`);
-    const backupInfo = {
-      id: backupId,
-      timestamp: new Date().toISOString(),
-      files: files.map(f => path.relative(this.rootPath, f)),
-      metadata,
-      size: 0,
-      checksums: {},
-      compressed: true,
-      status: 'creating'
-    };
-
-    try {
-      // Create temporary directory for backup files
-      const tempDir = path.join(this.backupDir, `temp-${backupId}`);
-      await fs.mkdir(tempDir, { recursive: true });
-
-      // Copy files to temp directory maintaining structure
-      for (const file of files) {
-        const relPath = path.relative(this.rootPath, file);
-        const tempPath = path.join(tempDir, relPath);
-        
-        await fs.mkdir(path.dirname(tempPath), { recursive: true });
-        
-        try {
-          await fs.copyFile(file, tempPath);
-          
-          // Calculate checksum
-          const content = await fs.readFile(file);
-          const checksum = crypto.createHash('sha256').update(content).digest('hex');
-          backupInfo.checksums[relPath] = checksum;
-        } catch (error) {
-          console.warn(chalk.yellow(`Warning: Could not backup ${file}: ${error.message}`));
-        }
-      }
-
-      // Create backup manifest
-      await fs.writeFile(
-        path.join(tempDir, 'backup-manifest.json'),
-        JSON.stringify(backupInfo, null, 2)
-      );
-
-      // Create tar archive
-      await tar.create(
-        {
-          gzip: { level: this.compressionLevel },
-          file: backupPath,
-          cwd: tempDir
-        },
-        ['.']
-      );
-
-      // Get backup size
-      const stats = await fs.stat(backupPath);
-      backupInfo.size = stats.size;
-      backupInfo.status = 'completed';
-
-      // Clean up temp directory
-      await fs.rm(tempDir, { recursive: true, force: true });
-
-      // Update metadata
-      await this.addBackupToMetadata(backupInfo);
-      
-      // Set as active backup
-      this.activeBackup = backupId;
-      
-      // Clean old backups
-      await this.cleanOldBackups();
-
-      console.log(chalk.green(`✅ Backup created: ${backupId}`));
-      console.log(chalk.gray(`   Files: ${files.length}, Size: ${this.formatSize(backupInfo.size)}`));
-
-      return backupId;
-
-    } catch (error) {
-      // Clean up on failure
-      try {
-        await fs.unlink(backupPath);
-      } catch {}
-      
-      throw new Error(`Backup creation failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Restore backup
-   * @param {string} backupId - Backup ID to restore
-   * @param {Object} options - Restore options
-   * @returns {Promise<Object>} Restore result
-   */
-  async restoreBackup(backupId, options = {}) {
-    const { targetPath = this.rootPath, dryRun = false } = options;
-    
-    console.log(chalk.blue(`🔄 Restoring backup: ${backupId}`));
-    
-    const result = {
-      success: true,
-      backupId,
-      restored_files: [],
-      failed_files: [],
-      warnings: []
-    };
-
-    try {
-      // Load backup metadata
-      const metadata = await this.loadMetadata();
-      const backupInfo = metadata.backups.find(b => b.id === backupId);
-      
-      if (!backupInfo) {
-        throw new Error(`Backup not found: ${backupId}`);
-      }
-
-      const backupPath = path.join(this.backupDir, `${backupId}.tar.gz`);
-      
-      // Verify backup exists
-      try {
-        await fs.access(backupPath);
-      } catch {
-        throw new Error(`Backup file missing: ${backupPath}`);
-      }
-
-      // Create restore temp directory
-      const restoreTemp = path.join(this.backupDir, `restore-${Date.now()}`);
-      await fs.mkdir(restoreTemp, { recursive: true });
-
-      // Extract backup
-      await tar.extract({
-        file: backupPath,
-        cwd: restoreTemp
-      });
-
-      // Load manifest
-      const manifestPath = path.join(restoreTemp, 'backup-manifest.json');
-      const manifest = JSON.parse(await fs.readFile(manifestPath, 'utf-8'));
-
-      // Verify checksums
-      for (const [relPath, expectedChecksum] of Object.entries(manifest.checksums)) {
-        const tempFile = path.join(restoreTemp, relPath);
-        try {
-          const content = await fs.readFile(tempFile);
-          const actualChecksum = crypto.createHash('sha256').update(content).digest('hex');
-          
-          if (actualChecksum !== expectedChecksum) {
-            result.warnings.push(`Checksum mismatch for ${relPath}`);
-          }
-        } catch (error) {
-          result.warnings.push(`Could not verify ${relPath}: ${error.message}`);
-        }
-      }
-
-      if (!dryRun) {
-        // Restore files
-        for (const relPath of manifest.files) {
-          const sourcePath = path.join(restoreTemp, relPath);
-          const destPath = path.join(targetPath, relPath);
-          
-          try {
-            // Create backup of current file if it exists
-            try {
-              await fs.access(destPath);
-              await fs.copyFile(destPath, `${destPath}.pre-restore`);
-            } catch {}
-            
-            // Ensure directory exists
-            await fs.mkdir(path.dirname(destPath), { recursive: true });
-            
-            // Restore file
-            await fs.copyFile(sourcePath, destPath);
-            result.restored_files.push(relPath);
-            
-          } catch (error) {
-            result.failed_files.push({
-              file: relPath,
-              error: error.message
-            });
-            result.success = false;
-          }
-        }
-      }
-
-      // Clean up
-      await fs.rm(restoreTemp, { recursive: true, force: true });
-
-      // Update statistics
-      if (!dryRun && result.success) {
-        metadata.statistics.successful_restores++;
-      } else if (!dryRun) {
-        metadata.statistics.failed_restores++;
-      }
-      await this.saveMetadata(metadata);
-
-      console.log(chalk.green(`✅ Restore ${dryRun ? 'preview' : 'completed'}`));
-      console.log(chalk.gray(`   Restored: ${result.restored_files.length} files`));
-      if (result.failed_files.length > 0) {
-        console.log(chalk.red(`   Failed: ${result.failed_files.length} files`));
-      }
-
-    } catch (error) {
-      result.success = false;
-      result.error = error.message;
-      console.error(chalk.red(`Restore failed: ${error.message}`));
-    }
-
-    return result;
-  }
-
-  /**
-   * Emergency restore - restores the last active backup
-   * @returns {Promise<Object>} Restore result
-   */
-  async emergencyRestore() {
-    console.log(chalk.red('🚨 EMERGENCY RESTORE INITIATED'));
-    
-    if (!this.activeBackup) {
-      // Find most recent backup
-      const metadata = await this.loadMetadata();
-      const backups = metadata.backups
-        .filter(b => b.status === 'completed')
-        .sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
-      
-      if (backups.length === 0) {
-        throw new Error('No backups available for emergency restore');
-      }
-      
-      this.activeBackup = backups[0].id;
-    }
-    
-    console.log(chalk.yellow(`Restoring backup: ${this.activeBackup}`));
-    return await this.restoreBackup(this.activeBackup);
-  }
-
-  /**
-   * List available backups
-   * @param {Object} filter - Filter options
-   * @returns {Promise<Array>} List of backups
-   */
-  async listBackups(filter = {}) {
-    const metadata = await this.loadMetadata();
-    let backups = metadata.backups;
-
-    // Apply filters
-    if (filter.status) {
-      backups = backups.filter(b => b.status === filter.status);
-    }
-    
-    if (filter.after) {
-      const afterDate = new Date(filter.after);
-      backups = backups.filter(b => new Date(b.timestamp) > afterDate);
-    }
-    
-    if (filter.metadata) {
-      backups = backups.filter(b => {
-        return Object.entries(filter.metadata).every(([key, value]) => 
-          b.metadata[key] === value
-        );
-      });
-    }
-
-    // Sort by timestamp (newest first)
-    backups.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
-
-    return backups.map(b => ({
-      id: b.id,
-      timestamp: b.timestamp,
-      files: b.files.length,
-      size: this.formatSize(b.size),
-      metadata: b.metadata,
-      isActive: b.id === this.activeBackup
-    }));
-  }
-
-  /**
-   * Delete specific backup
-   * @param {string} backupId - Backup ID to delete
-   * @returns {Promise<boolean>} Success status
-   */
-  async deleteBackup(backupId) {
-    try {
-      const backupPath = path.join(this.backupDir, `${backupId}.tar.gz`);
-      await fs.unlink(backupPath);
-      
-      // Remove from metadata
-      const metadata = await this.loadMetadata();
-      const index = metadata.backups.findIndex(b => b.id === backupId);
-      
-      if (index !== -1) {
-        const backup = metadata.backups[index];
-        metadata.statistics.total_size -= backup.size;
-        metadata.backups.splice(index, 1);
-        await this.saveMetadata(metadata);
-      }
-      
-      // Clear active backup if deleted
-      if (this.activeBackup === backupId) {
-        this.activeBackup = null;
-      }
-      
-      console.log(chalk.gray(`Deleted backup: ${backupId}`));
-      return true;
-      
-    } catch (error) {
-      console.error(chalk.red(`Failed to delete backup: ${error.message}`));
-      return false;
-    }
-  }
-
-  /**
-   * Get backup details
-   * @param {string} backupId - Backup ID
-   * @returns {Promise<Object>} Backup details
-   */
-  async getBackupDetails(backupId) {
-    const metadata = await this.loadMetadata();
-    const backup = metadata.backups.find(b => b.id === backupId);
-    
-    if (!backup) {
-      throw new Error(`Backup not found: ${backupId}`);
-    }
-    
-    return backup;
-  }
-
-  /**
-   * Verify backup integrity
-   * @param {string} backupId - Backup ID to verify
-   * @returns {Promise<Object>} Verification result
-   */
-  async verifyBackup(backupId) {
-    console.log(chalk.blue(`🔍 Verifying backup: ${backupId}`));
-    
-    const result = {
-      valid: true,
-      backupId,
-      errors: [],
-      warnings: []
-    };
-
-    try {
-      const backupPath = path.join(this.backupDir, `${backupId}.tar.gz`);
-      
-      // Check file exists
-      try {
-        await fs.access(backupPath);
-      } catch {
-        result.valid = false;
-        result.errors.push('Backup file not found');
-        return result;
-      }
-
-      // Try to list archive contents
-      try {
-        const entries = [];
-        await tar.list({
-          file: backupPath,
-          onentry: entry => entries.push(entry.path)
-        });
-        
-        if (!entries.includes('./backup-manifest.json')) {
-          result.valid = false;
-          result.errors.push('Missing backup manifest');
-        }
-      } catch (error) {
-        result.valid = false;
-        result.errors.push(`Archive corrupted: ${error.message}`);
-      }
-
-    } catch (error) {
-      result.valid = false;
-      result.errors.push(`Verification failed: ${error.message}`);
-    }
-
-    return result;
-  }
-
-  /**
-   * Check if has active backup
-   * @returns {boolean}
-   */
-  hasActiveBackup() {
-    return this.activeBackup !== null;
-  }
-
-  /**
-   * Load metadata
-   * @private
-   */
-  async loadMetadata() {
-    try {
-      const content = await fs.readFile(this.metadataFile, 'utf-8');
-      return JSON.parse(content);
-    } catch {
-      return {
-        version: '1.0.0',
-        backups: [],
-        statistics: {
-          total_backups: 0,
-          successful_restores: 0,
-          failed_restores: 0,
-          total_size: 0
-        }
-      };
-    }
-  }
-
-  /**
-   * Save metadata
-   * @private
-   */
-  async saveMetadata(metadata) {
-    await fs.writeFile(
-      this.metadataFile,
-      JSON.stringify(metadata, null, 2)
-    );
-  }
-
-  /**
-   * Add backup to metadata
-   * @private
-   */
-  async addBackupToMetadata(backupInfo) {
-    const metadata = await this.loadMetadata();
-    
-    metadata.backups.push(backupInfo);
-    metadata.statistics.total_backups++;
-    metadata.statistics.total_size += backupInfo.size;
-    
-    await this.saveMetadata(metadata);
-  }
-
-  /**
-   * Clean old backups
-   * @private
-   */
-  async cleanOldBackups() {
-    const metadata = await this.loadMetadata();
-    const backups = metadata.backups
-      .filter(b => b.status === 'completed')
-      .sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
-
-    if (backups.length > this.maxBackups) {
-      const toDelete = backups.slice(this.maxBackups);
-      
-      for (const backup of toDelete) {
-        await this.deleteBackup(backup.id);
-      }
-      
-      console.log(chalk.gray(`Cleaned ${toDelete.length} old backups`));
-    }
-  }
-
-  /**
-   * Generate backup ID
-   * @private
-   */
-  generateBackupId() {
-    const timestamp = Date.now();
-    const random = crypto.randomBytes(4).toString('hex');
-    return `backup-${timestamp}-${random}`;
-  }
-
-  /**
-   * Format file size
-   * @private
-   */
-  formatSize(bytes) {
-    const units = ['B', 'KB', 'MB', 'GB'];
-    let size = bytes;
-    let unitIndex = 0;
-    
-    while (size >= 1024 && unitIndex < units.length - 1) {
-      size /= 1024;
-      unitIndex++;
-    }
-    
-    return `${size.toFixed(2)} ${units[unitIndex]}`;
-  }
-
-  /**
-   * Export backup for external storage
-   * @param {string} backupId - Backup ID to export
-   * @param {string} exportPath - Path to export to
-   * @returns {Promise<Object>} Export result
-   */
-  async exportBackup(backupId, exportPath) {
-    const backupPath = path.join(this.backupDir, `${backupId}.tar.gz`);
-    const metadataPath = path.join(this.backupDir, `${backupId}-metadata.json`);
-    
-    try {
-      // Copy backup file
-      await fs.copyFile(backupPath, exportPath);
-      
-      // Export metadata
-      const metadata = await this.getBackupDetails(backupId);
-      await fs.writeFile(
-        metadataPath,
-        JSON.stringify(metadata, null, 2)
-      );
-      
-      return {
-        success: true,
-        exported: exportPath,
-        metadata: metadataPath,
-        size: metadata.size
-      };
-      
-    } catch (error) {
-      throw new Error(`Export failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Import external backup
-   * @param {string} importPath - Path to backup file
-   * @param {Object} metadata - Backup metadata
-   * @returns {Promise<string>} Imported backup ID
-   */
-  async importBackup(importPath, metadata) {
-    const backupId = metadata.id || this.generateBackupId();
-    const backupPath = path.join(this.backupDir, `${backupId}.tar.gz`);
-    
-    try {
-      // Copy backup file
-      await fs.copyFile(importPath, backupPath);
-      
-      // Update metadata
-      metadata.id = backupId;
-      metadata.imported = new Date().toISOString();
-      
-      await this.addBackupToMetadata(metadata);
-      
-      return backupId;
-      
-    } catch (error) {
-      throw new Error(`Import failed: ${error.message}`);
-    }
-  }
-}
-
-module.exports = BackupManager;