telegem 2.1.0 → 3.0.1

data/lib/webhook/server.rb

@@ -1,326 +1,185 @@
-# lib/webhook/server.rb - V2.0.0 (CLOUD-READY)
+# lib/telegem/webhook/server.rb
+require 'async/http/server'
+require 'async/http/endpoint'
+require 'openssl'
+require 'yaml'
 require 'json'
-require 'rack'
+require 'securerandom'
+require 'uri'
 
 module Telegem
   module Webhook
     class Server
-      attr_reader :bot, :port, :host, :logger, :running, :secret_token
-      
-      def initialize(bot, port: nil, host: '0.0.0.0', logger: nil, max_threads: 10, secret_token: nil)
+      attr_reader :bot, :port, :host, :logger, :secret_token, :running, :server, :ssl_mode
+
+      def initialize(bot, port: nil, host: '0.0.0.0', secret_token: nil, logger: nil, ssl: nil)
         @bot = bot
         @port = port || ENV['PORT'] || 3000
         @host = host
+        @secret_token = secret_token || ENV['WEBHOOK_SECRET_TOKEN'] || SecureRandom.hex(16)
         @logger = logger || Logger.new($stdout)
-        @max_threads = max_threads
-        @thread_pool = Concurrent::FixedThreadPool.new(max_threads)
-        @secret_token = secret_token || generate_secret_token
-        @server = nil
-        @running = false
-        @webhook_path = "/webhook"
-      end
-      
-      # Production server with Puma
-      def run
-        return if @running
-        
-        @logger.info "🚀 Starting Telegem webhook server on #{@host}:#{@port}"
-        @logger.info "📝 Set Telegram webhook to: #{webhook_url}"
-        @logger.info "🔐 Secret token: #{@secret_token}"
-        @logger.info "✅ Using Puma (production-ready)"
-        @logger.info "☁️  Cloud-ready: #{cloud_platform}"
-        
-        @running = true
-        
-        app = build_rack_app
-        start_puma_server(app)
-        
-        self
-      end
-      
-      def stop
-        return unless @running
-        
-        @logger.info "🛑 Stopping webhook server..."
         @running = false
-        
-        @server&.stop
-        @thread_pool.shutdown
-        @thread_pool.wait_for_termination(5)
-        
-        @logger.info "✅ Webhook server stopped"
-      end
-      
-      alias_method :shutdown, :stop
-      
-      def running?
-        @running
+        @server = nil
+
+        @ssl_mode, @ssl_context = determine_ssl_mode(ssl)
+        log_configuration
+        validate_ssl_setup
       end
-      
-      def webhook_url
-        # For cloud platforms, use their URL
-        if cloud_url = detect_cloud_url
-          "#{cloud_url}#{@webhook_path}"
-        elsif ENV['WEBHOOK_URL']
-          ENV['WEBHOOK_URL']
-        else
-          # Local development
-          "https://#{@host}:#{@port}#{@webhook_path}"
+
+      def determine_ssl_mode(ssl_options)
+        return [:none, nil] if ssl_options == false
+
+        if File.exist?('.telegem-ssl')
+          config = YAML.load_file('.telegem-ssl')
+          cert_path = config['cert_path']
+          key_path = config['key_path']
+
+          if cert_path && key_path && File.exist?(cert_path) && File.exist?(key_path)
+            return [:cli, load_certificate_files(cert_path, key_path)]
+          end
+        end
+
+        if ssl_options && ssl_options[:cert_path] && ssl_options[:key_path]
+          return [:manual, load_certificate_files(ssl_options[:cert_path], ssl_options[:key_path])]
+        end
+
+        if ENV['TELEGEM_WEBHOOK_URL'] && URI(ENV['TELEGEM_WEBHOOK_URL']).scheme == 'https'
+          return [:cloud, nil]
         end
+
+        [:none, nil]
       end
