@kadi.build/file-sharing 1.0.0

package/src/ShutdownManager.js

@@ -0,0 +1,135 @@
+/**
+ * ShutdownManager - Graceful shutdown for @kadi.build/file-sharing
+ *
+ * Manages ordered shutdown of components with priority-based callback execution,
+ * timeout handling, and process signal integration.
+ *
+ * Migrated from src/shutdownManager.js
+ */
+
+import { EventEmitter } from 'events';
+
+export class ShutdownManager extends EventEmitter {
+  constructor(config = {}) {
+    super();
+
+    this.config = {
+      gracefulTimeout: 30000,
+      finishActiveDownloads: true,
+      forceKillTimeout: 60000,
+      ...config
+    };
+
+    this.isShuttingDown = false;
+    this.shutdownCallbacks = [];
+    this._signalHandlersInstalled = false;
+  }
+
+  /**
+   * Register a shutdown callback with priority
+   * Lower priority numbers execute first.
+   * @param {Function} callback - Async callback to execute during shutdown
+   * @param {number} priority - Execution priority (lower = earlier, default 10)
+   */
+  register(callback, priority = 10) {
+    this.shutdownCallbacks.push({ callback, priority });
+    this.shutdownCallbacks.sort((a, b) => a.priority - b.priority);
+  }
+
+  /**
+   * Unregister a previously registered callback
+   * @param {Function} callback - The callback to remove
+   */
+  unregister(callback) {
+    this.shutdownCallbacks = this.shutdownCallbacks.filter(
+      (entry) => entry.callback !== callback
+    );
+  }
+
+  /**
+   * Install process signal handlers (SIGINT, SIGTERM)
+   */
+  installSignalHandlers() {
+    if (this._signalHandlersInstalled) return;
+
+    const handler = () => {
+      this.shutdown().catch((err) => {
+        this.emit('shutdown:error', err);
+      });
+    };
+
+    process.on('SIGINT', handler);
+    process.on('SIGTERM', handler);
+    this._signalHandlersInstalled = true;
+  }
+
+  /**
+   * Perform graceful shutdown
+   * Executes all registered callbacks in priority order with timeout.
+   */
+  async shutdown() {
+    if (this.isShuttingDown) {
+      return;
+    }
+
+    this.isShuttingDown = true;
+    this.emit('shutdown:start');
+
+    const total = this.shutdownCallbacks.length;
+    let completed = 0;
+
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(
+        () => reject(new Error('Shutdown timeout exceeded')),
+        this.config.gracefulTimeout
+      );
+    });
+
+    try {
+      await Promise.race([
+        this._executeCallbacks((count) => {
+          completed = count;
+          this.emit('shutdown:progress', { completed, total });
+        }),
+        timeoutPromise
+      ]);
+
+      this.emit('shutdown:complete');
+    } catch (error) {
+      this.emit('shutdown:timeout', error);
+      await this.forceShutdown();
+    }
+  }
+
+  /**
+   * Force shutdown - skip remaining callbacks
+   */
+  async forceShutdown() {
+    this.emit('shutdown:force');
+    this.isShuttingDown = true;
+    // Clear remaining callbacks
+    this.shutdownCallbacks = [];
+    this.emit('shutdown:complete');
+  }
+
+  /**
+   * Execute all registered callbacks in order
+   * @param {Function} onProgress - Progress callback
+   * @private
+   */
+  async _executeCallbacks(onProgress) {
+    let completed = 0;
+
+    for (const { callback } of this.shutdownCallbacks) {
+      try {
+        await callback();
+      } catch (error) {
+        this.emit('shutdown:error', error);
+      }
+      completed++;
+      if (onProgress) onProgress(completed);
+    }
+  }
+}
+
+export default ShutdownManager;

package/src/index.js

@@ -0,0 +1,69 @@
+/**
+ * @kadi.build/file-sharing - Main entry point
+ *
+ * File sharing service with tunneling and local S3-compatible interface.
+ * Integrates @kadi.build/file-manager and @kadi.build/tunnel-services.
+ */
+
+// Core classes
+export { FileSharingServer } from './FileSharingServer.js';
+export { HttpServerProvider } from './HttpServerProvider.js';
+export { S3Server } from './S3Server.js';
+export { DownloadMonitor } from './DownloadMonitor.js';
+export { ShutdownManager } from './ShutdownManager.js';
+export { MonitoringDashboard } from './MonitoringDashboard.js';
+export { EventNotifier } from './EventNotifier.js';
+
+// Re-export from dependencies for convenience
+export { FileManager, createFileManager } from '@kadi.build/file-manager';
+export { TunnelManager } from '@kadi.build/tunnel-services';
+
+// Default export
+export { FileSharingServer as default } from './FileSharingServer.js';
+
+/**
+ * Create a FileSharingServer with default options
+ * @param {object} options - Configuration options
+ * @returns {FileSharingServer}
+ */
+export function createFileSharingServer(options = {}) {
+  return new FileSharingServer(options);
+}
+
+/**
+ * Quick share - one-liner to share a directory
+ * @param {string} directory - Directory to share
+ * @param {object} options - Options
+ * @param {number}  [options.port=3000]         - HTTP port
+ * @param {boolean} [options.tunnel=false]       - Enable tunnel
+ * @param {string}  [options.tunnelService='kadi'] - Tunnel service name
+ * @param {string}  [options.kadiToken]          - KĀDI auth token (or set KADI_TUNNEL_TOKEN env)
+ * @param {string}  [options.ngrokAuthToken]     - Ngrok auth token (or set NGROK_AUTHTOKEN env)
+ * @param {object}  [options.auth]               - HTTP auth config ({apiKey} or {username,password})
+ * @param {object}  [options.tunnelOptions]      - Extra options passed to TunnelManager
+ * @returns {Promise<{ server: FileSharingServer, localUrl: string, publicUrl?: string }>}
+ */
+export async function createQuickShare(directory, options = {}) {
+  const server = new FileSharingServer({
+    staticDir: directory,
+    port: options.port || 3000,
+    auth: options.auth || null,
+    tunnel: options.tunnel
+      ? {
+          enabled: true,
+          service: options.tunnelService || 'kadi',
+          kadiToken: options.kadiToken,
+          ngrokAuthToken: options.ngrokAuthToken,
+          ...(options.tunnelOptions || {})
+        }
+      : { enabled: false }
+  });
+
+  const info = await server.start();
+
+  return {
+    server,
+    localUrl: info.localUrl,
+    publicUrl: info.publicUrl || undefined
+  };
+}