mathpix 0.1.1 → 0.1.2

data/lib/mathpix/mcp/transports/http_streaming_transport.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'mcp'  # Load full SDK including VERSION constant
-require 'mcp/transport'  # Load Transport base class
+require 'mcp' # Load full SDK including VERSION constant
+require 'mcp/transport' # Load Transport base class
 require 'rack'
 require 'puma'
 require 'json'
-require 'ostruct'  # For creating error objects
+require 'ostruct' # For creating error objects
 require_relative '../middleware'
 
 module Mathpix
@@ -22,7 +22,7 @@ module Mathpix
           @host = host
           @puma_server = nil
           @connections = {}
-          @pending_requests = {}  # Store pending tool invocations by request_id
+          @pending_requests = {} # Store pending tool invocations by request_id
           @open = false
         end
 
@@ -37,11 +37,9 @@ module Mathpix
 
           # Run in background thread to avoid blocking
           @server_thread = Thread.new do
-            begin
-              @puma_server.run.join
-            rescue StandardError => e
-              # Server stopped
-            end
+            @puma_server.run.join
+          rescue StandardError
+            # Server stopped
           end
 
           sleep 0.2 # Give server time to start
@@ -49,17 +47,21 @@ module Mathpix
 
         # Override MCP::Transport#close
         def close
-          return unless @open  # Don't close twice
+          return unless @open # Don't close twice
 
           @open = false
 
           # Signal all SSE handlers to stop and close streams
-          @connections.each do |session_id, conn|
+          @connections.each_value do |conn|
             handler = conn[:handler]
             next unless handler
 
             handler.stop_flag = true
-            handler.close rescue nil
+            begin
+              handler.close
+            rescue StandardError
+              nil
+            end
           end
 
           # Wait for handlers to finish (but not too long in tests)
@@ -72,7 +74,7 @@ module Mathpix
           # Stop Puma server aggressively
           if @puma_server
             begin
-              @puma_server.stop(true)  # Force immediate stop
+              @puma_server.stop(true) # Force immediate stop
             rescue StandardError
               # Ignore errors
             end
@@ -81,7 +83,11 @@ module Mathpix
           # Kill server thread immediately in tests
           if @server_thread&.alive?
             @server_thread.kill
-            @server_thread.join(0.1) rescue nil
+            begin
+              @server_thread.join(0.1)
+            rescue StandardError
+              nil
+            end
           end
 
           @puma_server = nil
@@ -102,9 +108,9 @@ module Mathpix
         end
 
         def unregister_connection(session_id)
-          $stderr.puts "[TRANSPORT] Unregistering connection: #{session_id}, current count: #{@connections.size}"
+          warn "[TRANSPORT] Unregistering connection: #{session_id}, current count: #{@connections.size}"
           @connections.delete(session_id)
-          $stderr.puts "[TRANSPORT] After unregister, count: #{@connections.size}"
+          warn "[TRANSPORT] After unregister, count: #{@connections.size}"
         end
 
         private
@@ -116,8 +122,8 @@ module Mathpix
             # CORS middleware
             use Mathpix::MCP::Middleware::CorsMiddleware,
                 allowed_origins: ['*'],
-                allowed_methods: ['GET', 'POST'],
-                allowed_headers: ['Authorization', 'Content-Type']
+                allowed_methods: %w[GET POST],
+                allowed_headers: %w[Authorization Content-Type]
 
             # Rate limiting middleware
             use Mathpix::MCP::Middleware::RateLimitingMiddleware,
@@ -179,35 +185,39 @@ module Mathpix
           handler.handle
         end
 
-        def handle_health_check(env)
+        def handle_health_check(_env)
           [
             200,
             { 'Content-Type' => 'application/json' },
             [JSON.generate({
-              status: 'healthy',
-              version: ::MCP::VERSION,
-              transport: 'http_sse',
-              active_connections: active_connections,
-              dependencies: {
-                mathpix_api: 'healthy',
-                database: 'healthy'
-              }
-            })]
+                             status: 'healthy',
+                             version: ::MCP::VERSION,
+                             transport: 'http_sse',
+                             active_connections: active_connections,
+                             dependencies: {
+                               mathpix_api: 'healthy',
+                               database: 'healthy'
+                             }
+                           })]
           ]
         end
 
         def handle_close_connection(env)
           # Explicit connection close endpoint for graceful disconnect
           request_body = env['rack.input'].read
-          params = JSON.parse(request_body) rescue {}
+          params = begin
+            JSON.parse(request_body)
+          rescue StandardError
+            {}
+          end
           session_id = params['session_id']
 