-      
-      def set_webhook(**options)
-        params = {
-          url: webhook_url,
-          secret_token: @secret_token,
-          drop_pending_updates: true
-        }.merge(options)
-        
-        @bot.api.call!('setWebhook', params)
+
+      def load_certificate_files(cert_path, key_path)
+        ctx = OpenSSL::SSL::SSLContext.new
+        ctx.cert = OpenSSL::X509::Certificate.new(File.read(cert_path))
+        ctx.key = OpenSSL::PKey::RSA.new(File.read(key_path))
+        ctx
+      rescue
+        nil
       end
-      
-      def delete_webhook
-        @bot.api.call!('deleteWebhook', {})
+
+      def validate_ssl_setup
+        case @ssl_mode
+        when :cli, :manual
+          raise "SSL certificate files not found or invalid" if @ssl_context.nil?
+        when :cloud
+          url = URI(ENV['TELEGEM_WEBHOOK_URL'])
+          raise "TELEGEM_WEBHOOK_URL must be HTTPS" unless url.scheme == 'https'
+        end
       end
-      
-      # Quick setup helper
-      def self.setup(bot, **options)
-        server = new(bot, **options)
-        server.run
-        server.set_webhook
-        server
+
+      def log_configuration
+        @logger.info("Webhook Server Configuration:")
+        @logger.info("  Mode: #{@ssl_mode.to_s.upcase}")
+        @logger.info("  Port: #{@port}")
+        @logger.info("  Host: #{@host}")
+        @logger.info("  Secret: #{@secret_token[0..8]}...")
       end
-      
-      private
-      
-      def build_rack_app
-        Rack::Builder.new do
-          use Rack::CommonLogger
-          use Rack::ShowExceptions if ENV['RACK_ENV'] == 'development'
-          
-          # Health endpoint (required by Render/Railway/Heroku)
-          map "/health" do
-            run ->(env) { 
-              [200, { 
-                'Content-Type' => 'application/json',
-                'Cache-Control' => 'no-cache'
-              }, [{ 
-                status: 'healthy',
-                timestamp: Time.now.iso8601,
-                service: 'telegem-webhook',
-                version: Telegem::VERSION
-              }.to_json]] 
-            }
-          end
-          
-          # Webhook endpoint
-          map "/webhook" do
-            run ->(env) do
-              server = env['telegem.server']
-              req = Rack::Request.new(env)
-              
-              if req.post?
-                server.handle_rack_request(req)
-              else
-                [405, { 'Content-Type' => 'text/plain' }, ['Method Not Allowed']]
-              end
-            end
-          end
-          
-          # Root landing page
-          map "/" do
-            run ->(env) do
-              server = env['telegem.server']
-              [200, { 'Content-Type' => 'text/html' }, [server.landing_page]]
-            end
-          end
+
+      def run
+        return if @running
+        @running = true
+
+        case @ssl_mode
+        when :cli, :manual
+          endpoint = Async::HTTP::Endpoint.parse("https://#{@host}:#{@port}", ssl_context: @ssl_context)
+          @logger.info("Starting HTTPS server with local certificates")
+        when :cloud
+          endpoint = Async::HTTP::Endpoint.parse("http://#{@host}:#{@port}")
+          @logger.info("Starting HTTP server (cloud platform handles SSL)")
+        else
+          endpoint = Async::HTTP::Endpoint.parse("http://#{@host}:#{@port}")
+          @logger.warn("Starting HTTP server (Telegram requires HTTPS)")
         end
-      end
-      
-      def start_puma_server(app)
-        require 'puma'
-        
-        # Cloud platforms set PORT environment variable
-        port = ENV['PORT'] || @port
-        
-        config = {
-          Host: @host,
-          Port: port,
-          Threads: "0:#{@max_threads}",
-          workers: ENV['WEB_CONCURRENCY']&.to_i || 1,
-          daemonize: false,
-          silent: false,
-          environment: ENV['RACK_ENV'] || 'production',
-          # Cloud platforms handle SSL termination
-          ssl_bind: nil  # Let platform handle SSL
-        }
-        
-        @server = Puma::Server.new(app)
-        @server.add_tcp_listener(@host, port)
-        
-        @server.app = ->(env) do
-          env['telegem.server'] = self
-          app.call(env)
+
+        @server = Async::HTTP::Server.for(endpoint) do |request|
+          handle_request(request)
         end
