capydash 0.1.0

data/lib/capydash/dashboard_server.rb

@@ -0,0 +1,175 @@
+require 'eventmachine'
+require 'em-websocket'
+
+module CapyDash
+  class DashboardServer
+    attr_reader :port, :clients
+
+    # Provide a single shared instance for the whole process
+    def self.instance(port: nil)
+      configured_port = port || CapyDash.config.server_port
+      @instance ||= new(port: configured_port)
+    end
+
+    def initialize(port: nil)
+      @port = port || CapyDash.config.server_port
+      @clients = []
+      @history = [] # recent events to replay on reconnect
+      @history_limit = CapyDash.config.message_history_limit
+      @max_connections = CapyDash.config.max_connections
+    end
+
+    # Start the WebSocket server in a background thread
+    def start
+      return if defined?(@started) && @started
+      @started = true
+      Thread.new do
+        EM.run do
+          EM::WebSocket.run(host: "0.0.0.0", port: @port) do |ws|
+
+            ws.onopen do
+              begin
+                # Check connection limit
+                if @clients.length >= @max_connections
+                  CapyDash::Logger.warn("Connection limit reached", {
+                    current_connections: @clients.length,
+                    max_connections: @max_connections
+                  })
+                  ws.close
+                  return
+                end
+
+                @clients << ws
+                CapyDash::Logger.info("Client connected", {
+                  total_clients: @clients.length,
+                  client_id: ws.object_id
+                })
+                puts "Client connected"
+
+                # Replay recent history so refreshed clients see last events
+                @history.each do |msg|
+                  begin
+                    ws.send(msg)
+                  rescue => e
+                    CapyDash::ErrorHandler.handle_websocket_error(e, ws)
+                  end
+                end
+              rescue => e
+                CapyDash::ErrorHandler.handle_websocket_error(e, ws)
+              end
+            end
+
+            ws.onclose do
+              begin
+                @clients.delete(ws)
+                CapyDash::Logger.info("Client disconnected", {
+                  remaining_clients: @clients.length,
+                  client_id: ws.object_id
+                })
+                puts "Client disconnected"
+              rescue => e
+                CapyDash::ErrorHandler.handle_websocket_error(e, ws)
+              end
+            end
+
+            ws.onmessage do |msg|
+              begin
+                CapyDash::Logger.debug("Received WebSocket message", {
+                  message_length: msg.length,
+                  client_id: ws.object_id
+                })
+                puts "Received message: #{msg}"
+
+                data = JSON.parse(msg) rescue nil
+                if data && data["command"] == "run_tests"
+                  args = data["args"] || ["bundle", "exec", "rails", "test", "test/system"]
+                  CapyDash::Logger.info("Executing test command", {
+                    command: args.join(' '),
+                    client_id: ws.object_id
+                  })
+                  puts "[CapyDash] Running command: #{args.join(' ')}"
+
+                  Thread.new do
+                    begin
+                      # Change to the dummy app directory and run tests there
+                      current_dir = File.dirname(__FILE__)
+                      gem_root = File.expand_path(File.join(current_dir, "..", ".."))
+                      dummy_app_path = File.join(gem_root, "spec", "dummy_app")
+
+                      CapyDash::Logger.info("Running tests in directory", {
+                        directory: dummy_app_path,
+                        exists: Dir.exist?(dummy_app_path)
+                      })
+                      puts "[CapyDash] Running tests in: #{dummy_app_path}"
+                      puts "[CapyDash] Directory exists: #{Dir.exist?(dummy_app_path)}"
+
+                      Dir.chdir(dummy_app_path) do
+                        # Set Rails environment and ensure CapyDash is loaded
+                        ENV["RAILS_ENV"] = "test"
+                        ENV["CAPYDASH_EXTERNAL_WS"] = "1"  # Use external WebSocket mode
+
+                        puts "[CapyDash] Current directory: #{Dir.pwd}"
+                        puts "[CapyDash] Running: #{args.join(' ')}"
+
+                        # Run the command and capture both stdout and stderr
+                        IO.popen(args, err: [:child, :out]) do |io|
+                          io.each_line do |line|
+                            puts "[CapyDash] Test output: #{line.strip}"
+                            event = { type: "runner", line: line.strip, status: "running", ts: Time.now.to_i }
+                            broadcast(event.to_json)
+                          end
+                        end
+                      end
+                    rescue => e
+                      CapyDash::ErrorHandler.handle_test_execution_error(e, args.join(' '))
+                      broadcast({ type: "runner", line: "Error: #{e.message}", status: "failed", ts: Time.now.to_i }.to_json)
+                    end
+                    broadcast({ type: "runner", line: "Finished", status: "passed", ts: Time.now.to_i }.to_json)
+                  end
+                else
+                  # Optionally broadcast to all clients
+                  broadcast(msg)
+                end
+              rescue => e
+                CapyDash::ErrorHandler.handle_websocket_error(e, ws)
+                warn "[CapyDash] ws.onmessage error: #{e.message}"
+                puts "[CapyDash] Backtrace: #{e.backtrace.first(5).join("\n")}"
+              end
+            end
+
+          end
+        end
+      end
+    end
+
+    # Send a message to all connected clients
+    def broadcast(message)
+      begin
+        # store in history buffer
+        @history << message
+        @history.shift if @history.length > @history_limit
+
+        # fan out to all connected clients
+        @clients.each do |client|
+          begin
+            client.send(message)
+          rescue => e
+            CapyDash::ErrorHandler.handle_websocket_error(e, client)
+            # Remove dead connections
+            @clients.delete(client)
+          end
+        end
+      rescue => e
+        CapyDash::ErrorHandler.handle_error(e, {
+          error_type: 'broadcast',
+          message_length: message&.length
+        })
+      end
+    end
+
+    # Stop the WebSocket server gracefully
+    def stop
+      EM.stop_event_loop if EM.reactor_running?
+    end
+  end
+end