-          $stderr.puts "[TRANSPORT] Close connection request for session: #{session_id}"
+          warn "[TRANSPORT] Close connection request for session: #{session_id}"
 
           if session_id && @connections[session_id]
             handler = @connections[session_id][:handler]
             if handler
-              $stderr.puts "[TRANSPORT] Setting stop_flag for session: #{session_id}"
+              warn "[TRANSPORT] Setting stop_flag for session: #{session_id}"
               handler.stop_flag = true
               # Give handler a moment to detect the flag and cleanup
               sleep 0.05
@@ -217,30 +227,30 @@ module Mathpix
               200,
               { 'Content-Type' => 'application/json' },
               [JSON.generate({
-                status: 'closed',
-                session_id: session_id
-              })]
+                               status: 'closed',
+                               session_id: session_id
+                             })]
             ]
           else
-            $stderr.puts "[TRANSPORT] Session not found: #{session_id}"
+            warn "[TRANSPORT] Session not found: #{session_id}"
             [
               404,
               { 'Content-Type' => 'application/json' },
               [JSON.generate({
-                error: 'session_not_found',
-                session_id: session_id
-              })]
+                               error: 'session_not_found',
+                               session_id: session_id
+                             })]
             ]
           end
         rescue StandardError => e
-          $stderr.puts "[TRANSPORT] Error in handle_close_connection: #{e.message}"
+          warn "[TRANSPORT] Error in handle_close_connection: #{e.message}"
           [
             500,
             { 'Content-Type' => 'application/json' },
             [JSON.generate({
-              error: 'internal_error',
-              message: e.message
-            })]
+                             error: 'internal_error',
+                             message: e.message
+                           })]
           ]
         end
 
@@ -257,33 +267,35 @@ module Mathpix
         # New handler methods for complete MCP server
 
         def handle_tool_invocation(env, path)
-          $stderr.puts "[TRANSPORT] Handling tool invocation: #{path}"
+          warn "[TRANSPORT] Handling tool invocation: #{path}"
           # Read request body
           request_body = env['rack.input'].read
-          $stderr.puts "[TRANSPORT] Request body: #{request_body[0..200]}"
+          warn "[TRANSPORT] Request body: #{request_body[0..200]}"
 
           # ✅ USE OFFICIAL SDK: Delegate to MCP::Server.handle_json
           # This handles JSON-RPC 2.0 protocol, tool routing, error formatting
           response_json = @server.handle_json(request_body)
-          $stderr.puts "[TRANSPORT] SDK response: #{response_json[0..200]}"
+          warn "[TRANSPORT] SDK response: #{response_json[0..200]}"
 
           # Parse response to extract request_id for SSE broadcasting
           response = JSON.parse(response_json)
           request_id = response['id']
-          $stderr.puts "[TRANSPORT] Response ID: #{request_id}, has error: #{response.key?('error')}"
+          warn "[TRANSPORT] Response ID: #{request_id}, has error: #{response.key?('error')}"
 
           # Store pending request for tracking
-          @pending_requests[request_id] = {
-            payload: JSON.parse(request_body),
-            received_at: Time.now
-          } if request_id
+          if request_id
+            @pending_requests[request_id] = {
+              payload: JSON.parse(request_body),
+              received_at: Time.now
+            }
+          end
 
           # Broadcast result via SSE to connected clients
           if response['error']
-            $stderr.puts "[TRANSPORT] Broadcasting tool_error"
+            warn '[TRANSPORT] Broadcasting tool_error'
             broadcast_to_connections(response_json, event_type: 'tool_error', request_id: request_id)
           else
-            $stderr.puts "[TRANSPORT] Broadcasting tool_result"
+            warn '[TRANSPORT] Broadcasting tool_result'
             broadcast_to_connections(response_json, event_type: 'tool_result', request_id: request_id)
           end
 
@@ -298,7 +310,7 @@ module Mathpix
           ]
         rescue StandardError => e
           # Return error response
-          $stderr.puts "[TRANSPORT] Error in handle_tool_invocation: #{e.message}\n#{e.backtrace.first(5).join("\n")}"
+          warn "[TRANSPORT] Error in handle_tool_invocation: #{e.message}\n#{e.backtrace.first(5).join("\n")}"
           [
             500,
             { 'Content-Type' => 'application/json' },
@@ -306,24 +318,24 @@ module Mathpix
           ]
         end
 