-        
-        Thread.new do
-          begin
-            @server.run
-          rescue => e
-            @logger.error "❌ Puma server error: #{e.message}"
-            @running = false
-            raise
-          end
+
+        Async do |task|
+          @server.run
+          task.sleep while @running
         end
-        
-        sleep 1 until @server.running
       end
-      
-      def handle_rack_request(req)
-        # Validate secret token from Telegram
-        telegram_token = req.get_header('X-Telegram-Bot-Api-Secret-Token')
-        
-        if @secret_token && telegram_token != @secret_token
-          @logger.warn "⚠️  Invalid secret token from #{req.ip}"
-          return [403, { 'Content-Type' => 'text/plain' }, ['Forbidden']]
+
+      def handle_request(request)
+        case request.path
+        when @secret_token, "/#{@secret_token}"
+          handle_webhook_request(request)
+        when '/health', '/healthz'
+          health_endpoint(request)
+        else
+          [404, {}, ["Not Found"]]
         end
-        
+      end
+
+      def handle_webhook_request(request)
+        return [405, {}, ["Method Not Allowed"]] unless request.post?
+
         begin
-          body = req.body.read
+          body = request.body.read
           update_data = JSON.parse(body)
-          
-          # Process in thread pool (not spawn new threads!)
-          @thread_pool.post do
-            begin
-              @bot.process(update_data)
-            rescue => e
-              @logger.error "Error processing update: #{e.message}"
-            end
-          end
-          
-          [200, { 'Content-Type' => 'text/plain' }, ['OK']]
-        rescue JSON::ParserError
-          [400, { 'Content-Type' => 'text/plain' }, ['Bad Request']]
-        rescue => e
-          @logger.error "Webhook error: #{e.message}"
-          [500, { 'Content-Type' => 'text/plain' }, ['Internal Server Error']]
+          Async { process_webhook_update(update_data) }
+          [200, {}, ["OK"]]
+        rescue
+          [500, {}, ["Internal Server Error"]]
         end
       end