data/lib/capydash/engine.rb

@@ -0,0 +1,54 @@
+module CapyDash
+  class Engine < ::Rails::Engine
+    isolate_namespace CapyDash
+
+    rake_tasks do
+      load File.expand_path("../tasks/capydash.rake", __dir__)
+    end
+
+    initializer "capydash.configuration", before: :load_config_initializers do
+      # Load configuration
+      CapyDash.config = CapyDash::Configuration.load_from_file
+      CapyDash::Logger.setup(CapyDash.config)
+
+      CapyDash::Logger.info("CapyDash configuration loaded", {
+        server_port: CapyDash.config.server_port,
+        log_level: CapyDash.config.log_level,
+        auth_enabled: CapyDash.config.auth_enabled?
+      })
+    end
+
+    initializer "capydash.instrumentation", after: :load_config_initializers do
+      begin
+        # Hook into Capybara sessions automatically
+        ActiveSupport.on_load(:action_dispatch_integration_test) do
+          Capybara::Session.include(CapyDash::Instrumentation)
+        end
+
+        # Start WebSocket server automatically in dev/test unless using external WS
+        if (Rails.env.development? || Rails.env.test?) && ENV["CAPYDASH_EXTERNAL_WS"] != "1"
+          port = CapyDash.config.server_port
+          CapyDash::DashboardServer.instance(port: port).start
+
+          CapyDash::Logger.info("WebSocket server started", {
+            port: port,
+            environment: Rails.env
+          })
+          puts "[CapyDash] WebSocket server started on ws://localhost:#{port}"
+        else
+          CapyDash::Logger.info("Skipping in-process WebSocket server", {
+            reason: ENV["CAPYDASH_EXTERNAL_WS"] == "1" ? "external_mode" : "production_environment",
+            environment: Rails.env
+          })
+          puts "[CapyDash] Skipping in-process WebSocket server (external mode)" if ENV["CAPYDASH_EXTERNAL_WS"] == "1"
+        end
+      rescue => e
+        CapyDash::ErrorHandler.handle_error(e, {
+          error_type: 'initialization',
+          component: 'engine'
+        })
+        raise
+      end
+    end
+  end
+end

