@kadi.build/file-manager 1.0.0

package/src/FileManager.js

@@ -0,0 +1,526 @@
+/**
+ * FileManager - Main orchestrator for file operations
+ *
+ * Provides unified interface for local and remote file management.
+ * API-compatible with the original LocalRemoteManager for test migration.
+ */
+
+import { EventEmitter } from 'events';
+import path from 'path';
+import os from 'os';
+import { LocalProvider } from './providers/LocalProvider.js';
+import { WatchProvider } from './providers/WatchProvider.js';
+import { CompressionProvider } from './providers/CompressionProvider.js';
+import { RemoteProvider } from './providers/RemoteProvider.js';
+
+class FileManager extends EventEmitter {
+  constructor(config) {
+    super();
+    this.config = config;
+    this.providers = {};
+    this._initializeProviders();
+
+    // Set up event handling after providers are initialized
+    process.nextTick(() => {
+      this._setupEventHandling();
+    });
+  }
+
+  _initializeProviders() {
+    // Always initialize local provider
+    this.providers.local = new LocalProvider(this.config.getLocalConfig());
+
+    // Initialize watch provider
+    this.providers.watch = new WatchProvider(this.config.getWatchConfig());
+
+    // Initialize compression provider
+    this.providers.compression = new CompressionProvider(this.config.getCompressionConfig());
+
+    // Initialize remote provider if configured
+    if (this.config.hasRemoteConfig()) {
+      this.providers.remote = new RemoteProvider(this.config.getRemoteConfig());
+    }
+  }
+
+  /**
+   * Get a specific provider
+   * @param {string} name - Provider name: 'local', 'remote', 'watch', 'compression'
+   */
+  getProvider(name = 'local') {
+    const provider = this.providers[name.toLowerCase()];
+    if (!provider) {
+      throw new Error(`Provider '${name}' not available. Available providers: ${Object.keys(this.providers).join(', ')}`);
+    }
+    return provider;
+  }
+
+  /**
+   * Convenience method to get compression provider
+   */
+  getCompressionProvider() {
+    return this.getProvider('compression');
+  }
+
+  /**
+   * Get list of available provider names
+   */
+  getAvailableProviders() {
+    return Object.keys(this.providers);
+  }
+
+  // ============================================================================
+  // FILE OPERATIONS (delegates to local or remote provider)
+  // ============================================================================
+
+  async uploadFile(sourcePath, targetPath, providerName = 'local') {
+    const provider = this.getProvider(providerName);
+    return await provider.uploadFile(sourcePath, targetPath);
+  }
+
+  async downloadFile(sourcePath, targetPath, providerName = 'local') {
+    const provider = this.getProvider(providerName);
+    return await provider.downloadFile(sourcePath, targetPath);
+  }
+
+  async getFileInfo(filePath, providerName = 'local') {
+    const provider = this.getProvider(providerName);
+    return await provider.getFile(filePath);
+  }
+
+  async listFiles(directoryPath = '/', providerName = 'local', options = {}) {
+    const provider = this.getProvider(providerName);
+    return await provider.listFiles(directoryPath, options);
+  }
+
+  async deleteFile(filePath, providerName = 'local') {
+    const provider = this.getProvider(providerName);
+    return await provider.deleteFile(filePath);
+  }
+
+  async renameFile(oldPath, newName, providerName = 'local') {
+    const provider = this.getProvider(providerName);
+    return await provider.renameFile(oldPath, newName);
+  }
+
+  async copyFile(sourcePath, targetPath, providerName = 'local') {
+    const provider = this.getProvider(providerName);
+    return await provider.copyFile(sourcePath, targetPath);
+  }
+
+  async moveFile(sourcePath, targetPath, providerName = 'local') {
+    const provider = this.getProvider(providerName);
+    return await provider.moveFile(sourcePath, targetPath);
+  }
+
+  // ============================================================================
+  // FOLDER OPERATIONS
+  // ============================================================================
+
+  async createFolder(folderPath, providerName = 'local') {
+    const provider = this.getProvider(providerName);
+    return await provider.createFolder(folderPath);
+  }
+
+  async listFolders(directoryPath = '/', providerName = 'local') {
+    const provider = this.getProvider(providerName);
+    return await provider.listFolders(directoryPath);
+  }
+
+  async deleteFolder(folderPath, recursive = false, providerName = 'local') {
+    const provider = this.getProvider(providerName);
+    return await provider.deleteFolder(folderPath, recursive);
+  }
+
+  async renameFolder(oldPath, newName, providerName = 'local') {
+    const provider = this.getProvider(providerName);
+    return await provider.renameFolder(oldPath, newName);
+  }
+
+  async getFolderInfo(folderPath, providerName = 'local') {
+    const provider = this.getProvider(providerName);
+    return await provider.getFolder(folderPath);
+  }
+
+  async copyFolder(sourcePath, targetPath, providerName = 'local') {
+    const provider = this.getProvider(providerName);
+    return await provider.copyFolder(sourcePath, targetPath);
+  }
+
+  async moveFolder(sourcePath, targetPath, providerName = 'local') {
+    const provider = this.getProvider(providerName);
+    return await provider.moveFolder(sourcePath, targetPath);
+  }
+
+  // ============================================================================
+  // SEARCH OPERATIONS
+  // ============================================================================
+
+  async searchFiles(query, providerName = 'local', options = {}) {
+    const provider = this.getProvider(providerName);
+    return await provider.searchFiles(query, options);
+  }
+
+  // ============================================================================
+  // UTILITY OPERATIONS
+  // ============================================================================
+
+  async testConnection(providerName = 'local') {
+    const provider = this.getProvider(providerName);
+    return await provider.testConnection();
+  }
+
+  async validateProvider(providerName = 'local') {
+    const provider = this.getProvider(providerName);
+    if (provider.validateConfig) {
+      return await provider.validateConfig();
+    }
+    return { isValid: true, errors: [], warnings: [] };
+  }
+
+  // ============================================================================
+  // FILE WATCHING METHODS
+  // ============================================================================
+
+  async startWatching(directoryPath, options = {}) {
+    const watchProvider = this.getProvider('watch');
+    return await watchProvider.startWatching(directoryPath, options);
+  }
+
+  async stopWatching(watchIdOrPath) {
+    const watchProvider = this.getProvider('watch');
+    return await watchProvider.stopWatching(watchIdOrPath);
+  }
+
+  async stopAllWatching() {
+    const watchProvider = this.getProvider('watch');
+    return await watchProvider.stopAllWatching();
+  }
+
+  listActiveWatchers() {
+    const watchProvider = this.getProvider('watch');
+    return watchProvider.listActiveWatchers();
+  }
+
+  getWatcherInfo(watchIdOrPath) {
+    const watchProvider = this.getProvider('watch');
+    return watchProvider.getWatcherInfo(watchIdOrPath);
+  }
+
+  getWatchingStatus() {
+    const watchProvider = this.getProvider('watch');
+    return watchProvider.getWatchingStatus();
+  }
+
+  // Alias for tests that use watch()
+  async watch(directoryPath, options = {}) {
+    const watchProvider = this.getProvider('watch');
+    const watchId = await watchProvider.startWatching(directoryPath, options);
+
+    return {
+      id: watchId,
+      stop: () => watchProvider.stopWatching(watchId),
+      getInfo: () => watchProvider.getWatcherInfo(watchId)
+    };
+  }
+
+  async stopWatch(watchId) {
+    return this.stopWatching(watchId);
+  }
+
+  async listWatches() {
+    return this.listActiveWatchers();
+  }
+
+  // ============================================================================
+  // COMPRESSION METHODS
+  // ============================================================================
+
+  async compressFile(inputPath, outputPath, options = {}) {
+    const compressionProvider = this.getProvider('compression');
+    return await compressionProvider.compressFile(inputPath, outputPath, options);
+  }
+
+  async decompressFile(archivePath, outputDirectory, options = {}) {
+    const compressionProvider = this.getProvider('compression');
+    return await compressionProvider.decompressFile(archivePath, outputDirectory, options);
+  }
+
+  async compress(source, output, options = {}) {
+    const compressionProvider = this.getProvider('compression');
+    return await compressionProvider.compress(source, output, options);
+  }
+
+  async decompress(archive, outputDir, options = {}) {
+    const compressionProvider = this.getProvider('compression');
+    return await compressionProvider.decompress(archive, outputDir, options);
+  }
+
+  async compressMultipleFiles(fileList, outputDirectory, options = {}) {
+    const compressionProvider = this.getProvider('compression');
+    return await compressionProvider.compressMultipleFiles(fileList, outputDirectory, options);
+  }
+
+  async decompressMultipleFiles(archiveList, outputDirectory, options = {}) {
+    const compressionProvider = this.getProvider('compression');
+    return await compressionProvider.decompressMultipleFiles(archiveList, outputDirectory, options);
+  }
+
+  listActiveCompressionOperations() {
+    const compressionProvider = this.getProvider('compression');
+    return compressionProvider.listActiveOperations();
+  }
+
+  getCompressionOperationInfo(operationId) {
+    const compressionProvider = this.getProvider('compression');
+    return compressionProvider.getOperationInfo(operationId);
+  }
+
+  getCompressionStatus() {
+    const compressionProvider = this.getProvider('compression');
+    return compressionProvider.getCompressionStatus();
+  }
+
+  // ============================================================================
+  // REMOTE-SPECIFIC OPERATIONS
+  // ============================================================================
+
+  async connectRemote(options = {}) {
+    if (!this.providers.remote) {
+      this.providers.remote = new RemoteProvider({
+        ...this.config.getRemoteConfig(),
+        ...options
+      });
+    }
+    return this.providers.remote.connect();
+  }
+
+  async disconnectRemote() {
+    if (this.providers.remote) {
+      return this.providers.remote.disconnect();
+    }
+  }
+
+  // ============================================================================
+  // CROSS-PROVIDER OPERATIONS
+  // ============================================================================
+
+  async syncToRemote(localPath, remotePath, options = {}) {
+    const local = this.getProvider('local');
+    const remote = this.getProvider('remote');
+
+    const localFiles = await local.listFiles(localPath, { recursive: true });
+    const results = [];
+
+    for (const file of localFiles) {
+      const targetPath = remotePath + '/' + (file.relativePath || file.name);
+      try {
+        await remote.uploadFile(file.path, targetPath);
+        results.push({ file: file.path, status: 'success' });
+      } catch (error) {
+        results.push({ file: file.path, status: 'error', error: error.message });
+      }
+    }
+
+    return results;
+  }
+
+  async syncFromRemote(remotePath, localPath, options = {}) {
+    const remote = this.getProvider('remote');
+
+    const remoteFiles = await remote.listFiles(remotePath, { recursive: true });
+    const results = [];
+
+    for (const file of remoteFiles) {
+      const targetPath = localPath + '/' + (file.relativePath || file.name);
+      try {
+        await remote.downloadFile(file.path, targetPath);
+        results.push({ file: file.path, status: 'success' });
+      } catch (error) {
+        results.push({ file: file.path, status: 'error', error: error.message });
+      }
+    }
+
+    return results;
+  }
+
+  // ============================================================================
+  // BATCH OPERATIONS
+  // ============================================================================
+
+  async uploadMultipleFiles(fileList, targetDirectory = '/', providerName = 'local') {
+    const results = [];
+    const errors = [];
+
+    for (const filePath of fileList) {
+      try {
+        const fileName = path.basename(filePath);
+        const targetPath = path.join(targetDirectory, fileName);
+        const result = await this.uploadFile(filePath, targetPath, providerName);
+        results.push({ sourcePath: filePath, targetPath, result });
+      } catch (error) {
+        errors.push({ filePath, error: error.message });
+      }
+    }
+
+    return { results, errors };
+  }
+
+  async downloadMultipleFiles(fileList, targetDirectory = './', providerName = 'local') {
+    const results = [];
+    const errors = [];
+
+    for (const filePath of fileList) {
+      try {
+        const fileName = path.basename(filePath);
+        const targetPath = path.join(targetDirectory, fileName);
+        const result = await this.downloadFile(filePath, targetPath, providerName);
+        results.push({ sourcePath: filePath, targetPath, result });
+      } catch (error) {
+        errors.push({ filePath, error: error.message });
+      }
+    }
+
+    return { results, errors };
+  }
+
+  // ============================================================================
+  // EVENT HANDLING SETUP
+  // ============================================================================
+
+  _setupEventHandling() {
+    try {
+      // Forward file watching events
+      const watchProvider = this.getProvider('watch');
+      watchProvider.on('fileEvent', (eventData) => {
+        this.emit('fileEvent', eventData);
+      });
+      watchProvider.on('watcherError', (errorData) => {
+        this.emit('watcherError', errorData);
+      });
+    } catch (error) {
+      // Watch provider might not be available
+    }
+
+    try {
+      // Forward compression events
+      const compressionProvider = this.getProvider('compression');
+      compressionProvider.on('compressionProgress', (progressData) => {
+        this.emit('compressionProgress', progressData);
+      });
+      compressionProvider.on('decompressionProgress', (progressData) => {
+        this.emit('decompressionProgress', progressData);
+      });
+    } catch (error) {
+      // Compression provider might not be available
+    }
+  }
+
+  // ============================================================================
+  // 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];
+  }
+
+  getSystemInfo() {
+    return {
+      platform: os.platform(),
+      arch: os.arch(),
+      nodeVersion: process.version,
+      availableProviders: this.getAvailableProviders(),
+      config: {
+        local: this.config.getLocalConfig(),
+        performance: this.config.getPerformanceConfig ? this.config.getPerformanceConfig() : {},
+        watch: this.config.getWatchConfig(),
+        compression: this.config.getCompressionConfig()
+      }
+    };
+  }
+
+  async getUsageStats() {
+    const provider = this.getProvider('local');
+    const localConfig = this.config.getLocalConfig();
+    const fsPromises = (await import('fs')).promises;
+
+    const stats = {
+      uploadDirectory: {
+        path: localConfig.uploadDirectory,
+        exists: false,
+        fileCount: 0,
+        totalSize: 0
+      },
+      downloadDirectory: {
+        path: localConfig.downloadDirectory,
+        exists: false,
+        fileCount: 0,
+        totalSize: 0
+      },
+      tempDirectory: {
+        path: localConfig.tempDirectory,
+        exists: false,
+        fileCount: 0,
+        totalSize: 0
+      },
+      watchStatus: this.getWatchingStatus(),
+      compressionStatus: this.getCompressionStatus()
+    };
+
+    for (const [key, dirInfo] of Object.entries(stats)) {
+      if (key === 'watchStatus' || key === 'compressionStatus') continue;
+
+      try {
+        const dirStat = await fsPromises.stat(dirInfo.path);
+        if (dirStat.isDirectory()) {
+          dirInfo.exists = true;
+          const files = await provider.listFiles(dirInfo.path, { recursive: true });
+          dirInfo.fileCount = files.length;
+          dirInfo.totalSize = files.reduce((sum, file) => sum + (file.size || 0), 0);
+        }
+      } catch (error) {
+        dirInfo.exists = false;
+      }
+    }
+
+    return stats;
+  }
+
+  // ============================================================================
+  // CLEANUP AND SHUTDOWN
+  // ============================================================================
+
+  async shutdown() {
+    try {
+      // Stop all watchers first
+      const watchProvider = this.getProvider('watch');
+      await watchProvider.shutdown();
+    } catch (error) {
+      // Watch provider might not be available
+    }
+
+    try {
+      // Shutdown compression provider
+      const compressionProvider = this.getProvider('compression');
+      if (compressionProvider.shutdown) {
+        await compressionProvider.shutdown();
+      }
+    } catch (error) {
+      // Compression provider might not be available
+    }
+
+    try {
+      // Disconnect remote if connected
+      if (this.providers.remote) {
+        await this.providers.remote.disconnect();
+      }
+    } catch (error) {
+      // Remote provider might not be available
+    }
+  }
+}
+
+export { FileManager };