-      
-      def landing_page
-        <<~HTML
-          <!DOCTYPE html>
-          <html>
-            <head>
-              <title>Telegem Webhook Server</title>
-              <style>
-                body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; 
-                       max-width: 800px; margin: 0 auto; padding: 20px; }
-                .status { background: #4CAF50; color: white; padding: 5px 10px; border-radius: 3px; }
-                code { background: #f5f5f5; padding: 2px 5px; border-radius: 3px; }
-                a { color: #2196F3; text-decoration: none; }
-              </style>
-            </head>
-            <body>
-              <h1>🤖 Telegem Webhook Server</h1>
-              <p><strong>Status:</strong> <span class="status">Running</span></p>
-              <p><strong>Webhook URL:</strong> <code>#{webhook_url}</code></p>
-              <p><strong>Health Check:</strong> <a href="/health">/health</a></p>
-              <p><strong>Platform:</strong> #{cloud_platform}</p>
-              <hr>
-              <p>To set up your Telegram bot:</p>
-              <pre><code>bot = Telegem.new('YOUR_TOKEN')
-server = bot.webhook
-server.run
-server.set_webhook</code></pre>
-            </body>
-          </html>
-        HTML
+
+      def process_webhook_update(update_data)
+        @bot.process(update_data)
+      rescue => e
+        @logger.error("Process error: #{e}")
+      end
+
+      def health_endpoint(request)
+        [200, { 'Content-Type' => 'application/json' }, [{
+          status: 'ok',
+          mode: @ssl_mode.to_s,
+          ssl: @ssl_mode != :none
+        }.to_json]]
       end
-      
-      def generate_secret_token
-        SecureRandom.hex(32)
+
+      def stop
+        return unless @running
+        @running = false
+        @server&.close
+        @logger.info("Server stopped")
+        @server = nil
       end
-      
-      def detect_cloud_url
-        # Render
-        if ENV['RENDER_EXTERNAL_URL']
-          ENV['RENDER_EXTERNAL_URL']
-        # Railway
-        elsif ENV['RAILWAY_STATIC_URL']
-          ENV['RAILWAY_STATIC_URL']
-        # Heroku
-        elsif ENV['HEROKU_APP_NAME']
-          "https://#{ENV['HEROKU_APP_NAME']}.herokuapp.com"
-        # Fly.io
-        elsif ENV['FLY_APP_NAME']
-          "https://#{ENV['FLY_APP_NAME']}.fly.dev"
-        # Vercel (if using serverless)
-        elsif ENV['VERCEL_URL']
-          "https://#{ENV['VERCEL_URL']}"
+
+      def webhook_url
+        case @ssl_mode
+        when :cli, :manual
+          "https://#{@host}:#{@port}#{@secret_token}"
+        when :cloud
+          cloud_url = ENV['TELEGEM_WEBHOOK_URL'].chomp('/')
+          "#{cloud_url}#{@secret_token}"
         else
-          nil
+          "http://#{@host}:#{@port}#{@secret_token}"
         end
       end
-      
-      def cloud_platform
-        if ENV['RENDER'] then 'Render'
-        elsif ENV['RAILWAY'] then 'Railway'
-        elsif ENV['HEROKU_APP_NAME'] then 'Heroku'
-        elsif ENV['FLY_APP_NAME'] then 'Fly.io'
-        elsif ENV['VERCEL'] then 'Vercel'
-        elsif ENV['DYNO'] then 'Heroku'
-        else 'Local/Unknown'
-        end
+
+      def set_webhook(**options)
+        url = webhook_url
+        params = { url: url }.merge(options)
+        @bot.set_webhook(**params)
+        @logger.info("Webhook set to: #{url}")
+        url
       end
-    end
-    
-    # Rack Middleware for existing apps
-    class Middleware
-      def initialize(app, bot, secret_token: nil)
-        @app = app
-        @bot = bot
-        @secret_token = secret_token || ENV['TELEGRAM_SECRET_TOKEN']
-        @thread_pool = Concurrent::FixedThreadPool.new(10)
+
+      def delete_webhook
+        @bot.delete_webhook
+        @logger.info("Webhook deleted")
       end
-      
-      def call(env)
-        req = Rack::Request.new(env)
-        
-        if req.post? && req.path == "/webhook"
-          handle_webhook(req)
-        else
-          @app.call(env)
-        end
+
+      def get_webhook_info
+        @bot.get_webhook_info
       end
-      
-      private
-      
-      def handle_webhook(req)
-        telegram_token = req.get_header('X-Telegram-Bot-Api-Secret-Token')
-        
-        if @secret_token && telegram_token != @secret_token
-          return [403, { 'Content-Type' => 'text/plain' }, ['Forbidden']]
-        end
-        
-        begin
-          update_data = JSON.parse(req.body.read)
-          
-          @thread_pool.post do
-            begin
-              @bot.process(update_data)
-            rescue => e
-              @bot.logger&.error("Webhook error: #{e.message}")
-            end
-          end
-          
-          [200, { 'Content-Type' => 'text/plain' }, ['OK']]
-        rescue JSON::ParserError
-          [400, { 'Content-Type' => 'text/plain' }, ['Bad Request']]
-        rescue => e
-          @bot.logger&.error("Webhook error: #{e.message}")
-          [500, { 'Content-Type' => 'text/plain' }, ['Internal Server Error']]
-        end
+
+      def running?
+        @running
       end
     end
   end