data/lib/capydash/error_handler.rb

@@ -0,0 +1,101 @@
+module CapyDash
+  class ErrorHandler
+    class << self
+      def handle_error(error, context = {})
+        log_error(error, context)
+        notify_error(error, context) if should_notify?(error)
+        recover_from_error(error, context)
+      end
+
+      def handle_websocket_error(error, connection = nil)
+        context = {
+          error_type: 'websocket',
+          connection_id: connection&.id,
+          error_class: error.class.name
+        }
+        handle_error(error, context)
+      end
+
+      def handle_test_execution_error(error, test_path = nil)
+        context = {
+          error_type: 'test_execution',
+          test_path: test_path,
+          error_class: error.class.name
+        }
+        handle_error(error, context)
+      end
+
+      def handle_instrumentation_error(error, method_name = nil)
+        context = {
+          error_type: 'instrumentation',
+          method_name: method_name,
+          error_class: error.class.name
+        }
+        handle_error(error, context)
+      end
+
+      private
+
+      def log_error(error, context)
+        Logger.error(
+          "Error occurred: #{error.message}",
+          context.merge(
+            backtrace: error.backtrace&.first(5),
+            error_class: error.class.name
+          )
+        )
+      end
+
+      def notify_error(error, context)
+        # In a production app, this would send notifications to monitoring services
+        # like Sentry, Bugsnag, or custom webhooks
+        puts "🚨 CRITICAL ERROR: #{error.message}"
+        puts "Context: #{context}"
+      end
+
+      def should_notify?(error)
+        # Only notify for critical errors
+        error.is_a?(StandardError) &&
+        !error.is_a?(ArgumentError) &&
+        !error.is_a?(NoMethodError)
+      end
+
+      def recover_from_error(error, context)
+        case context[:error_type]
+        when 'websocket'
+          recover_websocket_connection
+        when 'test_execution'
+          recover_test_execution
+        when 'instrumentation'
+          recover_instrumentation
+        else
+          # Generic recovery
+          Logger.warn("No specific recovery strategy for error type: #{context[:error_type]}")
+        end
+      end
+
+      def recover_websocket_connection
+        Logger.info("Attempting to recover WebSocket connection")
+        # In a real implementation, this would attempt to reconnect
+        # or notify the dashboard to refresh the connection
+      end
+
+      def recover_test_execution
+        Logger.info("Test execution error recovered")
+        # Could implement retry logic or cleanup
+      end
+
+      def recover_instrumentation
+        Logger.info("Instrumentation error recovered")
+        # Could disable problematic instrumentation or use fallbacks
+      end
+    end
+  end
+
+  # Custom error classes for better error handling
+  class CapyDashError < StandardError; end
+  class ConfigurationError < CapyDashError; end
+  class WebSocketError < CapyDashError; end
+  class TestExecutionError < CapyDashError; end
+  class InstrumentationError < CapyDashError; end
+end

data/lib/capydash/event_emitter.rb

@@ -0,0 +1,29 @@
+require 'capydash/dashboard_server'
+require 'capydash/forwarder'
+
+module CapyDash
+  module EventEmitter
+    @clients = []
+
+    class << self
+      attr_accessor :clients
+
+      def subscribe(&block)
+        @on_event = block
+      end
+
+      def broadcast(event)
+        @on_event&.call(event)
+
+        port = CapyDash.configuration&.port
+        if ENV["CAPYDASH_EXTERNAL_WS"] == "1"
+          forwarder = CapyDash::Forwarder.instance(port: port)
+          forwarder.send_message(event)
+        else
+          server = CapyDash::DashboardServer.instance(port: port)
+          server.broadcast(event.to_json)
+        end
+      end
+    end
+  end
+end

data/lib/capydash/forwarder.rb

