@kadi.build/local-remote-file-manager-ability/lib.js

Local & Remote File Management System with S3-compatible container registry, HTTP server provider, file streaming, comprehensive tunnel services (ngrok, serveo, localtunnel, localhost.run, pinggy), and comprehensive testing suite

/**
 * Local Remote File Manager Library
 * 
 * A comprehensive file management library with support for:
 * - Local file operations
 * - File watching and monitoring
 * - Compression/decompression (ZIP, TAR.GZ)
 * - HTTP server with S3-compatible endpoints
 * - Tunneling for remote access
 * - File streaming with range requests
 * 
 * @module local-remote-file-manager
 */

// Core classes
import { LocalRemoteManager } from './src/localRemoteManager.js';
import { ConfigManager } from './src/configManager.js';
import { S3HttpServer } from './src/s3Server.js';

// Providers
import { LocalProvider } from './src/providers/localProvider.js';
import { WatchProvider } from './src/providers/watchProvider.js';
import { CompressionProvider } from './src/providers/compressionProvider.js';
import { TunnelProvider } from './src/providers/tunnelProvider.js';
import { HttpServerProvider } from './src/providers/httpServerProvider.js';

// Utilities
import { FileStreamingUtils, FileStreamer } from './src/utils/fileStreamingUtils.js';
import { DownloadMonitor } from './src/downloadMonitor.js';
import { ShutdownManager } from './src/shutdownManager.js';
import { MonitoringDashboard } from './src/monitoringDashboard.js';
import { EventNotifier } from './src/eventNotifier.js';

// CLI (for programmatic access)
import { LocalRemoteCLI } from './index.js';

/**
 * Create a new LocalRemoteManager instance with default configuration
 * @param {Object} options - Configuration options
 * @returns {Promise<LocalRemoteManager>} Configured manager instance
 */
async function createManager(options = {}) {
  const config = new ConfigManager();

  // Apply custom options to config
  if (options.localConfig) {
    config.localConfig = { ...config.localConfig, ...options.localConfig };
  }
  if (options.watchConfig) {
    config.watchConfig = { ...config.watchConfig, ...options.watchConfig };
  }
  if (options.compressionConfig) {
    config.compressionConfig = { ...config.compressionConfig, ...options.compressionConfig };
  }
  if (options.tunnelConfig) {
    config.tunnelConfig = { ...config.tunnelConfig, ...options.tunnelConfig };
  }

  await config.load();
  return new LocalRemoteManager(config);
}

/**
 * Create a new S3-compatible HTTP server
 * @param {Object} config - Server configuration
 * @returns {S3HttpServer} S3 server instance
 */
function createS3Server(config = {}) {
  return new S3HttpServer(config);
}

/**
 * Create a simple HTTP server for file serving
 * @param {Object} config - Server configuration
 * @returns {HttpServerProvider} HTTP server instance
 */
function createHttpServer(config = {}) {
  return new HttpServerProvider(config);
}

/**
 * Quick file compression utility
 * @param {string} sourcePath - Path to compress
 * @param {string} outputPath - Output path
 * @param {Object} options - Compression options
 * @returns {Promise<Object>} Compression result
 */
async function compressFile(sourcePath, outputPath, options = {}) {
  const manager = await createManager();
  const compressionProvider = manager.getCompressionProvider();
  return compressionProvider.compress(sourcePath, outputPath, options);
}

/**
 * Quick file decompression utility
 * @param {string} archivePath - Archive to decompress
 * @param {string} outputDir - Output directory
 * @param {Object} options - Decompression options
 * @returns {Promise<Object>} Decompression result
 */
async function decompressFile(archivePath, outputDir, options = {}) {
  const manager = await createManager();
  const compressionProvider = manager.getCompressionProvider();
  return compressionProvider.decompress(archivePath, outputDir, options);
}

/**
 * Start watching a directory for changes
 * @param {string} watchPath - Path to watch
 * @param {Object} options - Watch options
 * @returns {Promise<Object>} Watch session
 */
async function watchDirectory(watchPath, options = {}) {
  const manager = await createManager();
  const watchProvider = manager.getProvider('watch');
  return watchProvider.startWatch(watchPath, options);
}

// Export main classes and utilities
export {
  // Core classes
  LocalRemoteManager,
  ConfigManager,
  S3HttpServer,
  
  // Providers
  LocalProvider,
  WatchProvider,
  CompressionProvider,
  TunnelProvider,
  HttpServerProvider,
  
  // Utilities
  FileStreamingUtils,
  FileStreamer,
  DownloadMonitor,
  ShutdownManager,
  MonitoringDashboard,
  EventNotifier,
  
  // CLI
  LocalRemoteCLI,

  // Factory functions
  createManager,
  createS3Server,
  createHttpServer,

  // Convenience functions
  compressFile,
  decompressFile,
  watchDirectory
};

// Provide a default export for compatibility with consumers that import the package
// as a default module. This exports a namespace-like object containing all
// primary APIs.
export default {
  // Core classes
  LocalRemoteManager,
  ConfigManager,
  S3HttpServer,

  // Providers
  LocalProvider,
  WatchProvider,
  CompressionProvider,
  TunnelProvider,
  HttpServerProvider,

  // Utilities
  FileStreamingUtils,
  FileStreamer,
  DownloadMonitor,
  ShutdownManager,
  MonitoringDashboard,
  EventNotifier,

  // CLI
  LocalRemoteCLI,

  // Factory
  createManager,
  createS3Server,
  createHttpServer,

  // Convenience
  compressFile,
  decompressFile,
  watchDirectory
};