-        def handle_server_info(env)
+        def handle_server_info(_env)
           [
             200,
             { 'Content-Type' => 'application/json' },
             [JSON.generate({
-              name: 'mathpix',
-              version: '1.0.0',
-              transport: 'http_sse',
-              capabilities: {
-                tools: true,
-                resources: true,
-                prompts: false
-              }
-            })]
+                             name: 'mathpix',
+                             version: '1.0.0',
+                             transport: 'http_sse',
+                             capabilities: {
+                               tools: true,
+                               resources: true,
+                               prompts: false
+                             }
+                           })]
           ]
         end
 
-        def handle_tool_discovery(env)
+        def handle_tool_discovery(_env)
           tools = [
             {
               name: 'convert_image',
@@ -426,7 +438,7 @@ module Mathpix
           ]
         end
 
-        def handle_resource_discovery(env)
+        def handle_resource_discovery(_env)
           resources = [
             {
               uri: 'mathpix://snip/recent',
@@ -457,7 +469,7 @@ module Mathpix
 
         def handle_resource_request(env, path)
           # Parse resource path
-          parts = path.split('/').drop(3)  # Drop '', 'mcp', 'resources'
+          parts = path.split('/').drop(3) # Drop '', 'mcp', 'resources'
 
           if parts[0] == 'mathpix' && parts[1] == 'snip'
             if parts[2] == 'recent'
@@ -467,11 +479,11 @@ module Mathpix
                   200,
                   { 'Content-Type' => 'application/json' },
                   [JSON.generate({
-                    id: parts[3],
-                    latex: '\\int_0^\\infty e^{-x^2} dx',
-                    confidence: 0.95,
-                    created_at: Time.now.iso8601
-                  })]
+                                   id: parts[3],
+                                   latex: '\\int_0^\\infty e^{-x^2} dx',
+                                   confidence: 0.95,
+                                   created_at: Time.now.iso8601
+                                 })]
                 ]
               else
                 # Recent snips list
@@ -491,13 +503,13 @@ module Mathpix
                   200,
                   { 'Content-Type' => 'application/json' },
                   [JSON.generate({
-                    data: snips,
-                    pagination: {
-                      offset: offset,
-                      limit: limit,
-                      total: 100
-                    }
-                  })]
+                                   data: snips,
+                                   pagination: {
+                                     offset: offset,
+                                     limit: limit,
+                                     total: 100
+                                   }
+                                 })]
                 ]
               end
             else
@@ -508,27 +520,27 @@ module Mathpix
           end
         end
 
-        def handle_metrics(env)
+        def handle_metrics(_env)
           # Mock metrics - would track real metrics in production
           [
             200,
             { 'Content-Type' => 'application/json' },
             [JSON.generate({
-              requests_total: 1234,
-              errors_total: 5,
-              response_time_p50: 120.5,
-              response_time_p95: 450.2,
-              response_time_p99: 892.1,
-              active_connections: active_connections,
-              dependencies: {
-                mathpix_api: 'healthy',
-                database: 'healthy'
-              }
-            })]
+                             requests_total: 1234,
+                             errors_total: 5,
+                             response_time_p50: 120.5,
+                             response_time_p95: 450.2,
+                             response_time_p99: 892.1,
+                             active_connections: active_connections,
+                             dependencies: {
+                               mathpix_api: 'healthy',
+                               database: 'healthy'
+                             }
+                           })]
           ]
         end
 
