@kadi.build/file-sharing 1.0.0

package/src/FileSharingServer.js

@@ -0,0 +1,598 @@
+/**
+ * FileSharingServer - Main orchestrating class for @kadi.build/file-sharing
+ *
+ * Integrates HttpServerProvider, S3Server, TunnelManager, DownloadMonitor,
+ * ShutdownManager, MonitoringDashboard, and EventNotifier into a unified
+ * file sharing solution.
+ *
+ * KĀDI is the default tunnel service.
+ */
+
+import { EventEmitter } from 'events';
+import fs from 'fs';
+import path from 'path';
+import { createFileManager } from '@kadi.build/file-manager';
+import { TunnelManager } from '@kadi.build/tunnel-services';
+import { HttpServerProvider } from './HttpServerProvider.js';
+import { S3Server } from './S3Server.js';
+import { DownloadMonitor } from './DownloadMonitor.js';
+import { ShutdownManager } from './ShutdownManager.js';
+import { MonitoringDashboard } from './MonitoringDashboard.js';
+import { EventNotifier } from './EventNotifier.js';
+
+/**
+ * Parse a .env file's content and inject into process.env.
+ * Existing env vars take priority (are NOT overwritten).
+ * @param {string} content  raw file content
+ */
+function _parseEnvFile(content) {
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eqIdx = trimmed.indexOf('=');
+    if (eqIdx === -1) continue;
+    const key = trimmed.substring(0, eqIdx).trim();
+    let val = trimmed.substring(eqIdx + 1).trim();
+    // Strip surrounding quotes
+    if ((val.startsWith('"') && val.endsWith('"')) ||
+        (val.startsWith("'") && val.endsWith("'"))) {
+      val = val.slice(1, -1);
+    }
+    // Real env vars take priority over .env file values
+    if (process.env[key] === undefined) {
+      process.env[key] = val;
+    }
+  }
+}
+
+/**
+ * Walk up from cwd looking for a .env file (supports monorepo layouts
+ * where .env lives at the workspace root, not inside packages/*).
+ * Stops at the filesystem root.
+ */
+function _loadEnvFile() {
+  let dir = process.cwd();
+  const root = path.parse(dir).root;
+
+  while (true) {
+    try {
+      const envPath = path.join(dir, '.env');
+      const content = fs.readFileSync(envPath, 'utf8');
+      _parseEnvFile(content);
+      return; // found and loaded — done
+    } catch {
+      // not found in this directory — keep climbing
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir || dir === root) break; // reached fs root
+    dir = parent;
+  }
+}
+
+/**
+ * Load secrets from environment variables and optional .env file.
+ * Supports KADI_ prefixed vars and common tunnel/auth env vars.
+ *
+ * Env vars (all optional — constructor config takes priority):
+ *   KADI_TUNNEL_TOKEN   — KĀDI tunnel auth token
+ *   KADI_TUNNEL_SERVER  — KĀDI broker address (default: broker.kadi.build)
+ *   KADI_TUNNEL_DOMAIN  — KĀDI tunnel domain (default: tunnel.kadi.build)
+ *   KADI_TUNNEL_PORT    — KĀDI frpc port (default: 7000)
+ *   KADI_TUNNEL_SSH_PORT— KĀDI SSH gateway port (default: 2200)
+ *   KADI_TUNNEL_MODE    — ssh | frpc | auto (default: auto)
+ *   KADI_AGENT_ID       — Agent identifier for proxy naming
+ *   NGROK_AUTHTOKEN     — Ngrok auth token (also: NGROK_AUTH_TOKEN)
+ *   KADI_S3_ACCESS_KEY  — S3 access key (default: minioadmin)
+ *   KADI_S3_SECRET_KEY  — S3 secret key (default: minioadmin)
+ *   KADI_AUTH_USERNAME   — HTTP Basic auth username
+ *   KADI_AUTH_PASSWORD   — HTTP Basic auth password
+ *   KADI_AUTH_API_KEY    — API key for Bearer/X-API-Key auth
+ *
+ * @returns {object} Secrets object (values are strings or undefined)
+ */
+function loadSecrets() {
+  // Find and load .env file — walk up parent directories (monorepo support).
+  // e.g. packages/file-sharing/ → packages/ → workspace root (where .env lives)
+  _loadEnvFile();
+
+
+  return {
+    kadiToken:      process.env.KADI_TUNNEL_TOKEN,
+    kadiServer:     process.env.KADI_TUNNEL_SERVER,
+    kadiDomain:     process.env.KADI_TUNNEL_DOMAIN,
+    kadiPort:       process.env.KADI_TUNNEL_PORT ? Number(process.env.KADI_TUNNEL_PORT) : undefined,
+    kadiSshPort:    process.env.KADI_TUNNEL_SSH_PORT ? Number(process.env.KADI_TUNNEL_SSH_PORT) : undefined,
+    kadiMode:       process.env.KADI_TUNNEL_MODE,
+    kadiAgentId:    process.env.KADI_AGENT_ID,
+    ngrokAuthToken: process.env.NGROK_AUTHTOKEN || process.env.NGROK_AUTH_TOKEN,
+    s3AccessKey:    process.env.KADI_S3_ACCESS_KEY,
+    s3SecretKey:    process.env.KADI_S3_SECRET_KEY,
+    authUsername:   process.env.KADI_AUTH_USERNAME,
+    authPassword:   process.env.KADI_AUTH_PASSWORD,
+    authApiKey:     process.env.KADI_AUTH_API_KEY
+  };
+}
+
+/**
+ * Strip `undefined` values from an object so they don't override downstream
+ * defaults when spread into a constructor config.
+ * @param {object} obj
+ * @returns {object}
+ */
+function _filterDefined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined));
+}
+
+export class FileSharingServer extends EventEmitter {
+  constructor(config = {}) {
+    super();
+
+    this.config = {
+      staticDir: process.cwd(),
+      port: 3000,
+      host: '0.0.0.0',
+      enableS3: false,
+      s3Port: 9000,
+      s3Config: {},
+      enableDirectoryListing: true,
+      cors: true,
+      auth: null,
+      tunnel: {
+        enabled: false,
+        service: 'kadi', // KĀDI is the default tunnel service
+        options: {},
+        autoReconnect: true,
+        reconnectDelay: 5000
+      },
+      monitoring: {
+        enabled: true,
+        dashboard: false,
+        webhooks: []
+      },
+      shutdown: {
+        gracefulTimeout: 30000,
+        finishActiveDownloads: true,
+        forceKillTimeout: 60000
+      },
+      ...config
+    };
+
+    // Ensure tunnel defaults are preserved when user provides partial tunnel config
+    if (config.tunnel) {
+      this.config.tunnel = {
+        enabled: false,
+        service: 'kadi',
+        options: {},
+        autoReconnect: true,
+        reconnectDelay: 5000,
+        ...config.tunnel
+      };
+    }
+
+    // ----------------------------------------------------------------
+    // Load secrets from env vars / .env (constructor config takes priority)
+    // ----------------------------------------------------------------
+    const secrets = loadSecrets();
+
+    // Build auth config: explicit config > env vars > null
+    if (!this.config.auth) {
+      if (secrets.authApiKey) {
+        this.config.auth = { apiKey: secrets.authApiKey };
+      } else if (secrets.authUsername && secrets.authPassword) {
+        this.config.auth = { username: secrets.authUsername, password: secrets.authPassword };
+      }
+    }
+
+    // Initialize components
+    this.fileManager = createFileManager();
+
+    this.httpServer = new HttpServerProvider({
+      port: this.config.port,
+      host: this.config.host,
+      staticDir: this.config.staticDir,
+      enableDirectoryListing: this.config.enableDirectoryListing,
+      cors: this.config.cors,
+      auth: this.config.auth,
+      ...(this.config.httpConfig || {})
+    });
+
+    this.s3Server = null;
+    if (this.config.enableS3) {
+      this.s3Server = new S3Server({
+        port: this.config.s3Port,
+        host: this.config.host,
+        rootDir: this.config.staticDir,
+        ...(secrets.s3AccessKey ? { accessKeyId: secrets.s3AccessKey } : {}),
+        ...(secrets.s3SecretKey ? { secretAccessKey: secrets.s3SecretKey } : {}),
+        ...this.config.s3Config
+      });
+    }
+
+    // Build TunnelManager config from env vars + explicit tunnel config.
+    // Use || to let explicit config override env, and filter out undefined
+    // values so TunnelManager's own defaults are preserved.
+    const tunnelCfg = this.config.tunnel || {};
+    const tunnelManagerConfig = _filterDefined({
+      primaryService: tunnelCfg.service || 'kadi',
+      autoFallback: tunnelCfg.autoFallback,
+      // KĀDI auth (env vars as fallback)
+      kadiToken:    tunnelCfg.kadiToken    || secrets.kadiToken,
+      kadiServer:   tunnelCfg.kadiServer   || secrets.kadiServer,
+      kadiDomain:   tunnelCfg.kadiDomain   || secrets.kadiDomain,
+      kadiPort:     tunnelCfg.kadiPort     || secrets.kadiPort,
+      kadiSshPort:  tunnelCfg.kadiSshPort  || secrets.kadiSshPort,
+      kadiMode:     tunnelCfg.kadiMode     || secrets.kadiMode,
+      kadiAgentId:  tunnelCfg.kadiAgentId  || secrets.kadiAgentId,
+      // Ngrok auth (env vars as fallback)
+      ngrokAuthToken: tunnelCfg.ngrokAuthToken || secrets.ngrokAuthToken,
+      // Pass through any extra service-specific options
+      ...(tunnelCfg.managerOptions || {})
+    });
+    this.tunnelManager = new TunnelManager(tunnelManagerConfig);
+    this.downloadMonitor = new DownloadMonitor();
+    this.shutdownManager = new ShutdownManager(this.config.shutdown);
+    this.monitoringDashboard = new MonitoringDashboard();
+    this.eventNotifier = new EventNotifier();
+
+    // State
+    this.isRunning = false;
+    this.tunnel = null;
+    this._startTime = null;
+
+    // Wire up events
+    this._setupEventForwarding();
+    this._setupShutdownHandlers();
+    this._setupWebhooks();
+  }
+
+  /**
+   * Start the file sharing server
+   * @returns {Promise<object>} Server information
+   */
+  async start() {
+    if (this.isRunning) {
+      return this.getInfo();
+    }
+
+    this._startTime = Date.now();
+
+    // Start HTTP server
+    const httpResult = await this.httpServer.start();
+    this.emit('http:started', httpResult);
+
+    // Start S3 server if enabled
+    if (this.s3Server) {
+      const s3Result = await this.s3Server.start();
+      this.emit('s3:started', s3Result);
+    }
+
+    // Create tunnel if enabled
+    if (this.config.tunnel.enabled) {
+      try {
+        await this.enableTunnel(this.config.tunnel);
+      } catch (error) {
+        this.emit('tunnel:error', error);
+        // Don't fail server start if tunnel fails
+      }
+    }
+
+    // Start monitoring dashboard if configured
+    if (this.config.monitoring.dashboard) {
+      await this.monitoringDashboard.start();
+      this.monitoringDashboard.setServerInfo(this.getInfo());
+    }
+
+    this.isRunning = true;
+    const info = this.getInfo();
+    this.emit('started', info);
+
+    return info;
+  }
+
+  /**
+   * Stop the file sharing server
+   * Gracefully shuts down all components.
+   */
+  async stop() {
+    if (!this.isRunning) {
+      return;
+    }
+
+    this.emit('stopping');
+
+    // Stop monitoring dashboard
+    if (this.monitoringDashboard.isRunning) {
+      await this.monitoringDashboard.stop();
+    }
+
+    // Disable tunnel
+    if (this.tunnel) {
+      try {
+        await this.disableTunnel();
+      } catch {
+        // Best effort tunnel cleanup
+      }
+    }
+
+    // Stop servers
+    await this.httpServer.stop();
+
+    if (this.s3Server) {
+      await this.s3Server.stop();
+    }
+
+    this.isRunning = false;
+    this._startTime = null;
+    this.emit('stopped');
+  }
+
+  /**
+   * Enable tunnel to expose server publicly
+   * @param {object} options - Tunnel options
+   * @returns {Promise<object>} Tunnel information
+   */
+  async enableTunnel(options = {}) {
+    if (this.tunnel) {
+      await this.disableTunnel();
+    }
+
+    const service = options.service || 'kadi'; // KĀDI is the default
+    const port = this.config.port;
+
+    // TunnelManager.createTunnel(port, options) — port is first arg (number),
+    // options.service tells it which provider to use.
+    const tunnelOptions = {
+      service,
+      ...(options.options || {})
+    };
+
+    this.tunnel = await this.tunnelManager.createTunnel(port, tunnelOptions);
+    this.emit('tunnel:created', this.tunnel);
+
+    return this.tunnel;
+  }
+
+  /**
+   * Disable active tunnel
+   */
+  async disableTunnel() {
+    if (!this.tunnel) {
+      return;
+    }
+
+    await this.tunnelManager.closeTunnel(this.tunnel.id);
+    this.tunnel = null;
+    this.emit('tunnel:closed');
+  }
+
+  /**
+   * Enable S3-compatible API dynamically
+   * @param {object} options - S3 server options
+   * @returns {Promise<object>} S3 server information
+   */
+  async enableS3(options = {}) {
+    if (this.s3Server) {
+      await this.disableS3();
+    }
+
+    const secrets = loadSecrets();
+    this.s3Server = new S3Server({
+      port: this.config.s3Port,
+      host: this.config.host,
+      rootDir: this.config.staticDir,
+      ...(secrets.s3AccessKey ? { accessKeyId: secrets.s3AccessKey } : {}),
+      ...(secrets.s3SecretKey ? { secretAccessKey: secrets.s3SecretKey } : {}),
+      ...this.config.s3Config,
+      ...options
+    });
+
+    // Forward S3 events
+    this.s3Server.on('object:get', (data) => this.emit('s3:get', data));
+    this.s3Server.on('object:put', (data) => this.emit('s3:put', data));
+    this.s3Server.on('object:delete', (data) => this.emit('s3:delete', data));
+    this.s3Server.on('error', (err) => this.emit('error', err));
+
+    const result = await this.s3Server.start();
+    this.emit('s3:started', result);
+    return result;
+  }
+
+  /**
+   * Disable S3 API
+   */
+  async disableS3() {
+    if (!this.s3Server) return;
+
+    await this.s3Server.stop();
+    this.s3Server = null;
+  }
+
+  /**
+   * Get current server information and statistics
+   * @returns {object} Server information
+   */
+  getInfo() {
+    return {
+      isRunning: this.isRunning,
+      localUrl: `http://${this.config.host}:${this.config.port}`,
+      publicUrl: this.tunnel?.publicUrl || null,
+      s3Endpoint: this.s3Server?.isRunning
+        ? `http://${this.config.host}:${this.config.s3Port}`
+        : null,
+      staticDir: this.config.staticDir,
+      stats: this.downloadMonitor.getStats(),
+      uptime: this._startTime ? Date.now() - this._startTime : 0,
+      tunnelStatus: this.tunnel || null
+    };
+  }
+
+  /**
+   * Get download statistics
+   * @returns {object}
+   */
+  getStats() {
+    return this.downloadMonitor.getStats();
+  }
+
+  /**
+   * List files in the served directory
+   * @param {string} subPath - Optional subdirectory path
+   * @returns {Promise<Array>}
+   */
+  async listFiles(subPath = '') {
+    const { default: path } = await import('path');
+    const { default: fsPromises } = await import('fs/promises');
+
+    const dirPath = path.join(this.config.staticDir, subPath);
+    const entries = await fsPromises.readdir(dirPath, { withFileTypes: true });
+
+    return Promise.all(entries.map(async (entry) => {
+      const fullPath = path.join(dirPath, entry.name);
+      const stats = await fsPromises.stat(fullPath);
+      return {
+        name: entry.name,
+        type: entry.isDirectory() ? 'directory' : 'file',
+        size: stats.size,
+        modified: stats.mtime.toISOString()
+      };
+    }));
+  }
+
+  /**
+   * Add a webhook for event notifications
+   * @param {string} url - Webhook URL
+   * @param {string[]} events - Events to subscribe to
+   */
+  addWebhook(url, events = []) {
+    this.eventNotifier.addWebhook(url, events);
+  }
+
+  /**
+   * Remove a webhook
+   * @param {string} url - Webhook URL to remove
+   */
+  removeWebhook(url) {
+    this.eventNotifier.removeWebhook(url);
+  }
+
+  /** @type {number} */
+  get port() {
+    return this.config.port;
+  }
+
+  /** @type {string|null} */
+  get tunnelUrl() {
+    return this.tunnel?.publicUrl || null;
+  }
+
+  /** @type {string|null} */
+  get s3Endpoint() {
+    return this.s3Server?.isRunning
+      ? `http://${this.config.host}:${this.config.s3Port}`
+      : null;
+  }
+
+  /** @type {string} */
+  get staticDir() {
+    return this.config.staticDir;
+  }
+
+  /**
+   * Wire up event forwarding between components
+   * @private
+   */
+  _setupEventForwarding() {
+    // Forward HTTP server events
+    this.httpServer.on('download:start', (data) => {
+      this.downloadMonitor.startDownload(
+        `http-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        data
+      );
+      this.emit('download:start', data);
+    });
+    this.httpServer.on('download:complete', (data) => {
+      this.emit('download:complete', data);
+    });
+    this.httpServer.on('download:error', (data) => {
+      this.emit('download:error', data);
+    });
+    this.httpServer.on('upload:complete', (data) => {
+      this.emit('upload:complete', data);
+    });
+    this.httpServer.on('error', (err) => {
+      this.emit('http:error', err);
+    });
+
+    // Forward S3 events
+    if (this.s3Server) {
+      this.s3Server.on('object:get', (data) => this.emit('s3:get', data));
+      this.s3Server.on('object:put', (data) => this.emit('s3:put', data));
+      this.s3Server.on('object:delete', (data) => this.emit('s3:delete', data));
+      this.s3Server.on('error', (err) => this.emit('error', err));
+    }
+
+    // Forward download monitor events to dashboard
+    this.downloadMonitor.on('download:start', () => {
+      this._updateDashboard();
+    });
+    this.downloadMonitor.on('download:complete', () => {
+      this._updateDashboard();
+    });
+    this.downloadMonitor.on('download:progress', () => {
+      this._updateDashboard();
+    });
+  }
+
+  /**
+   * Register shutdown handlers
+   * @private
+   */
+  _setupShutdownHandlers() {
+    this.shutdownManager.register(async () => {
+      await this.stop();
+    }, 1);
+  }
+
+  /**
+   * Setup initial webhooks from config
+   * @private
+   */
+  _setupWebhooks() {
+    if (this.config.monitoring?.webhooks) {
+      for (const webhook of this.config.monitoring.webhooks) {
+        this.eventNotifier.addWebhook(
+          webhook.url,
+          webhook.events || [],
+          webhook.options || {}
+        );
+      }
+    }
+
+    // Auto-notify on key events
+    const eventsToNotify = [
+      'started', 'stopped', 'download:start', 'download:complete',
+      'upload:complete', 's3:put', 's3:delete', 'tunnel:created', 'tunnel:closed'
+    ];
+
+    for (const event of eventsToNotify) {
+      this.on(event, (data) => {
+        this.eventNotifier.notify(event, data).catch(() => {
+          // Silently handle notification failures
+        });
+      });
+    }
+  }
+
+  /**
+   * Update the monitoring dashboard with latest stats
+   * @private
+   */
+  _updateDashboard() {
+    if (this.monitoringDashboard.isRunning) {
+      this.monitoringDashboard.updateStats(this.downloadMonitor.getStats());
+      this.monitoringDashboard.setServerInfo(this.getInfo());
+    }
+  }
+}
+
+export default FileSharingServer;