flow_chat 0.8.1 → 0.9.0

data/lib/flow_chat/simulator/views/simulator.html.erb

@@ -314,6 +314,15 @@
         height: 100%;
       }
 
+      .http-screen {
+        background: linear-gradient(180deg, #f8f9fa 0%, #e9ecef 100%);
+        flex: 1;
+        display: flex;
+        flex-direction: column;
+        min-height: 0;
+        height: 100%;
+      }
+
       .whatsapp-header {
         background: #075e54;
         color: white;
@@ -324,6 +333,16 @@
         flex-shrink: 0;
       }
 
+      .http-header {
+        background: #0066cc;
+        color: white;
+        padding: 15px 20px;
+        display: flex;
+        align-items: center;
+        gap: 12px;
+        flex-shrink: 0;
+      }
+
       .contact-avatar {
         width: 40px;
         height: 40px;
@@ -931,6 +950,20 @@
                     <!-- Messages will be displayed here -->
                   </div>
                 </div>
+
+                <!-- HTTP Screen -->
+                <div id="http-screen" class="http-screen hidden">
+                  <div class="http-header">
+                    <div class="config-icon" style="background: #0066cc;">🌐</div>
+                    <div class="contact-info">
+                      <h4>HTTP API</h4>
+                      <p>JSON Request/Response</p>
+                    </div>
+                  </div>
+                  <div class="messages-area" id="http-messages-area">
+                    <!-- HTTP messages will be displayed here -->
+                  </div>
+                </div>
               </div>
             </div>
             
@@ -1000,7 +1033,9 @@
         
         ussdScreen: document.getElementById('ussd-screen'),
         whatsappScreen: document.getElementById('whatsapp-screen'),
+        httpScreen: document.getElementById('http-screen'),
         messagesArea: document.getElementById('messages-area'),
+        httpMessagesArea: document.getElementById('http-messages-area'),
         contactAvatar: document.getElementById('contact-avatar'),
         headerContactName: document.getElementById('header-contact-name'),
         
@@ -1091,17 +1126,24 @@
       function updateUI() {
         if (!state.currentConfig) return
         
-        const isWhatsApp = state.currentConfig.processor_type === 'whatsapp'
+        const processorType = state.currentConfig.processor_type
+        const isWhatsApp = processorType === 'whatsapp'
+        const isHttp = processorType === 'http'
         
         // Show/hide platform-specific elements
         elements.contactNameGroup.style.display = isWhatsApp ? 'block' : 'none'
-        elements.ussdScreen.classList.toggle('hidden', isWhatsApp)
+        elements.ussdScreen.classList.toggle('hidden', isWhatsApp || isHttp)
         elements.whatsappScreen.classList.toggle('hidden', !isWhatsApp)
+        elements.httpScreen.classList.toggle('hidden', !isHttp)
         
         // Update input placeholder
-        elements.messageInput.placeholder = isWhatsApp ? 
-          'Type your WhatsApp message...' : 
-          'Enter USSD input...'
+        let placeholder = 'Enter USSD input...'
+        if (isWhatsApp) {
+          placeholder = 'Type your WhatsApp message...'
+        } else if (isHttp) {
+          placeholder = 'Type your HTTP message...'
+        }
+        elements.messageInput.placeholder = placeholder
         
         // Update button states
         const canStart = state.currentConfig && !state.isRunning
@@ -1144,8 +1186,10 @@
           
           if (state.currentConfig.processor_type === 'ussd') {
             await makeUSSDRequest()
-          } else {
+          } else if (state.currentConfig.processor_type === 'whatsapp') {
             await makeWhatsAppRequest()
+          } else if (state.currentConfig.processor_type === 'http') {
+            await makeHTTPRequest()
           }
           
           updateStatus('Connected', 'connected')
@@ -1164,9 +1208,11 @@
         try {
           updateStatus('Sending...', 'connecting')
           
-          // Add outgoing message to WhatsApp chat
+          // Add outgoing message to appropriate chat
           if (state.currentConfig.processor_type === 'whatsapp') {
             addMessage(message, true)
+          } else if (state.currentConfig.processor_type === 'http') {
+            addHttpMessage(message, true)
           }
           
           elements.messageInput.value = ''
@@ -1174,8 +1220,10 @@
           
           if (state.currentConfig.processor_type === 'ussd') {
             await makeUSSDRequest(message)
-          } else {
+          } else if (state.currentConfig.processor_type === 'whatsapp') {
             await makeWhatsAppRequest(message)
+          } else if (state.currentConfig.processor_type === 'http') {
+            await makeHTTPRequest(message)
           }
           
           updateStatus('Connected', 'connected')
@@ -1192,6 +1240,7 @@
         elements.messageInput.value = ''
         elements.ussdScreen.textContent = ''
         elements.messagesArea.innerHTML = ''
+        elements.httpMessagesArea.innerHTML = ''
         
         updateCharCount()
         updateStatus('Ready', 'disconnected')
@@ -1516,6 +1565,75 @@
         }
       }
 
+      // HTTP API request handler
+      async function makeHTTPRequest(userInput = null) {
+        const config = state.currentConfig
+        const userId = elements.phoneNumber.value
+        
+        // Build HTTP request payload
+        const requestData = {
+          session_id: state.sessionId,
+          user_id: userId,
+          input: userInput || '',
+          simulator_mode: true
+        }
+        
+        try {
+          const response = await fetch(config.endpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(requestData),
+            credentials: 'include'
+          })
+          
+          // Read and parse response
+          const responseText = await response.text()
+          let responseData = null
+          
+          // Try to parse as JSON
+          if (response.headers.get('content-type')?.includes('application/json')) {
+            try {
+              responseData = JSON.parse(responseText)
+              
+              // Display the HTTP response
+              displayHTTPResponse(responseData)
+              addRequestLog('POST', config.endpoint, requestData, responseData, response.status)
+              
+            } catch (jsonError) {
+              console.warn('Failed to parse JSON response:', jsonError)
+              responseData = responseText
+              displayHTTPResponse({ message: responseText, type: 'text' })
+              addRequestLog('POST', config.endpoint, requestData, responseData, response.status)
+            }
+          } else {
+            responseData = responseText
+            displayHTTPResponse({ message: responseText, type: 'text' })
+            addRequestLog('POST', config.endpoint, requestData, responseData, response.status)
+          }
+          
+          if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+          }
+          
+        } catch (error) {
+          // Log the error
+          addRequestLog('POST', config.endpoint, requestData, null, 0, error.message)
+          
+          // Show error in HTTP chat
+          setTimeout(() => {
+            addHttpMessage(
+              `❌ Request Failed: ${error.message}\n\n` +
+              `💡 Ensure your HTTP endpoint:\n` +
+              `• Accepts POST requests\n` +
+              `• Returns JSON with message, type, choices (optional), media (optional)\n` +
+              `• Handles CORS if cross-origin`
+            , false, 'error')
+          }, 500)
+          
+          throw error
+        }
+      }
+
       // Display Functions
       function displayUSSDResponse(content) {
         elements.ussdScreen.textContent = content
@@ -1889,6 +2007,100 @@
         elements.messagesArea.scrollTop = elements.messagesArea.scrollHeight
       }
 
