@kadi.build/tunnel-services 1.0.0

package/src/services/LocalTunnelService.js

@@ -0,0 +1,188 @@
+/**
+ * @fileoverview LocalTunnel service implementation
+ * Provides tunneling through localtunnel npm package
+ */
+
+import createDebug from 'debug';
+import { BaseTunnelService } from '../BaseTunnelService.js';
+import {
+  TransientTunnelError,
+  PermanentTunnelError,
+  ConnectionTimeoutError
+} from '../errors.js';
+
+const debug = createDebug('kadi:tunnel:localtunnel');
+
+// Dynamic import of localtunnel (optional dependency)
+let localtunnel;
+try {
+  const ltModule = await import('localtunnel');
+  localtunnel = ltModule.default || ltModule;
+} catch {
+  localtunnel = null;
+}
+
+/**
+ * LocalTunnel service implementation
+ *
+ * Provides tunneling through localtunnel with support for:
+ * - Custom subdomain support
+ * - Automatic npm package validation
+ * - URL extraction from localtunnel output
+ * - Process management and cleanup
+ * - Comprehensive error handling
+ *
+ * @extends BaseTunnelService
+ */
+export default class LocalTunnelService extends BaseTunnelService {
+
+  constructor(config) {
+    super(config);
+    this.DEFAULT_TIMEOUT = 30000;
+  }
+
+  get name() {
+    return 'localtunnel';
+  }
+
+  async connect(options) {
+    if (!options || typeof options.port !== 'number') {
+      throw new PermanentTunnelError('Port number is required for LocalTunnel');
+    }
+
+    if (options.port < 1 || options.port > 65535) {
+      throw new PermanentTunnelError(`Invalid port number: ${options.port}. Must be between 1-65535`);
+    }
+
+    if (!localtunnel) {
+      throw new PermanentTunnelError(
+        'localtunnel package is not installed. Install with: npm install localtunnel'
+      );
+    }
+
+    const tunnelId = this._generateTunnelId();
+    const timeout = options.timeout || this.DEFAULT_TIMEOUT;
+
+    this._emitProgress('connecting', 'Establishing LocalTunnel connection...', tunnelId);
+
+    try {
+      const ltOptions = {
+        port: options.port,
+        subdomain: options.subdomain || undefined,
+        host: 'https://localtunnel.me'
+      };
+
+      debug(`🔗 Creating LocalTunnel: port ${options.port}${options.subdomain ? ` subdomain ${options.subdomain}` : ''}`);
+
+      const tunnel = await Promise.race([
+        localtunnel(ltOptions),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new ConnectionTimeoutError(this.name, timeout)), timeout)
+        )
+      ]);
+
+      const tunnelInfo = {
+        id: tunnelId,
+        serviceName: 'localtunnel',
+        localPort: options.port,
+        subdomain: options.subdomain,
+        url: tunnel.url,
+        tunnel: tunnel,
+        createdAt: new Date(),
+        status: 'active'
+      };
+
+      this.activeTunnels.set(tunnelId, tunnelInfo);
+
+      this._emitProgress('connected', 'LocalTunnel established', tunnelId);
+      this._emitTunnelCreated(tunnelInfo);
+
+      debug(`✅ LocalTunnel established: ${tunnel.url}`);
+
+      return {
+        tunnelId: tunnelId,
+        url: tunnel.url,
+        subdomain: this._extractSubdomain(tunnel.url),
+        localPort: options.port,
+        createdAt: new Date(),
+        status: 'active',
+        service: 'localtunnel'
+      };
+
+    } catch (error) {
+      this.activeTunnels.delete(tunnelId);
+
+      if (error instanceof ConnectionTimeoutError) {
+        throw error;
+      }
+
+      const errorMessage = error.message || error.toString();
+
+      if (errorMessage.includes('subdomain') && errorMessage.includes('not available')) {
+        throw new PermanentTunnelError(
+          'Subdomain is not available. Try a different subdomain or remove subdomain requirement.'
+        );
+      }
+
+      if (errorMessage.includes('port') && errorMessage.includes('in use')) {
+        throw new TransientTunnelError(`Port ${options.port} is already in use`);
+      }
+
+      if (errorMessage.includes('ECONNREFUSED') || errorMessage.includes('network') || errorMessage.includes('timeout')) {
+        throw new TransientTunnelError(`Network error: ${errorMessage}`);
+      }
+
+      throw new TransientTunnelError(`LocalTunnel creation failed: ${errorMessage}`);
+    }
+  }
+
+  async disconnect(tunnelId) {
+    const tunnelInfo = this.activeTunnels.get(tunnelId);
+
+    if (!tunnelInfo) {
+      return false;
+    }
+
+    this._emitProgress('disconnecting', 'Destroying LocalTunnel...', tunnelId);
+
+    try {
+      if (tunnelInfo.tunnel && typeof tunnelInfo.tunnel.close === 'function') {
+        tunnelInfo.tunnel.close();
+        debug(`🔌 LocalTunnel disconnected: ${tunnelInfo.url}`);
+      }
+
+      this.activeTunnels.delete(tunnelId);
+      this._emitProgress('disconnected', 'LocalTunnel destroyed', tunnelId);
+      this._emitTunnelDestroyed(tunnelId);
+
+      debug(`✅ LocalTunnel ${tunnelId} disconnected`);
+      return true;
+    } catch (error) {
+      this.activeTunnels.delete(tunnelId);
+      this._emitTunnelDestroyed(tunnelId);
+      throw error;
+    }
+  }
+
+  getStatus() {
+    return {
+      serviceName: 'localtunnel',
+      isActive: this.activeTunnels.size > 0,
+      activeTunnels: this.activeTunnels.size,
+      available: !!localtunnel,
+      tunnels: Array.from(this.activeTunnels.values()).map(tunnel => ({
+        id: tunnel.id,
+        url: tunnel.url,
+        localPort: tunnel.localPort,
+        status: tunnel.status,
+        createdAt: tunnel.createdAt
+      }))
+    };
+  }
+
+  _extractSubdomain(url) {
+    if (!url) return null;
+    const match = url.match(/https:\/\/([a-zA-Z0-9-]+)\.loca\.lt/);
+    return match ? match[1] : null;
+  }
+}