@@ -0,0 +1,84 @@
+require 'eventmachine'
+require 'faye/websocket'
+require 'json'
+
+module CapyDash
+  # Forwards events to an external WebSocket server when CAPYDASH_EXTERNAL_WS=1
+  class Forwarder
+    attr_reader :port
+
+    def self.instance(port: nil)
+      configured_port = port || (CapyDash.respond_to?(:configuration) ? CapyDash.configuration&.port : nil)
+      @instance ||= new(port: configured_port || 4000)
+    end
+
+    def initialize(port: 4000)
+      @port = port
+      @connected = false
+      @queue = []
+      @ws = nil
+      @mutex = Mutex.new
+      start
+    end
+
+    def start
+      return if @started
+      @started = true
+
+      Thread.new do
+        EM.run do
+          connect
+        end
+      end
+    end
+
+    def connect
+      url = "ws://127.0.0.1:#{@port}"
+      puts "[CapyDash Forwarder] Attempting to connect to #{url}"
+      @ws = Faye::WebSocket::Client.new(url)
+
+      @ws.on(:open) do |_event|
+        @connected = true
+        puts "[CapyDash Forwarder] Connected to WebSocket server"
+        flush_queue
+      end
+
+      @ws.on(:close) do |_event|
+        @connected = false
+        puts "[CapyDash Forwarder] Disconnected from WebSocket server"
+        # attempt reconnect after short delay
+        EM.add_timer(0.5) { connect }
+      end
+
+      @ws.on(:error) do |event|
+        puts "[CapyDash Forwarder] WebSocket error: #{event.inspect}"
+        # keep trying; errors are expected if server not yet up
+      end
+    end
+
+    def send_message(raw_message)
+      message = raw_message.is_a?(String) ? raw_message : JSON.dump(raw_message)
+      puts "[CapyDash Forwarder] Sending message: #{message[0..100]}..."
+      @mutex.synchronize do
+        if @connected && @ws
+          @ws.send(message)
+        else
+          @queue << message
+          puts "[CapyDash Forwarder] Queued message (not connected)"
+        end
+      end
+    end
+
+    private
+
+    def flush_queue
+      return unless @connected && @ws
+      pending = nil
+      @mutex.synchronize do
+        pending = @queue.dup
+        @queue.clear
+      end
+      pending.each { |m| @ws.send(m) }
+    end
+  end
+end

data/lib/capydash/instrumentation.rb

@@ -0,0 +1,99 @@
+require 'capybara'
+require 'capydash/dashboard_server'
+require 'base64'
+require 'fileutils'
+
+puts "[CapyDash] Instrumentation file loaded"
+
+module CapyDash
+  module Instrumentation
+    def visit(path)
+      emit_step("visit", path) { super(path) }
+    end
+
+    def click_button(*args)
+      emit_step("click_button", args.first) { super(*args) }
+    end
+
+    def fill_in(locator, with:)
+      emit_step("fill_in", "#{locator} => #{with}") { super(locator, with: with) }
+    end
+
+    private
+
+    def emit_step(step_name, detail)
+      # take screenshot
+      base_dir = if CapyDash.respond_to?(:configuration)
+        CapyDash.configuration&.screenshot_path || "tmp/capydash_screenshots"
+      else
+        "tmp/capydash_screenshots"
+      end
+      FileUtils.mkdir_p(base_dir) unless Dir.exist?(base_dir)
+      timestamp = Time.now.strftime('%Y%m%d-%H%M%S-%L')
+      safe_step = step_name.gsub(/\s+/, '_')
+      screenshot_path = File.join(base_dir, "#{safe_step}-#{timestamp}.png")
+
+      data_url = nil
+      if defined?(Capybara)
+        begin
+          current_driver = Capybara.current_driver
+          puts "[CapyDash] Current Capybara driver: #{current_driver}"
+          if current_driver == :rack_test
+            puts "[CapyDash] Skipping screenshot (rack_test driver)"
+          else
+            if respond_to?(:page)
+              page.save_screenshot(screenshot_path)
+            else
+              Capybara.current_session.save_screenshot(screenshot_path)
+            end
+            puts "[CapyDash] Saved screenshot: #{screenshot_path}"
+            if File.exist?(screenshot_path)
+              encoded = Base64.strict_encode64(File.binread(screenshot_path))
+              data_url = "data:image/png;base64,#{encoded}"
+            end
+          end
+        rescue => e
+          warn "[CapyDash] Screenshot capture failed: #{e.message}"
+        end
+      end
+
+      # emit event
+      CapyDash::EventEmitter.broadcast(
+        step_name: step_name,
+        detail: detail,
+        screenshot: screenshot_path,
+        data_url: data_url,
+        test_name: (defined?(CapyDash) ? CapyDash.current_test : nil),
+        status: "running"
+      )
+
+      # run the original step
+      yield
+
+      # mark success
+      CapyDash::EventEmitter.broadcast(
+        step_name: step_name,
+        detail: detail,
+        screenshot: screenshot_path,
+        data_url: data_url,
+        test_name: (defined?(CapyDash) ? CapyDash.current_test : nil),
+        status: "passed"
+      )
+    rescue => e
+      CapyDash::EventEmitter.broadcast(
+        step_name: step_name,
+        detail: detail,
+        screenshot: screenshot_path,
+        data_url: data_url,
+        test_name: (defined?(CapyDash) ? CapyDash.current_test : nil),
+        status: "failed",
+        error: e.message
+      )
+      raise e
+    end
+  end
+end
+
+# Prepend into Capybara DSL so it wraps all calls
+Capybara::Session.prepend(CapyDash::Instrumentation)
+puts "[CapyDash] Instrumentation prepended into Capybara::Session"

