aios-core 4.1.0 → 4.2.0

package/.aios-core/development/scripts/backup-manager.js

@@ -1,607 +1,607 @@
-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, '.aios', '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}`);
-    }
-  }
-}
-
+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, '.aios', '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;