@kadi.build/file-sharing 1.0.0

package/src/HttpServerProvider.js

@@ -0,0 +1,538 @@
+/**
+ * HttpServerProvider - HTTP file server for @kadi.build/file-sharing
+ *
+ * Provides HTTP file serving with:
+ * - Static file serving with correct MIME types
+ * - Directory listing (HTML and JSON)
+ * - Range requests (video streaming)
+ * - CORS support
+ * - Optional basic authentication
+ * - SSL/TLS support
+ * - Download event tracking
+ * - Connection tracking for graceful shutdown
+ *
+ * Migrated from src/providers/httpServerProvider.js
+ */
+
+import { EventEmitter } from 'events';
+import http from 'http';
+import https from 'https';
+import path from 'path';
+import fs from 'fs/promises';
+import { createReadStream, statSync } from 'fs';
+import mime from 'mime-types';
+
+export class HttpServerProvider extends EventEmitter {
+  constructor(config = {}) {
+    super();
+
+    this.config = {
+      port: 3000,
+      host: '0.0.0.0',
+      staticDir: process.cwd(),
+      enableDirectoryListing: true,
+      cors: true,
+      auth: null,
+      ssl: null,
+      maxFileSize: null,
+      uploadDir: null,
+      ...config
+    };
+
+    this.server = null;
+    this.isRunning = false;
+    this.activeConnections = new Map();
+    this.startTime = null;
+    this.requestCount = 0;
+    this.errorCount = 0;
+  }
+
+  /**
+   * Start the HTTP server
+   * @returns {{ port: number, host: string, url: string }}
+   */
+  async start() {
+    if (this.isRunning) {
+      return { port: this.config.port, host: this.config.host, already: true };
+    }
+
+    return new Promise((resolve, reject) => {
+      const requestHandler = this._createRequestHandler();
+
+      // Create HTTP or HTTPS server
+      if (this.config.ssl) {
+        this.server = https.createServer({
+          key: this.config.ssl.key,
+          cert: this.config.ssl.cert,
+          ...(this.config.ssl.ca ? { ca: this.config.ssl.ca } : {})
+        }, requestHandler);
+      } else {
+        this.server = http.createServer(requestHandler);
+      }
+
+      // Track connections for graceful shutdown
+      this.server.on('connection', (socket) => {
+        const id = `${socket.remoteAddress}:${socket.remotePort}`;
+        this.activeConnections.set(id, socket);
+        socket.on('close', () => this.activeConnections.delete(id));
+      });
+
+      this.server.listen(this.config.port, this.config.host, () => {
+        const addr = this.server.address();
+        this.config.port = addr.port;
+        this.isRunning = true;
+        this.startTime = new Date();
+
+        const protocol = this.config.ssl ? 'https' : 'http';
+        const info = {
+          port: addr.port,
+          host: this.config.host,
+          url: `${protocol}://${this.config.host}:${addr.port}`
+        };
+
+        this.emit('started', info);
+        resolve(info);
+      });
+
+      this.server.on('error', (error) => {
+        this.emit('error', error);
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * Stop the HTTP server
+   */
+  async stop() {
+    if (!this.isRunning) {
+      return;
+    }
+
+    return new Promise((resolve) => {
+      // Close active connections
+      for (const [id, socket] of this.activeConnections) {
+        socket.destroy();
+        this.activeConnections.delete(id);
+      }
+
+      this.server.close(() => {
+        this.isRunning = false;
+        this.server = null;
+        this.emit('stopped');
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * Get active connection count
+   * @returns {number}
+   */
+  getActiveConnections() {
+    return this.activeConnections.size;
+  }
+
+  /**
+   * Force close all active connections
+   */
+  closeAllConnections() {
+    for (const [id, socket] of this.activeConnections) {
+      socket.destroy();
+      this.activeConnections.delete(id);
+    }
+  }
+
+  /**
+   * Create the main request handler
+   * @private
+   */
+  _createRequestHandler() {
+    return async (req, res) => {
+      this.requestCount++;
+
+      try {
+        // CORS headers
+        if (this.config.cors) {
+          this._setCorsHeaders(res);
+
+          if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+          }
+        }
+
+        // Authentication
+        if (this.config.auth) {
+          if (!this._checkAuth(req)) {
+            // Set appropriate WWW-Authenticate based on configured scheme
+            const auth = this.config.auth;
+            if (auth.apiKey || auth.bearerToken) {
+              res.setHeader('WWW-Authenticate', 'Bearer');
+            } else {
+              res.setHeader('WWW-Authenticate', 'Basic realm="File Server"');
+            }
+            res.writeHead(401);
+            res.end('Unauthorized');
+            return;
+          }
+        }
+
+        // Route request
+        const urlObj = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
+        const urlPath = decodeURIComponent(urlObj.pathname);
+        const filePath = path.join(this.config.staticDir, urlPath);
+
+        // Security: prevent directory traversal
+        const resolvedStatic = path.resolve(this.config.staticDir);
+        const resolvedFile = path.resolve(filePath);
+        if (!resolvedFile.startsWith(resolvedStatic)) {
+          res.writeHead(403);
+          res.end('Forbidden');
+          return;
+        }
+
+        // Handle file upload
+        if (req.method === 'PUT' || req.method === 'POST') {
+          await this._handleUpload(req, res, resolvedFile, urlPath);
+          return;
+        }
+
+        await this._handleFileRequest(req, res, resolvedFile, urlPath);
+      } catch (error) {
+        this.errorCount++;
+        this.emit('error', error);
+        if (!res.headersSent) {
+          res.writeHead(500);
+          res.end('Internal Server Error');
+        }
+      }
+    };
+  }
+
+  /**
+   * Set CORS headers on response
+   * @private
+   */
+  _setCorsHeaders(res) {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS, HEAD');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, Range, Accept');
+    res.setHeader('Access-Control-Expose-Headers', 'Content-Length, Content-Range, Accept-Ranges');
+  }
+
+  /**
+   * Handle file request (GET/HEAD)
+   * @private
+   */
+  async _handleFileRequest(req, res, filePath, urlPath) {
+    try {
+      const stats = await fs.stat(filePath);
+
+      if (stats.isDirectory()) {
+        // Check for index.html
+        const indexPath = path.join(filePath, 'index.html');
+        try {
+          await fs.access(indexPath);
+          return this._serveFile(req, res, indexPath);
+        } catch {
+          // No index.html, show directory listing
+          if (this.config.enableDirectoryListing) {
+            return this._serveDirectoryListing(req, res, filePath, urlPath);
+          } else {
+            res.writeHead(403);
+            res.end('Directory listing disabled');
+          }
+        }
+      } else {
+        return this._serveFile(req, res, filePath);
+      }
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        res.writeHead(404);
+        res.end('Not Found');
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Serve a file with proper headers, range support, and event tracking
+   * @private
+   */
+  async _serveFile(req, res, filePath) {
+    const stats = await fs.stat(filePath);
+    const mimeType = mime.lookup(filePath) || 'application/octet-stream';
+
+    // Emit download start
+    this.emit('download:start', {
+      file: filePath,
+      size: stats.size,
+      clientIp: req.socket.remoteAddress
+    });
+
+    const startTime = Date.now();
+
+    // ETag and Last-Modified
+    const etag = `"${stats.size}-${stats.mtime.getTime()}"`;
+    res.setHeader('ETag', etag);
+    res.setHeader('Last-Modified', stats.mtime.toUTCString());
+    res.setHeader('Accept-Ranges', 'bytes');
+
+    // Conditional request handling
+    const ifNoneMatch = req.headers['if-none-match'];
+    if (ifNoneMatch && ifNoneMatch === etag) {
+      res.writeHead(304);
+      res.end();
+      return;
+    }
+
+    const ifModifiedSince = req.headers['if-modified-since'];
+    if (ifModifiedSince && new Date(ifModifiedSince) >= stats.mtime) {
+      res.writeHead(304);
+      res.end();
+      return;
+    }
+
+    // Handle range requests (for video streaming)
+    const range = req.headers.range;
+    if (range) {
+      const parts = range.replace(/bytes=/, '').split('-');
+      const start = parseInt(parts[0], 10);
+      const end = parts[1] ? parseInt(parts[1], 10) : stats.size - 1;
+
+      if (start >= stats.size || start < 0 || end >= stats.size) {
+        res.writeHead(416, {
+          'Content-Range': `bytes */${stats.size}`
+        });
+        res.end();
+        return;
+      }
+
+      const chunkSize = end - start + 1;
+
+      res.writeHead(206, {
+        'Content-Range': `bytes ${start}-${end}/${stats.size}`,
+        'Accept-Ranges': 'bytes',
+        'Content-Length': chunkSize,
+        'Content-Type': mimeType
+      });
+
+      const stream = createReadStream(filePath, { start, end });
+      stream.pipe(res);
+    } else {
+      res.writeHead(200, {
+        'Content-Length': stats.size,
+        'Content-Type': mimeType,
+        'Accept-Ranges': 'bytes'
+      });
+
+      const stream = createReadStream(filePath);
+      stream.pipe(res);
+
+      stream.on('end', () => {
+        this.emit('download:complete', {
+          file: filePath,
+          size: stats.size,
+          duration: Date.now() - startTime,
+          clientIp: req.socket.remoteAddress
+        });
+      });
+
+      stream.on('error', (err) => {
+        this.emit('download:error', {
+          file: filePath,
+          error: err
+        });
+      });
+    }
+  }
+
+  /**
+   * Serve directory listing in HTML or JSON format
+   * @private
+   */
+  async _serveDirectoryListing(req, res, dirPath, urlPath) {
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+    // Check Accept header for JSON response
+    const acceptsJson = req.headers.accept?.includes('application/json');
+
+    if (acceptsJson) {
+      const items = await Promise.all(entries.map(async (entry) => {
+        const fullPath = path.join(dirPath, entry.name);
+        try {
+          const stats = await fs.stat(fullPath);
+          return {
+            name: entry.name,
+            type: entry.isDirectory() ? 'directory' : 'file',
+            size: stats.size,
+            modified: stats.mtime.toISOString()
+          };
+        } catch {
+          return {
+            name: entry.name,
+            type: entry.isDirectory() ? 'directory' : 'file',
+            size: 0,
+            modified: null
+          };
+        }
+      }));
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ path: urlPath, entries: items }));
+    } else {
+      // HTML response
+      const html = this._generateDirectoryHtml(urlPath, entries);
+      res.writeHead(200, { 'Content-Type': 'text/html' });
+      res.end(html);
+    }
+  }
+
+  /**
+   * Handle file upload (PUT/POST)
+   * @private
+   */
+  async _handleUpload(req, res, filePath, urlPath) {
+    try {
+      // Ensure parent directory exists
+      await fs.mkdir(path.dirname(filePath), { recursive: true });
+
+      const chunks = [];
+      for await (const chunk of req) {
+        chunks.push(chunk);
+      }
+      const body = Buffer.concat(chunks);
+
+      await fs.writeFile(filePath, body);
+
+      this.emit('upload:complete', {
+        file: filePath,
+        size: body.length,
+        clientIp: req.socket.remoteAddress
+      });
+
+      res.writeHead(201, { 'Content-Length': 0 });
+      res.end();
+    } catch (error) {
+      this.emit('upload:error', { file: filePath, error });
+      res.writeHead(500);
+      res.end('Upload failed');
+    }
+  }
+
+  /**
+   * Generate HTML directory listing
+   * @private
+   */
+  _generateDirectoryHtml(urlPath, entries) {
+    // Sort: directories first, then files
+    const sorted = [...entries].sort((a, b) => {
+      if (a.isDirectory() && !b.isDirectory()) return -1;
+      if (!a.isDirectory() && b.isDirectory()) return 1;
+      return a.name.localeCompare(b.name);
+    });
+
+    const items = sorted.map(entry => {
+      const icon = entry.isDirectory() ? '📁' : '📄';
+      const href = path.posix.join(urlPath, entry.name);
+      const name = entry.isDirectory() ? `${entry.name}/` : entry.name;
+      return `<li><a href="${href}">${icon} ${name}</a></li>`;
+    }).join('\n    ');
+
+    return `<!DOCTYPE html>
+<html>
+<head>
+  <title>Index of ${urlPath}</title>
+  <style>
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; padding: 20px; max-width: 900px; margin: 0 auto; }
+    h1 { color: #333; border-bottom: 1px solid #eee; padding-bottom: 10px; }
+    ul { list-style: none; padding: 0; }
+    li { padding: 8px 4px; border-bottom: 1px solid #f0f0f0; }
+    a { text-decoration: none; color: #0066cc; font-size: 15px; }
+    a:hover { text-decoration: underline; }
+    .footer { margin-top: 20px; color: #999; font-size: 12px; }
+  </style>
+</head>
+<body>
+  <h1>Index of ${urlPath}</h1>
+  <ul>
+    ${urlPath !== '/' ? '<li><a href="..">⬆️ Parent Directory</a></li>' : ''}
+    ${items}
+  </ul>
+  <div class="footer">Powered by @kadi.build/file-sharing</div>
+</body>
+</html>`;
+  }
+
+  /**
+   * Check authentication on incoming request.
+   *
+   * Supports three auth schemes (configured via `config.auth`):
+   *
+   * 1. **API Key** — `config.auth.apiKey`
+   *    Checked against: `Authorization: Bearer <key>` header,
+   *    `X-API-Key: <key>` header, or `?apiKey=<key>` query param.
+   *
+   * 2. **Bearer Token** — `config.auth.bearerToken`
+   *    Checked against: `Authorization: Bearer <token>` header.
+   *
+   * 3. **Basic Auth** — `config.auth.username` + `config.auth.password`
+   *    Checked against: `Authorization: Basic <base64>` header.
+   *
+   * If multiple schemes are configured, ANY valid match succeeds (OR logic).
+   *
+   * @private
+   * @param {import('http').IncomingMessage} req
+   * @returns {boolean}
+   */
+  _checkAuth(req) {
+    const authHeader = req.headers.authorization || '';
+    const auth = this.config.auth;
+
+    // --- API Key auth ---
+    if (auth.apiKey) {
+      // Check Authorization: Bearer <apiKey>
+      if (authHeader.startsWith('Bearer ') && authHeader.slice(7) === auth.apiKey) {
+        return true;
+      }
+      // Check X-API-Key header
+      if (req.headers['x-api-key'] === auth.apiKey) {
+        return true;
+      }
+      // Check ?apiKey= query param
+      try {
+        const url = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
+        if (url.searchParams.get('apiKey') === auth.apiKey) {
+          return true;
+        }
+      } catch {
+        // malformed URL — ignore
+      }
+    }
+
+    // --- Bearer token auth ---
+    if (auth.bearerToken) {
+      if (authHeader.startsWith('Bearer ') && authHeader.slice(7) === auth.bearerToken) {
+        return true;
+      }
+    }
+
+    // --- Basic auth ---
+    if (auth.username && auth.password) {
+      if (authHeader.startsWith('Basic ')) {
+        const credentials = Buffer.from(authHeader.slice(6), 'base64').toString();
+        const [username, password] = credentials.split(':');
+        if (username === auth.username && password === auth.password) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+}
+
+export default HttpServerProvider;

package/src/MonitoringDashboard.js

@@ -0,0 +1,181 @@
+/**
+ * MonitoringDashboard - Console monitoring dashboard for @kadi.build/file-sharing
+ *
+ * Provides a console-based real-time dashboard showing server status,
+ * active downloads, transfer statistics, and progress information.
+ *
+ * Migrated from src/monitoringDashboard.js
+ */
+
+import { EventEmitter } from 'events';
+
+export class MonitoringDashboard extends EventEmitter {
+  constructor(config = {}) {
+    super();
+
+    this.config = {
+      refreshInterval: 1000,
+      showProgressBars: true,
+      maxDisplayItems: 10,
+      ...config
+    };
+
+    this.isRunning = false;
+    this._intervalId = null;
+    this._stats = {
+      totalBytes: 0,
+      totalDownloads: 0,
+      activeCount: 0,
+      activeDownloads: [],
+      averageSpeed: 0,
+      peakConcurrent: 0,
+      uptime: 0
+    };
+    this._serverInfo = null;
+  }
+
+  /**
+   * Start the monitoring dashboard
+   * @returns {{ running: boolean }}
+   */
+  async start() {
+    if (this.isRunning) {
+      return { running: true };
+    }
+
+    this.isRunning = true;
+
+    this._intervalId = setInterval(() => {
+      this._render();
+    }, this.config.refreshInterval);
+
+    this.emit('started');
+    return { running: true };
+  }
+
+  /**
+   * Stop the monitoring dashboard
+   */
+  async stop() {
+    if (!this.isRunning) return;
+
+    if (this._intervalId) {
+      clearInterval(this._intervalId);
+      this._intervalId = null;
+    }
+
+    this.isRunning = false;
+    this.emit('stopped');
+  }
+
+  /**
+   * Update dashboard statistics
+   * @param {object} stats - New stats to display
+   */
+  updateStats(stats) {
+    this._stats = { ...this._stats, ...stats };
+  }
+
+  /**
+   * Set server information
+   * @param {object} info - Server info (localUrl, publicUrl, etc.)
+   */
+  setServerInfo(info) {
+    this._serverInfo = info;
+  }
+
+  /**
+   * Render the dashboard to console
+   * @private
+   */
+  _render() {
+    if (!this.isRunning) return;
+
+    const lines = [];
+    lines.push('');
+    lines.push('╔══════════════════════════════════════════════════════╗');
+    lines.push('║          KĀDI File Sharing Monitor                  ║');
+    lines.push('╠══════════════════════════════════════════════════════╣');
+
+    // Server info
+    if (this._serverInfo) {
+      lines.push(`║ Local:  ${(this._serverInfo.localUrl || 'N/A').padEnd(44)}║`);
+      if (this._serverInfo.publicUrl) {
+        lines.push(`║ Public: ${this._serverInfo.publicUrl.padEnd(44)}║`);
+      }
+      if (this._serverInfo.s3Endpoint) {
+        lines.push(`║ S3:     ${this._serverInfo.s3Endpoint.padEnd(44)}║`);
+      }
+    }
+
+    lines.push('╠══════════════════════════════════════════════════════╣');
+
+    // Stats
+    const stats = this._stats;
+    lines.push(`║ Downloads: ${String(stats.totalDownloads).padEnd(8)} Active: ${String(stats.activeCount).padEnd(8)} ║`);
+    lines.push(`║ Total:     ${this._formatBytes(stats.totalBytes).padEnd(8)} Speed:  ${this._formatSpeed(stats.averageSpeed).padEnd(8)} ║`);
+
+    // Active downloads
+    if (stats.activeDownloads && stats.activeDownloads.length > 0) {
+      lines.push('╠══════════════════════════════════════════════════════╣');
+      lines.push('║ Active Downloads:                                    ║');
+
+      const displayed = stats.activeDownloads.slice(0, this.config.maxDisplayItems);
+      for (const dl of displayed) {
+        const name = (dl.file || dl.id || 'unknown').slice(-30).padEnd(30);
+        const progress = dl.progress ? `${dl.progress.toFixed(0)}%` : '?%';
+
+        if (this.config.showProgressBars) {
+          const bar = this._progressBar(dl.progress || 0, 15);
+          lines.push(`║  ${name} ${bar} ${progress.padStart(4)} ║`);
+        } else {
+          lines.push(`║  ${name} ${progress.padStart(4)}             ║`);
+        }
+      }
+    }
+
+    lines.push('╚══════════════════════════════════════════════════════╝');
+
+    // Output (in a real console dashboard, this would use cursor movement)
+    this.emit('render', lines.join('\n'));
+  }
+
+  /**
+   * Generate a progress bar string
+   * @param {number} percent - Progress percentage (0-100)
+   * @param {number} width - Bar width in characters
+   * @returns {string}
+   * @private
+   */
+  _progressBar(percent, width = 20) {
+    const filled = Math.round((percent / 100) * width);
+    const empty = width - filled;
+    return `[${'█'.repeat(filled)}${'░'.repeat(empty)}]`;
+  }
+
+  /**
+   * Format bytes to human-readable string
+   * @param {number} bytes
+   * @returns {string}
+   * @private
+   */
+  _formatBytes(bytes) {
+    if (bytes === 0) return '0 B';
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${units[i]}`;
+  }
+
+  /**
+   * Format speed to human-readable string
+   * @param {number} bytesPerSec
+   * @returns {string}
+   * @private
+   */
+  _formatSpeed(bytesPerSec) {
+    if (!bytesPerSec || bytesPerSec === 0) return '0 B/s';
+    return `${this._formatBytes(bytesPerSec)}/s`;
+  }
+}
+
+export default MonitoringDashboard;