@kadi.build/file-sharing 1.0.0

package/src/DownloadMonitor.js

@@ -0,0 +1,199 @@
+/**
+ * DownloadMonitor - Transfer monitoring for @kadi.build/file-sharing
+ *
+ * Tracks active downloads, monitors progress, records completion statistics,
+ * and provides real-time download information.
+ *
+ * Migrated from src/downloadMonitor.js
+ */
+
+import { EventEmitter } from 'events';
+
+export class DownloadMonitor extends EventEmitter {
+  constructor() {
+    super();
+    this.activeDownloads = new Map();
+    this.completedDownloads = [];
+    this.stats = {
+      totalBytes: 0,
+      totalDownloads: 0,
+      activeCount: 0,
+      failedCount: 0,
+      averageSpeed: 0,
+      peakConcurrent: 0
+    };
+  }
+
+  /**
+   * Register a new download being tracked
+   * @param {string} id - Unique download identifier
+   * @param {object} metadata - Download metadata
+   * @returns {object} The download record
+   */
+  startDownload(id, metadata = {}) {
+    const download = {
+      id,
+      file: metadata.file || 'unknown',
+      totalSize: metadata.totalSize || metadata.size || 0,
+      clientIp: metadata.clientIp || 'unknown',
+      bytesTransferred: 0,
+      progress: 0,
+      speed: 0,
+      startTime: Date.now(),
+      status: 'active',
+      ...metadata
+    };
+
+    this.activeDownloads.set(id, download);
+    this.stats.activeCount = this.activeDownloads.size;
+
+    if (this.stats.activeCount > this.stats.peakConcurrent) {
+      this.stats.peakConcurrent = this.stats.activeCount;
+    }
+
+    this.emit('download:start', download);
+    return download;
+  }
+
+  /**
+   * Update download progress
+   * @param {string} id - Download identifier
+   * @param {number} bytesTransferred - Bytes transferred so far
+   */
+  updateProgress(id, bytesTransferred) {
+    const download = this.activeDownloads.get(id);
+    if (!download) return;
+
+    const now = Date.now();
+    const elapsed = (now - download.startTime) / 1000; // seconds
+
+    download.bytesTransferred = bytesTransferred;
+    download.progress = download.totalSize
+      ? (bytesTransferred / download.totalSize) * 100
+      : 0;
+    download.speed = elapsed > 0 ? bytesTransferred / elapsed : 0;
+
+    this.emit('download:progress', { ...download });
+  }
+
+  /**
+   * Mark a download as completed
+   * @param {string} id - Download identifier
+   */
+  completeDownload(id) {
+    const download = this.activeDownloads.get(id);
+    if (!download) return;
+
+    download.status = 'completed';
+    download.endTime = Date.now();
+    download.duration = download.endTime - download.startTime;
+    download.progress = 100;
+
+    this.activeDownloads.delete(id);
+    this.completedDownloads.push(download);
+
+    this.stats.activeCount = this.activeDownloads.size;
+    this.stats.totalDownloads++;
+    this.stats.totalBytes += download.bytesTransferred;
+    this._updateAverageSpeed();
+
+    this.emit('download:complete', download);
+  }
+
+  /**
+   * Mark a download as failed
+   * @param {string} id - Download identifier
+   * @param {Error} error - The error that caused the failure
+   */
+  failDownload(id, error) {
+    const download = this.activeDownloads.get(id);
+    if (!download) return;
+
+    download.status = 'failed';
+    download.error = error.message || String(error);
+    download.endTime = Date.now();
+    download.duration = download.endTime - download.startTime;
+
+    this.activeDownloads.delete(id);
+    this.completedDownloads.push(download);
+
+    this.stats.activeCount = this.activeDownloads.size;
+    this.stats.failedCount++;
+
+    this.emit('download:error', { download, error });
+  }
+
+  /**
+   * Cancel an active download
+   * @param {string} id - Download identifier
+   */
+  cancelDownload(id) {
+    const download = this.activeDownloads.get(id);
+    if (!download) return;
+
+    download.status = 'cancelled';
+    download.endTime = Date.now();
+    download.duration = download.endTime - download.startTime;
+
+    this.activeDownloads.delete(id);
+    this.completedDownloads.push(download);
+    this.stats.activeCount = this.activeDownloads.size;
+
+    this.emit('download:cancel', download);
+  }
+
+  /**
+   * Get current download statistics
+   * @returns {object} Download stats
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      activeDownloads: this.getActiveDownloads()
+    };
+  }
+
+  /**
+   * Get all active downloads
+   * @returns {Array} Active download records
+   */
+  getActiveDownloads() {
+    return Array.from(this.activeDownloads.values());
+  }
+
+  /**
+   * Get completed downloads
+   * @param {number} limit - Max number of records to return
+   * @returns {Array} Completed download records
+   */
+  getCompletedDownloads(limit = 100) {
+    return this.completedDownloads.slice(-limit);
+  }
+
+  /**
+   * Clear completed download history
+   */
+  clearHistory() {
+    this.completedDownloads = [];
+  }
+
+  /**
+   * Update the running average speed
+   * @private
+   */
+  _updateAverageSpeed() {
+    const completed = this.completedDownloads.filter(d => d.status === 'completed' && d.duration > 0);
+    if (completed.length === 0) {
+      this.stats.averageSpeed = 0;
+      return;
+    }
+
+    const totalSpeed = completed.reduce((sum, d) => {
+      return sum + (d.bytesTransferred / (d.duration / 1000));
+    }, 0);
+
+    this.stats.averageSpeed = totalSpeed / completed.length;
+  }
+}
+
+export default DownloadMonitor;

