@kadi.build/file-manager 1.0.0

package/src/providers/CompressionProvider.js

@@ -0,0 +1,968 @@
+import { promises as fs } from 'fs';
+import fsSync from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import archiver from 'archiver';
+import unzipper from 'unzipper';
+import tar from 'tar';
+import { EventEmitter } from 'events';
+
+class CompressionProvider extends EventEmitter {
+  constructor(config) {
+    super();
+    this.config = config || {};
+    this.localRoot = this.config.localRoot || process.cwd();
+    this.enabled = this.config.enabled !== false;
+    this.compressionLevel = this.config.level || 6;
+    this.defaultFormat = this.config.format || 'zip';
+    this.maxFileSize = this.config.maxFileSize || 1073741824; // 1GB
+    this.chunkSize = this.config.chunkSize || 8388608; // 8MB
+    this.enableProgressTracking = this.config.enableProgressTracking !== false;
+    this.enableChecksumVerification = this.config.enableChecksumVerification !== false;
+
+    this.activeOperations = new Map();
+    this.operationCount = 0;
+  }
+
+  // ============================================================================
+  // CONNECTION AND VALIDATION
+  // ============================================================================
+
+  async testConnection() {
+    try {
+      const stats = await fs.stat(this.localRoot);
+      if (!stats.isDirectory()) {
+        throw new Error(`Local root '${this.localRoot}' is not a directory`);
+      }
+
+      const testFile = path.join(this.localRoot, '.compression-provider-test');
+      await fs.writeFile(testFile, 'test');
+      await fs.unlink(testFile);
+
+      await this.testCompressionLibraries();
+
+      return {
+        provider: 'compression',
+        localRoot: this.localRoot,
+        enabled: this.enabled,
+        supportedFormats: ['zip', 'tar.gz'],
+        defaultFormat: this.defaultFormat,
+        compressionLevel: this.compressionLevel,
+        activeOperations: this.activeOperations.size,
+        enableProgressTracking: this.enableProgressTracking,
+        enableChecksumVerification: this.enableChecksumVerification
+      };
+    } catch (error) {
+      throw new Error(`Compression provider connection test failed: ${error.message}`);
+    }
+  }
+
+  async testCompressionLibraries() {
+    try {
+      const testArchiver = archiver('zip', { zlib: { level: 1 } });
+      if (!testArchiver) {
+        throw new Error('Archiver library not available');
+      }
+
+      if (!unzipper.Extract) {
+        throw new Error('Unzipper library not available');
+      }
+
+      if (!tar.create) {
+        throw new Error('Tar library not available');
+      }
+
+      return true;
+    } catch (error) {
+      throw new Error(`Compression library test failed: ${error.message}`);
+    }
+  }
+
+  validateConfig() {
+    const errors = [];
+    const warnings = [];
+
+    if (!this.localRoot) {
+      errors.push('Local root directory is required for compression operations');
+    }
+
+    if (this.compressionLevel < 0 || this.compressionLevel > 9) {
+      errors.push('Compression level must be between 0 and 9');
+    }
+
+    if (!['zip', 'tar.gz'].includes(this.defaultFormat)) {
+      errors.push('Default format must be either "zip" or "tar.gz"');
+    }
+
+    if (this.maxFileSize <= 0) {
+      errors.push('Max file size must be positive');
+    }
+
+    if (this.chunkSize <= 0) {
+      errors.push('Chunk size must be positive');
+    }
+
+    if (this.chunkSize > this.maxFileSize) {
+      warnings.push('Chunk size is larger than max file size');
+    }
+
+    if (!this.enabled) {
+      warnings.push('Compression operations are disabled');
+    }
+
+    if (this.compressionLevel > 6) {
+      warnings.push('High compression level (>6) may significantly impact performance');
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+
+  // ============================================================================
+  // PATH MANAGEMENT METHODS
+  // ============================================================================
+
+  normalizePath(inputPath) {
+    if (!inputPath || inputPath === '/') {
+      return this.localRoot;
+    }
+
+    if (path.isAbsolute(inputPath)) {
+      return path.normalize(inputPath);
+    }
+
+    const resolvedLocalRoot = path.resolve(this.localRoot);
+    return path.resolve(resolvedLocalRoot, inputPath);
+  }
+
+  validatePath(inputPath) {
+    if (!inputPath) {
+      throw new Error('Path cannot be empty');
+    }
+
+    if (/[<>:"|?*\x00-\x1f]/.test(inputPath)) {
+      throw new Error(`Path contains invalid characters: ${inputPath}`);
+    }
+
+    return true;
+  }
+
+  generateOperationId() {
+    this.operationCount++;
+    return `compress_${Date.now()}_${this.operationCount}`;
+  }
+
+  // ============================================================================
+  // COMPRESSION OPERATIONS
+  // ============================================================================
+
+  async compressFile(inputPath, outputPath, options = {}) {
+    if (!this.enabled) {
+      throw new Error('Compression operations are disabled in configuration');
+    }
+
+    this.validatePath(inputPath);
+    this.validatePath(outputPath);
+
+    const resolvedInputPath = this.normalizePath(inputPath);
+    const resolvedOutputPath = this.normalizePath(outputPath);
+
+    const {
+      format = this.defaultFormat,
+      level = this.compressionLevel,
+      includeRoot = false,
+      password = null
+    } = options;
+
+    const validatedLevel = Math.max(1, Math.min(9, parseInt(level) || this.compressionLevel));
+
+    const operationId = this.generateOperationId();
+
+    try {
+      const inputStats = await fs.stat(resolvedInputPath);
+
+      if (inputStats.isFile() && inputStats.size > this.maxFileSize) {
+        throw new Error(`File size ${this.formatBytes(inputStats.size)} exceeds maximum of ${this.formatBytes(this.maxFileSize)}`);
+      }
+
+      const outputDir = path.dirname(resolvedOutputPath);
+      await fs.mkdir(outputDir, { recursive: true });
+
+      this.activeOperations.set(operationId, {
+        type: 'compress',
+        inputPath: resolvedInputPath,
+        outputPath: resolvedOutputPath,
+        format,
+        level: validatedLevel,
+        startedAt: new Date().toISOString(),
+        progress: { processed: 0, total: 0 }
+      });
+
+      let result;
+
+      if (format === 'zip') {
+        result = await this.compressToZip(resolvedInputPath, resolvedOutputPath, {
+          level: validatedLevel,
+          includeRoot,
+          password,
+          operationId
+        });
+      } else if (format === 'tar.gz') {
+        result = await this.compressToTarGz(resolvedInputPath, resolvedOutputPath, {
+          level: validatedLevel,
+          includeRoot,
+          operationId
+        });
+      } else {
+        throw new Error(`Unsupported compression format: ${format}`);
+      }
+
+      this.activeOperations.delete(operationId);
+
+      return {
+        operationId,
+        name: path.basename(outputPath),
+        inputPath,
+        outputPath,
+        format,
+        level: validatedLevel,
+        size: result.size,
+        originalSize: result.originalSize,
+        compressionRatio: result.compressionRatio,
+        hash: result.hash,
+        completedAt: new Date().toISOString()
+      };
+
+    } catch (error) {
+      this.activeOperations.delete(operationId);
+
+      if (this.isFileNotFoundError(error)) {
+        throw new Error(`Input not found: ${inputPath}`);
+      }
+      throw new Error(`Compression failed: ${error.message}`);
+    }
+  }
+
+  // Alias for API compatibility
+  async compress(inputPath, outputPath, options = {}) {
+    return this.compressFile(inputPath, outputPath, options);
+  }
+
+  async compressToZip(inputPath, outputPath, options = {}) {
+    const { level, includeRoot, password, operationId } = options;
+
+    return new Promise(async (resolve, reject) => {
+      try {
+        const output = fsSync.createWriteStream(outputPath);
+        const archive = archiver('zip', {
+          zlib: { level: Math.max(1, Math.min(9, level || this.compressionLevel)) }
+        });
+
+        let totalBytes = 0;
+        let processedBytes = 0;
+
+        if (this.enableProgressTracking) {
+          totalBytes = await this.calculateTotalSize(inputPath);
+          this.updateOperationProgress(operationId, 0, totalBytes);
+        }
+
+        archive.on('progress', (progress) => {
+          if (this.enableProgressTracking && operationId) {
+            processedBytes = progress.entries.processed;
+            this.updateOperationProgress(operationId, processedBytes, totalBytes);
+
+            this.emit('compressionProgress', {
+              operationId,
+              processed: processedBytes,
+              total: totalBytes,
+              percentage: totalBytes > 0 ? Math.round((processedBytes / totalBytes) * 100) : 0
+            });
+          }
+        });
+
+        archive.on('error', reject);
+        output.on('error', reject);
+
+        output.on('close', async () => {
+          try {
+            const outputStats = await fs.stat(outputPath);
+            const inputStats = await fs.stat(inputPath);
+            const originalSize = inputStats.isDirectory() ? totalBytes : inputStats.size;
+
+            const result = {
+              name: path.basename(outputPath),
+              size: outputStats.size,
+              originalSize: originalSize,
+              compressionRatio: originalSize > 0 ? Math.max(0, (originalSize - outputStats.size) / originalSize) : 0
+            };
+
+            if (this.enableChecksumVerification) {
+              result.hash = await this.calculateChecksum(outputPath);
+            }
+
+            resolve(result);
+          } catch (error) {
+            reject(error);
+          }
+        });
+
+        archive.pipe(output);
+
+        const inputStats = await fs.stat(inputPath);
+
+        if (inputStats.isFile()) {
+          const fileName = path.basename(inputPath);
+          archive.file(inputPath, { name: fileName });
+        } else if (inputStats.isDirectory()) {
+          const baseDir = includeRoot ? path.basename(inputPath) : false;
+          archive.directory(inputPath, baseDir);
+        }
+
+        await archive.finalize();
+
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  async compressToTarGz(inputPath, outputPath, options = {}) {
+    const { level, includeRoot, operationId } = options;
+
+    try {
+      const inputStats = await fs.stat(inputPath);
+      let totalBytes = 0;
+
+      if (this.enableProgressTracking) {
+        totalBytes = await this.calculateTotalSize(inputPath);
+        this.updateOperationProgress(operationId, 0, totalBytes);
+      }
+
+      const tarOptions = {
+        file: outputPath,
+        gzip: {
+          level: level || this.compressionLevel
+        },
+        cwd: inputStats.isDirectory() ? (includeRoot ? path.dirname(inputPath) : inputPath) : path.dirname(inputPath)
+      };
+
+      let processedBytes = 0;
+      if (this.enableProgressTracking) {
+        tarOptions.filter = (filePath, stat) => {
+          processedBytes += stat.size || 0;
+          this.updateOperationProgress(operationId, processedBytes, totalBytes);
+
+          this.emit('compressionProgress', {
+            operationId,
+            processed: processedBytes,
+            total: totalBytes,
+            percentage: totalBytes > 0 ? Math.round((processedBytes / totalBytes) * 100) : 0
+          });
+
+          return true;
+        };
+      }
+
+      if (inputStats.isFile()) {
+        await tar.create(tarOptions, [path.basename(inputPath)]);
+      } else {
+        const targetPath = includeRoot ? path.basename(inputPath) : '.';
+        await tar.create(tarOptions, [targetPath]);
+      }
+
+      const outputStats = await fs.stat(outputPath);
+      const originalSize = inputStats.isDirectory() ? totalBytes : inputStats.size;
+
+      const result = {
+        name: path.basename(outputPath),
+        size: outputStats.size,
+        originalSize: originalSize,
+        compressionRatio: originalSize > 0 ? Math.max(0, (originalSize - outputStats.size) / originalSize) : 0
+      };
+
+      if (this.enableChecksumVerification) {
+        result.hash = await this.calculateChecksum(outputPath);
+      }
+
+      return result;
+
+    } catch (error) {
+      throw new Error(`TAR.GZ compression failed: ${error.message}`);
+    }
+  }
+
+  // ============================================================================
+  // DECOMPRESSION OPERATIONS
+  // ============================================================================
+
+  async decompressFile(inputPath, outputDirectory, options = {}) {
+    if (!this.enabled) {
+      throw new Error('Compression operations are disabled in configuration');
+    }
+
+    this.validatePath(inputPath);
+    this.validatePath(outputDirectory);
+
+    const resolvedInputPath = this.normalizePath(inputPath);
+    const resolvedOutputDir = this.normalizePath(outputDirectory);
+
+    const {
+      format = this.detectFormat(inputPath),
+      overwrite = false,
+      preservePermissions = true,
+      password = null
+    } = options;
+
+    const operationId = this.generateOperationId();
+
+    try {
+      const inputStats = await fs.stat(resolvedInputPath);
+      if (!inputStats.isFile()) {
+        throw new Error(`Input '${inputPath}' is not a file`);
+      }
+
+      if (inputStats.size > this.maxFileSize) {
+        throw new Error(`Archive size ${this.formatBytes(inputStats.size)} exceeds maximum of ${this.formatBytes(this.maxFileSize)}`);
+      }
+
+      await fs.mkdir(resolvedOutputDir, { recursive: true });
+
+      this.activeOperations.set(operationId, {
+        type: 'decompress',
+        inputPath: resolvedInputPath,
+        outputPath: resolvedOutputDir,
+        format,
+        startedAt: new Date().toISOString(),
+        progress: { processed: 0, total: inputStats.size }
+      });
+
+      let result;
+
+      if (format === 'zip') {
+        result = await this.decompressFromZip(resolvedInputPath, resolvedOutputDir, {
+          overwrite,
+          password,
+          operationId
+        });
+      } else if (format === 'tar.gz') {
+        result = await this.decompressFromTarGz(resolvedInputPath, resolvedOutputDir, {
+          overwrite,
+          preservePermissions,
+          operationId
+        });
+      } else {
+        throw new Error(`Unsupported decompression format: ${format}`);
+      }
+
+      this.activeOperations.delete(operationId);
+
+      return {
+        operationId,
+        inputPath,
+        outputDirectory,
+        format,
+        extractedFiles: result.extractedFiles,
+        extractedDirectories: result.extractedDirectories,
+        totalSize: result.totalSize,
+        hash: result.hash,
+        completedAt: new Date().toISOString()
+      };
+
+    } catch (error) {
+      this.activeOperations.delete(operationId);
+
+      if (this.isFileNotFoundError(error)) {
+        throw new Error(`Archive not found: ${inputPath}`);
+      }
+      throw new Error(`Decompression failed: ${error.message}`);
+    }
+  }
+
+  // Alias for API compatibility
+  async decompress(inputPath, outputDirectory, options = {}) {
+    return this.decompressFile(inputPath, outputDirectory, options);
+  }
+
+  async decompressFromZip(inputPath, outputDir, options = {}) {
+    const { overwrite, password, operationId } = options;
+
+    try {
+      const inputStats = await fs.stat(inputPath);
+
+      await fs.mkdir(outputDir, { recursive: true });
+
+      let extractedFiles = 0;
+      let extractedDirectories = 0;
+      let totalSize = 0;
+
+      try {
+        const directory = await unzipper.Open.file(inputPath);
+
+        for (const file of directory.files) {
+          if (file.type === 'Directory') {
+            extractedDirectories++;
+            const dirPath = path.join(outputDir, file.path);
+            await fs.mkdir(dirPath, { recursive: true });
+          } else if (file.type === 'File') {
+            const filePath = path.join(outputDir, file.path);
+
+            const fileExists = await fs.access(filePath).then(() => true).catch(() => false);
+            if (!overwrite && fileExists) {
+              continue;
+            }
+
+            const fileDir = path.dirname(filePath);
+            await fs.mkdir(fileDir, { recursive: true });
+
+            const content = await file.buffer();
+            await fs.writeFile(filePath, content);
+
+            extractedFiles++;
+            totalSize += content.length;
+
+            if (this.enableProgressTracking && operationId) {
+              this.updateOperationProgress(operationId, totalSize, inputStats.size);
+
+              this.emit('decompressionProgress', {
+                operationId,
+                processed: totalSize,
+                total: inputStats.size,
+                currentFile: file.path,
+                percentage: Math.round((totalSize / inputStats.size) * 100)
+              });
+            }
+          }
+        }
+
+        const result = {
+          extractedFiles,
+          extractedDirectories,
+          totalSize
+        };
+
+        if (this.enableChecksumVerification) {
+          try {
+            result.hash = await this.calculateChecksum(inputPath);
+          } catch (error) {
+            // Checksum calculation failed, continue without it
+          }
+        }
+
+        return result;
+
+      } catch (openError) {
+        // Fallback: use unzipper.Extract
+        return new Promise((resolve, reject) => {
+          let extractedFiles = 0;
+          let extractedDirectories = 0;
+          let totalSize = 0;
+
+          const extract = unzipper.Extract({
+            path: outputDir,
+            overwrite: overwrite
+          });
+
+          extract.on('entry', (entry) => {
+            if (entry.type === 'Directory') {
+              extractedDirectories++;
+            } else {
+              extractedFiles++;
+              totalSize += entry.vars.uncompressedSize || 0;
+            }
+          });
+
+          extract.on('close', async () => {
+            const result = {
+              extractedFiles,
+              extractedDirectories,
+              totalSize
+            };
+
+            if (this.enableChecksumVerification) {
+              try {
+                result.hash = await this.calculateChecksum(inputPath);
+              } catch (error) {
+                // Continue without checksum
+              }
+            }
+
+            resolve(result);
+          });
+
+          extract.on('error', (extractError) => {
+            reject(new Error(`ZIP extraction failed: ${extractError.message}`));
+          });
+
+          const readStream = fsSync.createReadStream(inputPath);
+          readStream.pipe(extract);
+
+          setTimeout(() => {
+            reject(new Error('ZIP extraction timeout after 30 seconds'));
+          }, 30000);
+        });
+      }
+
+    } catch (error) {
+      throw new Error(`ZIP decompression failed: ${error.message}`);
+    }
+  }
+
+  async decompressFromTarGz(inputPath, outputDir, options = {}) {
+    const { overwrite, preservePermissions, operationId } = options;
+
+    try {
+      let extractedFiles = 0;
+      let extractedDirectories = 0;
+      let totalSize = 0;
+      let processedBytes = 0;
+
+      const extractOptions = {
+        file: inputPath,
+        cwd: outputDir,
+        preservePaths: true,
+        unlink: overwrite,
+        preserveOwner: preservePermissions
+      };
+
+      if (this.enableProgressTracking) {
+        extractOptions.onentry = (entry) => {
+          const size = entry.size || 0;
+
+          if (entry.type === 'Directory') {
+            extractedDirectories++;
+          } else {
+            extractedFiles++;
+            totalSize += size;
+          }
+
+          processedBytes += size;
+          this.updateOperationProgress(operationId, processedBytes, totalSize);
+
+          this.emit('decompressionProgress', {
+            operationId,
+            processed: processedBytes,
+            total: totalSize,
+            currentFile: entry.path,
+            percentage: totalSize > 0 ? Math.round((processedBytes / totalSize) * 100) : 0
+          });
+        };
+      }
+
+      await tar.extract(extractOptions);
+
+      const result = {
+        extractedFiles,
+        extractedDirectories,
+        totalSize
+      };
+
+      if (this.enableChecksumVerification) {
+        result.hash = await this.calculateChecksum(inputPath);
+      }
+
+      return result;
+
+    } catch (error) {
+      throw new Error(`TAR.GZ decompression failed: ${error.message}`);
+    }
+  }
+
+  // ============================================================================
+  // BATCH OPERATIONS
+  // ============================================================================
+
+  async compressMultipleFiles(fileList, outputDirectory, options = {}) {
+    const {
+      format = this.defaultFormat,
+      level = this.compressionLevel,
+      namingPattern = '{name}.{format}'
+    } = options;
+
+    const results = [];
+    const errors = [];
+
+    for (let i = 0; i < fileList.length; i++) {
+      const inputPath = fileList[i];
+      try {
+        const baseName = path.parse(inputPath).name;
+        const outputName = namingPattern
+          .replace('{name}', baseName)
+          .replace('{format}', format);
+        const outputPath = path.join(outputDirectory, outputName);
+
+        const result = await this.compressFile(inputPath, outputPath, { format, level });
+
+        results.push({ inputPath, outputPath, result });
+      } catch (error) {
+        errors.push({ inputPath, error: error.message });
+      }
+    }
+
+    return {
+      successful: results,
+      failed: errors,
+      summary: {
+        total: fileList.length,
+        successful: results.length,
+        failed: errors.length,
+        successRate: (results.length / fileList.length * 100).toFixed(1) + '%'
+      }
+    };
+  }
+
+  async decompressMultipleFiles(fileList, outputDirectory, options = {}) {
+    const results = [];
+    const errors = [];
+
+    for (let i = 0; i < fileList.length; i++) {
+      const inputPath = fileList[i];
+      try {
+        const archiveName = path.parse(inputPath).name;
+        const archiveOutputDir = path.join(outputDirectory, archiveName);
+
+        const result = await this.decompressFile(inputPath, archiveOutputDir, options);
+
+        results.push({ inputPath, outputDirectory: archiveOutputDir, result });
+      } catch (error) {
+        errors.push({ inputPath, error: error.message });
+      }
+    }
+
+    return {
+      successful: results,
+      failed: errors,
+      summary: {
+        total: fileList.length,
+        successful: results.length,
+        failed: errors.length,
+        successRate: (results.length / fileList.length * 100).toFixed(1) + '%'
+      }
+    };
+  }
+
+  // ============================================================================
+  // UTILITY METHODS
+  // ============================================================================
+
+  detectFormat(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const fileName = path.basename(filePath).toLowerCase();
+
+    if (ext === '.zip') {
+      return 'zip';
+    } else if (fileName.endsWith('.tar.gz') || fileName.endsWith('.tgz')) {
+      return 'tar.gz';
+    } else {
+      return this.detectFormatByHeader(filePath);
+    }
+  }
+
+  async detectFormatByHeader(filePath) {
+    try {
+      const buffer = Buffer.alloc(10);
+      const fd = await fs.open(filePath, 'r');
+      await fd.read(buffer, 0, 10, 0);
+      await fd.close();
+
+      if (buffer[0] === 0x50 && buffer[1] === 0x4B) {
+        return 'zip';
+      }
+
+      if (buffer[0] === 0x1f && buffer[1] === 0x8b) {
+        return 'tar.gz';
+      }
+
+      return 'zip';
+    } catch (error) {
+      return 'zip';
+    }
+  }
+
+  getSupportedFormats() {
+    return ['zip', 'tar.gz'];
+  }
+
+  async calculateTotalSize(inputPath) {
+    const stats = await fs.stat(inputPath);
+
+    if (stats.isFile()) {
+      return stats.size;
+    } else if (stats.isDirectory()) {
+      return await this.calculateDirectorySize(inputPath);
+    }
+
+    return 0;
+  }
+
+  async calculateDirectorySize(dirPath) {
+    let totalSize = 0;
+
+    try {
+      const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+
+        if (entry.isFile()) {
+          const stats = await fs.stat(fullPath);
+          totalSize += stats.size;
+        } else if (entry.isDirectory()) {
+          totalSize += await this.calculateDirectorySize(fullPath);
+        }
+      }
+    } catch (error) {
+      // Skip directories we can't read
+    }
+
+    return totalSize;
+  }
+
+  async calculateChecksum(filePath) {
+    return new Promise((resolve, reject) => {
+      const hash = crypto.createHash('sha256');
+      const stream = fsSync.createReadStream(filePath);
+
+      stream.on('error', reject);
+      stream.on('data', chunk => hash.update(chunk));
+      stream.on('end', () => resolve(hash.digest('hex')));
+    });
+  }
+
+  updateOperationProgress(operationId, processed, total) {
+    const operation = this.activeOperations.get(operationId);
+    if (operation) {
+      operation.progress = { processed, total };
+      operation.lastUpdated = new Date().toISOString();
+    }
+  }
+
+  // ============================================================================
+  // INFORMATION AND STATUS METHODS
+  // ============================================================================
+
+  listActiveOperations() {
+    const operations = [];
+
+    for (const [operationId, operationInfo] of this.activeOperations) {
+      operations.push({
+        operationId,
+        type: operationInfo.type,
+        inputPath: operationInfo.inputPath,
+        outputPath: operationInfo.outputPath,
+        format: operationInfo.format,
+        startedAt: operationInfo.startedAt,
+        progress: operationInfo.progress,
+        duration: Date.now() - new Date(operationInfo.startedAt).getTime()
+      });
+    }
+
+    return operations;
+  }
+
+  getCompressionStatus() {
+    return {
+      enabled: this.enabled,
+      activeOperations: this.activeOperations.size,
+      supportedFormats: ['zip', 'tar.gz'],
+      defaultFormat: this.defaultFormat,
+      compressionLevel: this.compressionLevel,
+      enableProgressTracking: this.enableProgressTracking,
+      enableChecksumVerification: this.enableChecksumVerification,
+      config: {
+        maxFileSize: this.maxFileSize,
+        chunkSize: this.chunkSize
+      }
+    };
+  }
+
+  // ============================================================================
+  // UTILITY METHODS
+  // ============================================================================
+
+  formatBytes(bytes) {
+    if (bytes === 0) return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+  }
+
+  formatDuration(milliseconds) {
+    const seconds = Math.floor(milliseconds / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+
+    if (hours > 0) {
+      return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    } else if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
+    } else {
+      return `${seconds}s`;
+    }
+  }
+
+  // ============================================================================
+  // ERROR HANDLING HELPERS
+  // ============================================================================
+
+  isFileNotFoundError(error) {
+    return error.code === 'ENOENT' ||
+      error.message.includes('no such file') ||
+      error.message.includes('not found');
+  }
+
+  isPermissionError(error) {
+    return error.code === 'EACCES' ||
+      error.code === 'EPERM' ||
+      error.message.includes('permission denied');
+  }
+
+  isSpaceError(error) {
+    return error.code === 'ENOSPC' ||
+      error.message.includes('no space left') ||
+      error.message.includes('disk full');
+  }
+
+  isCorruptedArchiveError(error) {
+    return error.message.includes('invalid zip file') ||
+      error.message.includes('corrupted') ||
+      error.message.includes('bad archive') ||
+      error.message.includes('unexpected end of archive');
+  }
+
+  // ============================================================================
+  // CLEANUP AND SHUTDOWN
+  // ============================================================================
+
+  async shutdown() {
+    try {
+      const activeOps = Array.from(this.activeOperations.keys());
+
+      if (activeOps.length > 0) {
+        const timeout = setTimeout(() => {
+          this.activeOperations.clear();
+        }, 30000);
+
+        while (this.activeOperations.size > 0) {
+          await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+
+        clearTimeout(timeout);
+      }
+
+      this.removeAllListeners();
+
+      return {
+        operationsCompleted: activeOps.length,
+        shutdownAt: new Date().toISOString()
+      };
+    } catch (error) {
+      throw error;
+    }
+  }
+}
+
+export { CompressionProvider };