+      function displayHTTPResponse(responseData) {
+        // Handle the HTTP response data
+        let message = responseData.message || 'Empty response'
+        let messageType = responseData.type || 'text'
+        let choices = responseData.choices || null
+        let media = responseData.media || null
+        
+        // Log choices for debugging if needed
+        if (choices && console.log) {
+          console.log('HTTP Response choices:', choices)
+        }
+        
+        // Add incoming HTTP message
+        addHttpMessage(message, false, messageType, choices, media)
+        
+        // Update session state based on response type  
+        state.isRunning = (messageType === 'prompt' || messageType === 'text')
+      }
+
+      function addHttpMessage(content, isOutgoing = false, type = 'text', choices = null, media = null) {
+        const messageDiv = document.createElement('div')
+        messageDiv.className = `message ${isOutgoing ? 'outgoing' : 'incoming'}`
+        
+        const bubbleDiv = document.createElement('div')
+        bubbleDiv.className = 'message-bubble'
+        
+        // Style differently for different message types
+        if (type === 'error') {
+          bubbleDiv.style.background = '#ffebee'
+          bubbleDiv.style.borderLeft = '4px solid #f44336'
+          bubbleDiv.style.whiteSpace = 'pre-line'
+        } else if (type === 'terminal') {
+          bubbleDiv.style.background = '#f3e5f5'
+          bubbleDiv.style.borderLeft = '4px solid #9c27b0'
+        }
+        
+        // Handle media content if present
+        if (media && !isOutgoing) {
+          const mediaContainer = document.createElement('div')
+          mediaContainer.className = 'media-container'
+          mediaContainer.style.marginBottom = content ? '8px' : '0'
+          
+          if (media.type === 'image' && media.url) {
+            const img = document.createElement('img')
+            img.src = media.url
+            img.style.maxWidth = '100%'
+            img.style.height = 'auto'
+            img.style.borderRadius = '8px'
+            img.style.display = 'block'
+            img.alt = media.caption || 'Image'
+            mediaContainer.appendChild(img)
+          }
+          
+          bubbleDiv.appendChild(mediaContainer)
+        }
+        
+        // Add text content
+        if (content) {
+          const textDiv = document.createElement('div')
+          textDiv.textContent = content
+          bubbleDiv.appendChild(textDiv)
+        }
+        
+        messageDiv.appendChild(bubbleDiv)
+        
+        // Add choice buttons for incoming messages
+        if (!isOutgoing && choices && Object.keys(choices).length > 0) {
+          const buttonsDiv = document.createElement('div')
+          buttonsDiv.className = 'interactive-buttons'
+          
+          Object.entries(choices).forEach(([key, value]) => {
+            const btn = document.createElement('div')
+            btn.className = 'interactive-button'
+            
+            const choiceKey = value.key || key
+            const displayValue = value.value || 'Option'
+            
+            btn.textContent = displayValue
+            btn.onclick = () => selectHttpOption(choiceKey)
+            buttonsDiv.appendChild(btn)
+          })
+          
+          bubbleDiv.appendChild(buttonsDiv)
+        }
+        
+        elements.httpMessagesArea.appendChild(messageDiv)
+        elements.httpMessagesArea.scrollTop = elements.httpMessagesArea.scrollHeight
+      }
+
+      function selectHttpOption(optionKey) {
+        elements.messageInput.value = optionKey
+        sendMessage()
+      }
+
       function getDocumentIcon(filename) {
         if (!filename) return '📄'
         

data/lib/flow_chat/telegram/client.rb

@@ -0,0 +1,240 @@
+require "net/http"
+require "json"
+require "uri"
+
+module FlowChat
+  module Telegram
+    class Client
+      include FlowChat::Instrumentation
+
+      def initialize(config)
+        @config = config
+        FlowChat.logger.info { "Telegram::Client: Initialized Telegram client" }
+      end
+
+      # Main send_message method matching FlowChat pattern
+      def send_message(chat_id, prompt, choices: nil, media: nil)
+        FlowChat.logger.info { "Telegram::Client: Sending message to chat #{chat_id}" }
+
+        response = FlowChat::Telegram::Renderer.new(prompt, choices: choices, media: media).render
+        type, content, options = response
+
+        case type
+        when :text
+          send_text(chat_id, content)
+        when :inline_keyboard
+          send_text_with_keyboard(chat_id, content, options[:keyboard])
+        when :photo
+          send_photo(chat_id, options[:url], caption: content)
+        when :photo_with_keyboard
+          send_photo_with_keyboard(chat_id, options[:url], caption: content, keyboard: options[:keyboard])
+        when :document
+          send_document(chat_id, options[:url], caption: content)
+        when :video
+          send_video(chat_id, options[:url], caption: content)
+        when :audio
+          send_audio(chat_id, options[:url], caption: content)
+        when :voice
+          send_voice(chat_id, options[:url])
+        else
+          send_text(chat_id, content.to_s)
+        end
+      end
+
+      def send_text(chat_id, text, parse_mode: "HTML")
+        api_request("sendMessage", {
+          chat_id: chat_id,
+          text: text,
+          parse_mode: parse_mode
+        }.compact)
+      end
+
+      def send_text_with_keyboard(chat_id, text, keyboard, parse_mode: "HTML")
+        api_request("sendMessage", {
+          chat_id: chat_id,
+          text: text,
+          parse_mode: parse_mode,
+          reply_markup: {inline_keyboard: keyboard}
+        }.compact)
+      end
+
+      def send_photo(chat_id, photo_url_or_id, caption: nil)
+        api_request("sendPhoto", {
+          chat_id: chat_id,
+          photo: photo_url_or_id,
+          caption: caption
+        }.compact)
+      end
+
+      def send_photo_with_keyboard(chat_id, photo_url_or_id, caption: nil, keyboard: nil)
+        api_request("sendPhoto", {
+          chat_id: chat_id,
+          photo: photo_url_or_id,
+          caption: caption,
+          reply_markup: keyboard ? {inline_keyboard: keyboard} : nil
+        }.compact)
+      end
+
+      def send_document(chat_id, document_url_or_id, caption: nil)
+        api_request("sendDocument", {
+          chat_id: chat_id,
+          document: document_url_or_id,
+          caption: caption
+        }.compact)
+      end
+
+      def send_video(chat_id, video_url_or_id, caption: nil)
+        api_request("sendVideo", {
+          chat_id: chat_id,
+          video: video_url_or_id,
+          caption: caption
+        }.compact)
+      end
+
+      def send_audio(chat_id, audio_url_or_id, caption: nil)
+        api_request("sendAudio", {
+          chat_id: chat_id,
+          audio: audio_url_or_id,
+          caption: caption
+        }.compact)
+      end
+
+      def send_voice(chat_id, voice_url_or_id)
+        api_request("sendVoice", {
+          chat_id: chat_id,
+          voice: voice_url_or_id
+        })
+      end
+
+      def answer_callback_query(callback_query_id, text: nil, show_alert: false)
+        api_request("answerCallbackQuery", {
+          callback_query_id: callback_query_id,
+          text: text,
+          show_alert: show_alert
+        }.compact)
+      end
+
+      def edit_message_text(chat_id, message_id, text, keyboard: nil, parse_mode: "HTML")
+        api_request("editMessageText", {
+          chat_id: chat_id,
+          message_id: message_id,
+          text: text,
+          parse_mode: parse_mode,
+          reply_markup: keyboard ? {inline_keyboard: keyboard} : nil
+        }.compact)
+      end
+
+      def delete_message(chat_id, message_id)
+        api_request("deleteMessage", {
+          chat_id: chat_id,
+          message_id: message_id
+        })
+      end
+
+      # Send a chat action (e.g. typing indicator) to a Telegram chat.
+      #
+      # The action lasts ~5 seconds or until the next outbound message.
+      # Valid actions per Telegram Bot API: "typing", "upload_photo",
+      # "record_video", "upload_video", "record_voice", "upload_voice",
+      # "upload_document", "choose_sticker", "find_location",
+      # "record_video_note", "upload_video_note".
+      #
+      # @param chat_id [Integer, String] the target chat id
+      # @param action [String] the chat action to broadcast (default: "typing")
+      # @return [Hash] parsed Telegram API response
+      def send_chat_action(chat_id, action: "typing")
+        api_request("sendChatAction", chat_id: chat_id, action: action)
+      end
+
+      # Show a typing indicator in a Telegram chat.
+      #
+      # Convenience wrapper around `send_chat_action(chat_id, action: "typing")`.
+      # The indicator lasts ~5 seconds or until the next outbound message;
+      # there is no stop-typing call.
+      #
+      # @param chat_id [Integer, String] the target chat id
+      # @return [Hash] parsed Telegram API response
+      def indicate_typing(chat_id)
+        send_chat_action(chat_id, action: "typing")
+      end
+
+      # Webhook management
+      def set_webhook(url, secret_token: nil, allowed_updates: nil)
+        api_request("setWebhook", {
+          url: url,
+          secret_token: secret_token,
+          allowed_updates: allowed_updates || ["message", "callback_query"]
+        }.compact)
+      end
+
+      def delete_webhook
+        api_request("deleteWebhook")
+      end
+
+      def get_webhook_info
+        api_request("getWebhookInfo")
+      end
+
+      def get_me
+        api_request("getMe")
+      end
+
+      private
+
+      def api_request(method, params = {})
+        uri = URI("#{@config.api_base_url}/#{method}")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request.body = params.to_json
+
+        FlowChat.logger.debug { "Telegram::Client: API request to #{method}" }
+
+        response = http.request(request)
+        result = JSON.parse(response.body)
+
+        if result["ok"]
+          FlowChat.logger.debug { "Telegram::Client: API request successful" }
+        else
+          FlowChat.logger.error { "Telegram::Client: API error - #{result["description"]}" }
+          report_api_error(
+            "Telegram API error: #{result["description"]}",
+            api_method: method,
+            error_code: result["error_code"],
+            error_description: result["description"],
+            chat_id: params[:chat_id]
+          )
+        end
+
+        result
+      rescue Net::OpenTimeout, Net::ReadTimeout => network_error
+        FlowChat.logger.error { "Telegram::Client: Network timeout: #{network_error.class.name}: #{network_error.message}" }
+        raise network_error
+      rescue => error
+        FlowChat.logger.error { "Telegram::Client: API request exception: #{error.class.name}: #{error.message}" }
+        report_api_error(
+          "Telegram API request exception: #{error.class.name}",
+          api_method: method,
+          error: error,
+          chat_id: params[:chat_id]
+        )
+        {"ok" => false, "description" => error.message}
+      end
+
+      def report_api_error(message, api_method: nil, error_code: nil, error_description: nil, error: nil, chat_id: nil)
+        FlowChat::Instrumentation.report_api_error(
+          message,
+          error: error,
+          platform: :telegram,
+          bot_id: @config.bot_id,
+          api_method: api_method,
+          error_code: error_code,
+          error_description: error_description,
+          chat_id: chat_id
+        )
+      end
+    end
+  end
+end

data/lib/flow_chat/telegram/configuration.rb

@@ -0,0 +1,118 @@
+module FlowChat
+  module Telegram
+    class Configuration
+      attr_accessor :bot_token, :secret_token, :name, :skip_signature_validation
+
+      @@configurations = {}
+
+      def initialize(name)
+        @name = name
+        @bot_token = nil
+        @secret_token = nil
+        @skip_signature_validation = false
+
+        FlowChat.logger.debug { "Telegram::Configuration: Initialized configuration with name: #{name || "anonymous"}" }
+
+        register_as(name) if name.present?
+      end
+
+      def self.from_credentials
+        FlowChat.logger.info { "Telegram::Configuration: Loading configuration from credentials/environment" }
+
+        config = new(nil)
+
+        if defined?(Rails) && Rails.respond_to?(:application) && Rails.application.credentials.telegram
+          FlowChat.logger.debug { "Telegram::Configuration: Loading from Rails credentials" }
+          credentials = Rails.application.credentials.telegram
+          config.bot_token = credentials[:bot_token]
+          config.secret_token = credentials[:secret_token]
+          config.skip_signature_validation = credentials[:skip_signature_validation] || false
+        else
+          FlowChat.logger.debug { "Telegram::Configuration: Loading from environment variables" }
+          config.bot_token = ENV["TELEGRAM_BOT_TOKEN"]
+          config.secret_token = ENV["TELEGRAM_SECRET_TOKEN"]
+          config.skip_signature_validation = ENV["TELEGRAM_SKIP_SIGNATURE_VALIDATION"] == "true"
+        end
+
+        if config.valid?
+          FlowChat.logger.info { "Telegram::Configuration: Configuration loaded successfully" }
+        else
+          FlowChat.logger.warn { "Telegram::Configuration: Incomplete configuration loaded - missing required fields" }
+        end
+
+        config
+      end
+
+      def self.register(name, config)
+        FlowChat.logger.debug { "Telegram::Configuration: Registering configuration '#{name}'" }
+        @@configurations[name.to_sym] = config
+      end
+
+      def self.get(name)
+        config = @@configurations[name.to_sym]
+        if config
+          FlowChat.logger.debug { "Telegram::Configuration: Retrieved configuration '#{name}'" }
+          config
+        else
+          FlowChat.logger.error { "Telegram::Configuration: Configuration '#{name}' not found" }
+          raise ArgumentError, "Telegram configuration '#{name}' not found"
+        end
+      end
+
+      def self.exists?(name)
+        exists = @@configurations.key?(name.to_sym)
+        FlowChat.logger.debug { "Telegram::Configuration: Configuration '#{name}' exists: #{exists}" }
+        exists
+      end
+
+      def self.configuration_names
+        names = @@configurations.keys
+        FlowChat.logger.debug { "Telegram::Configuration: Available configurations: #{names}" }
+        names
+      end
+
+      def self.clear_all!
+        FlowChat.logger.debug { "Telegram::Configuration: Clearing all registered configurations" }
+        @@configurations.clear
+      end
+
+      def register_as(name)
+        FlowChat.logger.debug { "Telegram::Configuration: Registering configuration as '#{name}'" }
+        @name = name.to_sym
+        self.class.register(@name, self)
+        self
+      end
+
+      def valid?
+        is_valid = !!(bot_token && !bot_token.to_s.empty?)
+        FlowChat.logger.debug { "Telegram::Configuration: Configuration valid: #{is_valid}" }
+        is_valid
+      end
+
+      def api_base_url
+        return nil unless bot_token
+        "https://api.telegram.org/bot#{bot_token}"
+      end
+
+      def bot_id
+        bot_token&.split(":")&.first
+      end
+
+      def send_message_url
+        "#{api_base_url}/sendMessage"
+      end
+
+      def set_webhook_url
+        "#{api_base_url}/setWebhook"
+      end
+
+      def get_webhook_info_url
+        "#{api_base_url}/getWebhookInfo"
+      end
+
+      def delete_webhook_url
+        "#{api_base_url}/deleteWebhook"
+      end
+    end
+  end
+end