-        def handle_options(env)
+        def handle_options(_env)
           [
             200,
             {
@@ -565,7 +577,7 @@ module Mathpix
                 enhanced['result'] = tool_response
               rescue JSON::ParserError
                 # If parsing fails, keep original structure
-                $stderr.puts "[TRANSPORT] Warning: Could not parse tool response text"
+                warn '[TRANSPORT] Warning: Could not parse tool response text'
               end
             end
           end
@@ -580,41 +592,40 @@ module Mathpix
           if request_id && @pending_requests[request_id]
             return @pending_requests[request_id][:payload]['params']['name']
           end
+
           nil
         end
 
         def broadcast_to_connections(message, event_type: 'response', request_id: nil)
-          $stderr.puts "[TRANSPORT] Broadcasting to #{@connections.size} connections, event_type: #{event_type}"
-          data = JSON.parse(message)  # Returns string keys
+          warn "[TRANSPORT] Broadcasting to #{@connections.size} connections, event_type: #{event_type}"
+          data = JSON.parse(message) # Returns string keys
           data['request_id'] = request_id if request_id
 
           @connections.each do |session_id, conn|
-            begin
-              handler = conn[:handler]
-              $stderr.puts "[TRANSPORT] Sending to handler #{session_id}"
-
-              # Use SDK handler public methods (no instance_eval needed!)
-              case event_type
-              when 'tool_error'
-                # JSON.parse returns string keys, not symbols
-                error_data = data['error'] || {}
-                error = OpenStruct.new(message: error_data['message'] || error_data['data'] || 'Unknown error')
-                handler.send_tool_error_event(request_id, error)
-              when 'tool_result'
-                $stderr.puts "[TRANSPORT] Calling send_custom_event on handler"
-                # Extract tool result from nested structure
-                enhanced_data = extract_tool_result_data(data)
-                handler.send_custom_event('tool_result', enhanced_data)
-              else
-                handler.send_custom_event(event_type, data)
-              end
-            rescue StandardError => e
-              # Connection might be closed
-              $stderr.puts "[TRANSPORT] Error broadcasting to #{session_id}: #{e.message}\n#{e.backtrace.first(3).join("\n")}"
-              unregister_connection(session_id)
+            handler = conn[:handler]
+            warn "[TRANSPORT] Sending to handler #{session_id}"
+
+            # Use SDK handler public methods (no instance_eval needed!)
+            case event_type
+            when 'tool_error'
+              # JSON.parse returns string keys, not symbols
+              error_data = data['error'] || {}
+              error = OpenStruct.new(message: error_data['message'] || error_data['data'] || 'Unknown error')
+              handler.send_tool_error_event(request_id, error)
+            when 'tool_result'
+              warn '[TRANSPORT] Calling send_custom_event on handler'
+              # Extract tool result from nested structure
+              enhanced_data = extract_tool_result_data(data)
+              handler.send_custom_event('tool_result', enhanced_data)
+            else
+              handler.send_custom_event(event_type, data)
             end
+          rescue StandardError => e
+            # Connection might be closed
+            warn "[TRANSPORT] Error broadcasting to #{session_id}: #{e.message}\n#{e.backtrace.first(3).join("\n")}"
+            unregister_connection(session_id)
           end
-          $stderr.puts "[TRANSPORT] Broadcast complete"
+          warn '[TRANSPORT] Broadcast complete'
         end
       end
     end

data/lib/mathpix/mcp/transports/sse_stream_handler.rb

@@ -2,7 +2,6 @@
 
 require 'securerandom'
 require 'json'
-require 'thread'  # For Queue
 
 module Mathpix
   module MCP
@@ -21,14 +20,14 @@ module Mathpix
 
         def initialize(mcp_server, env, test_mode: false, transport: nil)
           @mcp_server = mcp_server
-          @transport = transport  # Transport for connection tracking
+          @transport = transport # Transport for connection tracking
           @session_id = extract_session_id(env)
           @event_id = 0
           @last_activity = Time.now
           @heartbeat_thread = nil
           @test_mode = test_mode
           @stop_flag = false
-          @event_queue = Queue.new  # Thread-safe event queue
+          @event_queue = Queue.new # Thread-safe event queue
         end
 
         def handle
@@ -40,7 +39,7 @@ module Mathpix
           }
 
           stream = proc do |out|
-            @stream = out  # Store stream for external access
+            @stream = out # Store stream for external access
             @closed = false
             register_connection
 
@@ -55,39 +54,39 @@ module Mathpix
               timeout = @test_mode ? TEST_TIMEOUT : TIMEOUT
               check_interval = @test_mode ? TEST_EVENT_LOOP_CHECK_INTERVAL : EVENT_LOOP_CHECK_INTERVAL
               start_time = Time.now
-              $stderr.puts "[SSE] Event loop started (timeout: #{timeout}s, check_interval: #{check_interval * 1000}ms)"
+              warn "[SSE] Event loop started (timeout: #{timeout}s, check_interval: #{check_interval * 1000}ms)"
 
               loop do
                 # Check for timeout
                 if Time.now - start_time > timeout
-                  $stderr.puts "[SSE] Timeout reached, sending timeout event"
+                  warn '[SSE] Timeout reached, sending timeout event'
                   send_event(out, 'timeout', {
-                    message: 'Connection timed out due to inactivity'
-                  })
+                               message: 'Connection timed out due to inactivity'
+                             })
                   break
                 end
 
                 # Check for stop signal
                 if @stop_flag
-                  $stderr.puts "[SSE] Stop flag set, exiting loop"
+                  warn '[SSE] Stop flag set, exiting loop'
                   break
                 end
 
                 # Process queued events (non-blocking with short timeout)
                 begin
-                  event = @event_queue.pop(true)  # non_block = true
-                  $stderr.puts "[SSE] Sending queued event: #{event[:type]}"
+                  event = @event_queue.pop(true) # non_block = true
+                  warn "[SSE] Sending queued event: #{event[:type]}"
                   send_event(out, event[:type], event[:data])
                 rescue ThreadError
                   # Queue empty - that's ok, sleep briefly and check again
                   sleep check_interval
                 end
               end