package/src/EventNotifier.js

@@ -0,0 +1,178 @@
+/**
+ * EventNotifier - Webhook and event notification for @kadi.build/file-sharing
+ *
+ * Sends notifications to registered webhooks when events occur.
+ * Supports filtering by event type, retry logic, and multiple notification channels.
+ *
+ * Migrated from src/eventNotifier.js
+ */
+
+import { EventEmitter } from 'events';
+
+export class EventNotifier extends EventEmitter {
+  constructor(config = {}) {
+    super();
+
+    this.config = {
+      maxRetries: 3,
+      retryDelay: 1000,
+      timeout: 5000,
+      ...config
+    };
+
+    this.webhooks = new Map();
+    this._notificationHistory = [];
+  }
+
+  /**
+   * Register a webhook for event notifications
+   * @param {string} url - Webhook URL to send notifications to
+   * @param {string[]} events - Array of event names to subscribe to (empty = all events)
+   * @param {object} options - Additional options (headers, etc.)
+   */
+  addWebhook(url, events = [], options = {}) {
+    this.webhooks.set(url, {
+      url,
+      events: events.length > 0 ? new Set(events) : null, // null = all events
+      headers: options.headers || {},
+      active: true,
+      failCount: 0,
+      lastNotified: null
+    });
+  }
+
+  /**
+   * Remove a registered webhook
+   * @param {string} url - Webhook URL to remove
+   */
+  removeWebhook(url) {
+    this.webhooks.delete(url);
+  }
+
+  /**
+   * Send a notification for an event
+   * @param {string} event - Event name
+   * @param {object} data - Event data payload
+   */
+  async notify(event, data = {}) {
+    const payload = {
+      event,
+      timestamp: new Date().toISOString(),
+      data
+    };
+
+    const promises = [];
+
+    for (const [url, webhook] of this.webhooks) {
+      if (!webhook.active) continue;
+
+      // Check event filter
+      if (webhook.events && !webhook.events.has(event)) continue;
+
+      promises.push(this._sendNotification(url, webhook, payload));
+    }
+
+    if (promises.length > 0) {
+      await Promise.allSettled(promises);
+    }
+
+    // Record in history
+    this._notificationHistory.push({
+      event,
+      timestamp: payload.timestamp,
+      recipientCount: promises.length
+    });
+
+    // Keep history bounded
+    if (this._notificationHistory.length > 1000) {
+      this._notificationHistory = this._notificationHistory.slice(-500);
+    }
+  }
+
+  /**
+   * Get list of registered webhooks
+   * @returns {Array} Webhook configurations
+   */
+  getWebhooks() {
+    return Array.from(this.webhooks.values()).map(w => ({
+      url: w.url,
+      events: w.events ? Array.from(w.events) : ['*'],
+      active: w.active,
+      failCount: w.failCount,
+      lastNotified: w.lastNotified
+    }));
+  }
+
+  /**
+   * Get notification history
+   * @param {number} limit - Max records to return
+   * @returns {Array}
+   */
+  getHistory(limit = 50) {
+    return this._notificationHistory.slice(-limit);
+  }
+
+  /**
+   * Send notification to a single webhook with retry logic
+   * @param {string} url - Webhook URL
+   * @param {object} webhook - Webhook config
+   * @param {object} payload - Notification payload
+   * @private
+   */
+  async _sendNotification(url, webhook, payload) {
+    let lastError;
+
+    for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+
+        const response = await fetch(url, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'User-Agent': 'KadiFileSharing/1.0',
+            ...webhook.headers
+          },
+          body: JSON.stringify(payload),
+          signal: controller.signal
+        });
+
+        clearTimeout(timeoutId);
+
+        if (response.ok) {
+          webhook.failCount = 0;
+          webhook.lastNotified = new Date().toISOString();
+          this.emit('notification:sent', { url, event: payload.event });
+          return;
+        }
+
+        lastError = new Error(`HTTP ${response.status}: ${response.statusText}`);
+      } catch (error) {
+        lastError = error;
+      }
+
+      // Wait before retry
+      if (attempt < this.config.maxRetries) {
+        await new Promise(resolve =>
+          setTimeout(resolve, this.config.retryDelay * (attempt + 1))
+        );
+      }
+    }
+
+    // All retries failed
+    webhook.failCount++;
+    if (webhook.failCount >= 10) {
+      webhook.active = false;
+      this.emit('webhook:disabled', { url, reason: 'Too many failures' });
+    }
+
+    this.emit('notification:failed', {
+      url,
+      event: payload.event,
+      error: lastError?.message || 'Unknown error'
+    });
+  }
+}
+
+export default EventNotifier;