data/lib/capydash/logger.rb

@@ -0,0 +1,99 @@
+require 'logger'
+require 'fileutils'
+
+module CapyDash
+  class Logger
+    class << self
+      attr_accessor :instance
+    end
+
+    def initialize(config = nil)
+      @config = config || Configuration.new
+      @logger = create_logger
+    end
+
+    def self.setup(config = nil)
+      self.instance = new(config)
+    end
+
+    def self.info(message, context = {})
+      instance&.info(message, context)
+    end
+
+    def self.warn(message, context = {})
+      instance&.warn(message, context)
+    end
+
+    def self.error(message, context = {})
+      instance&.error(message, context)
+    end
+
+    def self.debug(message, context = {})
+      instance&.debug(message, context)
+    end
+
+    def info(message, context = {})
+      log(:info, message, context)
+    end
+
+    def warn(message, context = {})
+      log(:warn, message, context)
+    end
+
+    def error(message, context = {})
+      log(:error, message, context)
+    end
+
+    def debug(message, context = {})
+      log(:debug, message, context)
+    end
+
+    private
+
+    def create_logger
+      # Ensure log directory exists
+      log_dir = File.dirname(@config.log_file)
+      FileUtils.mkdir_p(log_dir) unless Dir.exist?(log_dir)
+
+      # Create logger with file rotation
+      logger = ::Logger.new(
+        @config.log_file,
+        @config.max_files,
+        @config.max_file_size
+      )
+
+      # Set log level
+      logger.level = case @config.log_level.downcase
+                    when 'debug' then ::Logger::DEBUG
+                    when 'info' then ::Logger::INFO
+                    when 'warn' then ::Logger::WARN
+                    when 'error' then ::Logger::ERROR
+                    else ::Logger::INFO
+                    end
+
+      # Set format
+      logger.formatter = proc do |severity, datetime, progname, msg|
+        "#{datetime.strftime('%Y-%m-%d %H:%M:%S')} [#{severity}] #{progname}: #{msg}\n"
+      end
+
+      logger
+    end
+
+    def log(level, message, context = {})
+      return unless @logger
+
+      # Add context information
+      full_message = message
+      if context.any?
+        context_str = context.map { |k, v| "#{k}=#{v}" }.join(' ')
+        full_message = "#{message} | #{context_str}"
+      end
+
+      @logger.send(level, full_message)
+    rescue => e
+      # Fallback to stdout if logging fails
+      puts "Logging error: #{e.message}"
+      puts "#{level.upcase}: #{message}"
+    end
+  end
+end