package/src/index.js

@@ -0,0 +1,48 @@
+/**
+ * @kadi.build/file-manager
+ *
+ * Complete local and remote file management library.
+ * Provides file operations, watching, compression, and remote SSH/SFTP support.
+ */
+
+// Providers
+export { LocalProvider } from './providers/LocalProvider.js';
+export { WatchProvider } from './providers/WatchProvider.js';
+export { CompressionProvider } from './providers/CompressionProvider.js';
+export { RemoteProvider } from './providers/RemoteProvider.js';
+
+// Utilities
+export { FileStreamingUtils, FileStreamer, DownloadTracker } from './utils/FileStreamingUtils.js';
+export { PathUtils } from './utils/PathUtils.js';
+
+// Main classes
+export { FileManager } from './FileManager.js';
+export { ConfigManager } from './ConfigManager.js';
+
+// Factory function
+export async function createFileManager(options = {}) {
+  const { ConfigManager: CM } = await import('./ConfigManager.js');
+  const { FileManager: FM } = await import('./FileManager.js');
+  const config = new CM();
+  await config.load(options);
+  return new FM(config);
+}
+
+// Convenience functions
+export async function compressFile(sourcePath, outputPath, options = {}) {
+  const manager = await createFileManager();
+  return manager.compress(sourcePath, outputPath, options);
+}
+
+export async function decompressFile(archivePath, outputDir, options = {}) {
+  const manager = await createFileManager();
+  return manager.decompress(archivePath, outputDir, options);
+}
+
+export async function watchDirectory(dirPath, options = {}) {
+  const manager = await createFileManager();
+  return manager.watch(dirPath, options);
+}
+
+// Default export
+export { FileManager as default } from './FileManager.js';