-              $stderr.puts "[SSE] Event loop exited"
-            rescue IOError, Errno::EPIPE, Errno::ECONNRESET => e
+              warn '[SSE] Event loop exited'
+            rescue IOError, Errno::EPIPE, Errno::ECONNRESET
               # Connection closed by client - exit cleanly
               @closed = true
-            rescue StandardError => e
+            rescue StandardError
               # Unexpected error - log and exit
               @closed = true
             ensure
@@ -135,18 +134,22 @@ module Mathpix
         def send_custom_event(event_type, data)
           return if @closed
 
-          $stderr.puts "[SSE] Queueing event: #{event_type}"
+          warn "[SSE] Queueing event: #{event_type}"
           @event_queue << {
             type: event_type,
             data: data
           }
-          $stderr.puts "[SSE] Event queued, queue size: #{@event_queue.size}"
+          warn "[SSE] Event queued, queue size: #{@event_queue.size}"
         end
 
         def close
           @closed = true
           @stop_flag = true
-          @stream&.close rescue nil
+          begin
+            @stream&.close
+          rescue StandardError
+            nil
+          end
         end
 
         private
@@ -156,7 +159,7 @@ module Mathpix
         end
 
         def send_event(stream, event_type, data)
-          return if @closed  # Don't send if already closed
+          return if @closed # Don't send if already closed
 
           @event_id += 1
 
@@ -169,23 +172,22 @@ module Mathpix
         rescue IOError, Errno::EPIPE, Errno::ECONNRESET
           # Connection closed by client
           @closed = true
-          nil  # Return nil instead of raising
+          nil # Return nil instead of raising
         end
 
         def send_connection_event(stream)
           send_event(stream, 'connection', {
-            session_id: session_id,
-            transport: 'http_sse'
-          })
+                       session_id: session_id,
+                       transport: 'http_sse'
+                     })
         end
 
         def send_heartbeat(stream)
           send_event(stream, 'heartbeat', {
-            timestamp: Time.now.iso8601
-          })
+                       timestamp: Time.now.iso8601
+                     })
         end
 
-
         def start_heartbeat(stream)
           interval = @test_mode ? TEST_HEARTBEAT_INTERVAL : HEARTBEAT_INTERVAL
           @heartbeat_thread = Thread.new do
@@ -195,11 +197,11 @@ module Mathpix
             end
           rescue IOError, Errno::EPIPE, Errno::ECONNRESET => e
             # Client disconnected - signal main event loop to exit
-            $stderr.puts "[HEARTBEAT] Client disconnect detected: #{e.class}"
+            warn "[HEARTBEAT] Client disconnect detected: #{e.class}"
             @stop_flag = true
           rescue StandardError => e
             # Unexpected error - signal main loop to exit
-            $stderr.puts "[HEARTBEAT] Unexpected error: #{e.class}: #{e.message}"
+            warn "[HEARTBEAT] Unexpected error: #{e.class}: #{e.message}"
             @stop_flag = true
           end
         end
@@ -215,20 +217,20 @@ module Mathpix
 
         def unregister_connection
           # Remove connection from transport's connection tracking
-          $stderr.puts "[SSE] Unregistering connection: #{@session_id}, transport present: #{!@transport.nil?}"
+          warn "[SSE] Unregistering connection: #{@session_id}, transport present: #{!@transport.nil?}"
           if @transport
-            $stderr.puts "[SSE] About to call transport.unregister_connection"
+            warn '[SSE] About to call transport.unregister_connection'
             begin
               @transport.unregister_connection(@session_id)
-              $stderr.puts "[SSE] Called transport.unregister_connection"
-            rescue => e
-              $stderr.puts "[SSE] ERROR calling unregister: #{e.class}: #{e.message}"
-              $stderr.puts "[SSE] Backtrace: #{e.backtrace.first(3).join('\n')}"
+              warn '[SSE] Called transport.unregister_connection'
+            rescue StandardError => e
+              warn "[SSE] ERROR calling unregister: #{e.class}: #{e.message}"
+              warn "[SSE] Backtrace: #{e.backtrace.first(3).join('\n')}"
             end
           else
-            $stderr.puts "[SSE] WARNING: No transport to unregister from!"
+            warn '[SSE] WARNING: No transport to unregister from!'
           end
-          $stderr.puts "[SSE] Unregistration complete"
+          warn '[SSE] Unregistration complete'
         end
       end
     end