package/src/services/LocalhostRunTunnelService.js

@@ -0,0 +1,241 @@
+/**
+ * @fileoverview LocalhostRun tunnel service implementation
+ * Provides SSH-based tunneling through localhost.run
+ */
+
+import createDebug from 'debug';
+import { BaseTunnelService } from '../BaseTunnelService.js';
+import {
+  TransientTunnelError,
+  PermanentTunnelError,
+  SSHUnavailableError,
+  ConnectionTimeoutError
+} from '../errors.js';
+import { spawn } from 'child_process';
+
+const debug = createDebug('kadi:tunnel:localhost.run');
+
+/**
+ * LocalhostRun tunnel service implementation
+ *
+ * Provides SSH-based tunneling through localhost.run with support for:
+ * - Automatic URL extraction from SSH output
+ * - Email verification handling
+ * - Process management and cleanup
+ * - Comprehensive error handling
+ *
+ * @extends BaseTunnelService
+ */
+export default class LocalhostRunTunnelService extends BaseTunnelService {
+
+  constructor(config) {
+    super(config);
+    this.DEFAULT_TIMEOUT = 30000;
+  }
+
+  get name() {
+    return 'localhost.run';
+  }
+
+  async connect(options) {
+    if (!options || typeof options.port !== 'number' || options.port < 1 || options.port > 65535) {
+      throw new PermanentTunnelError('Valid port number (1-65535) is required for LocalhostRun tunnel');
+    }
+
+    const tunnelId = this._generateTunnelId();
+    const timeout = options.timeout || this.DEFAULT_TIMEOUT;
+
+    this._emitProgress('connecting', 'Establishing LocalhostRun tunnel...', tunnelId);
+
+    return new Promise((resolve, reject) => {
+      let resolved = false;
+      let sshProcess = null;
+      let timeoutHandle = null;
+
+      const sshArgs = this._buildSSHArgs(options.port);
+
+      debug(`🔗 Creating localhost.run tunnel: ssh ${sshArgs.join(' ')}`);
+
+      try {
+        sshProcess = spawn('ssh', sshArgs, {
+          stdio: ['pipe', 'pipe', 'pipe']
+        });
+
+        const tunnelInfo = {
+          id: tunnelId,
+          serviceName: 'localhost.run',
+          localPort: options.port,
+          process: sshProcess,
+          createdAt: new Date(),
+          status: 'connecting'
+        };
+
+        this.activeTunnels.set(tunnelId, tunnelInfo);
+
+        let output = '';
+        let tunnelUrl = null;
+
+        const handleOutput = (data) => {
+          const text = data.toString();
+          output += text;
+          debug('LocalhostRun output:', text.trim());
+
+          tunnelUrl = this._extractLocalhostRunUrl(output);
+          if (tunnelUrl && !resolved) {
+            resolved = true;
+
+            if (timeoutHandle) {
+              clearTimeout(timeoutHandle);
+            }
+
+            tunnelInfo.status = 'active';
+            tunnelInfo.url = tunnelUrl;
+
+            this._emitProgress('connected', 'LocalhostRun tunnel established', tunnelId);
+            this._emitTunnelCreated(tunnelInfo);
+
+            resolve({
+              tunnelId: tunnelId,
+              url: tunnelUrl,
+              subdomain: this._extractSubdomain(tunnelUrl),
+              localPort: options.port,
+              createdAt: new Date(),
+              status: 'active',
+              service: 'localhost.run'
+            });
+          }
+        };
+
+        sshProcess.stdout.on('data', handleOutput);
+        sshProcess.stderr.on('data', handleOutput);
+
+        sshProcess.on('error', (error) => {
+          if (!resolved) {
+            resolved = true;
+
+            if (timeoutHandle) {
+              clearTimeout(timeoutHandle);
+            }
+
+            this.activeTunnels.delete(tunnelId);
+
+            if (error.code === 'ENOENT') {
+              reject(new SSHUnavailableError());
+            } else {
+              reject(new TransientTunnelError(`LocalhostRun tunnel failed: ${error.message}`));
+            }
+          }
+        });
+
+        sshProcess.on('exit', (code) => {
+          if (!resolved) {
+            resolved = true;
+
+            if (timeoutHandle) {
+              clearTimeout(timeoutHandle);
+            }
+
+            this.activeTunnels.delete(tunnelId);
+
+            if (code !== 0) {
+              reject(new TransientTunnelError(`LocalhostRun tunnel exited with code ${code}`));
+            }
+          } else {
+            this.activeTunnels.delete(tunnelId);
+            this._emitTunnelDestroyed(tunnelId);
+          }
+        });
+
+        timeoutHandle = setTimeout(() => {
+          if (!resolved) {
+            resolved = true;
+
+            if (sshProcess && !sshProcess.killed) {
+              sshProcess.kill();
+            }
+
+            this.activeTunnels.delete(tunnelId);
+            reject(new ConnectionTimeoutError('localhost.run', timeout));
+          }
+        }, timeout);
+
+      } catch (error) {
+        if (!resolved) {
+          resolved = true;
+          reject(new TransientTunnelError(`Failed to start LocalhostRun tunnel: ${error.message}`));
+        }
+      }
+    });
+  }
+
+  async disconnect(tunnelId) {
+    const tunnelInfo = this.activeTunnels.get(tunnelId);
+
+    if (!tunnelInfo) {
+      return false;
+    }
+
+    try {
+      if (tunnelInfo.process && !tunnelInfo.process.killed) {
+        tunnelInfo.process.kill();
+      }
+
+      this.activeTunnels.delete(tunnelId);
+      this._emitTunnelDestroyed(tunnelId);
+
+      return true;
+    } catch (error) {
+      this.activeTunnels.delete(tunnelId);
+      return false;
+    }
+  }
+
+  getStatus() {
+    return {
+      serviceName: 'localhost.run',
+      available: true,
+      isActive: this.activeTunnels.size > 0,
+      activeTunnels: this.activeTunnels.size,
+      tunnels: Array.from(this.activeTunnels.values()).map(tunnel => ({
+        id: tunnel.id,
+        url: tunnel.url,
+        localPort: tunnel.localPort,
+        status: tunnel.status,
+        createdAt: tunnel.createdAt
+      }))
+    };
+  }
+
+  _buildSSHArgs(port) {
+    return [
+      '-R', `80:localhost:${port}`,
+      'ssh.localhost.run',
+      '-o', 'StrictHostKeyChecking=no',
+      '-o', 'ServerAliveInterval=30',
+      '-o', 'ExitOnForwardFailure=yes'
+    ];
+  }
+
+  _extractLocalhostRunUrl(output) {
+    // localhost.run uses .lhr.life domains for tunnels (previously .localhost.run)
+    // Match patterns like: https://abcdef1234.lhr.life or https://xxxx.localhost.run
+    // Avoid matching static URLs like admin.localhost.run
+    const patterns = [
+      /https:\/\/[a-zA-Z0-9-]+\.lhr\.life/,
+      /https:\/\/[a-f0-9]{8,}[a-zA-Z0-9-]*\.localhost\.run/
+    ];
+
+    for (const pattern of patterns) {
+      const match = output.match(pattern);
+      if (match) return match[0];
+    }
+
+    return null;
+  }
+
+  _extractSubdomain(url) {
+    if (!url) return null;
+    const match = url.match(/https:\/\/([a-zA-Z0-9-]+)\.(?:lhr\.life|localhost\.run)/);
+    return match ? match[1] : null;
+  }
+}