context_drop 0.1.0

data/app/assets/stylesheets/context_drop/application.css

@@ -0,0 +1,2 @@
+/* ContextDrop Engine Dashboard Stylesheet */
+/* Styles are also embedded in layouts/context_drop/application.html.erb for zero-config asset setups */

data/app/controllers/context_drop/application_controller.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module ContextDrop
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+
+    before_action :ensure_context_drop_enabled!
+
+    rescue_from ActionController::InvalidAuthenticityToken, with: :handle_invalid_csrf_token
+    rescue_from ContextDrop::UploadValidator::ValidationError, with: :handle_upload_validation_error
+    rescue_from ContextDrop::MetadataSanitizer::SensitiveElementError, with: :handle_sensitive_element_error
+
+    class << self
+      def rate_limit_store
+        @rate_limit_store ||= {}
+      end
+
+      def rate_limit_mutex
+        @rate_limit_mutex ||= Mutex.new
+      end
+
+      def reset_rate_limits!
+        rate_limit_mutex.synchronize { rate_limit_store.clear }
+      end
+    end
+
+    private
+
+    def ensure_context_drop_enabled!
+      return if ContextDrop.enabled?
+
+      respond_to do |format|
+        format.json { render json: { error: "Not Found" }, status: :not_found }
+        format.any { head :not_found }
+      end
+    end
+
+    def current_context_drop_submitter
+      return @current_context_drop_submitter if defined?(@current_context_drop_submitter)
+
+      @current_context_drop_submitter = ContextDrop.config.resolve_submitter(self)
+    end
+
+    def enforce_submission_authorization!
+      submitter = current_context_drop_submitter
+      if !ContextDrop.config.allow_anonymous && submitter.nil?
+        render json: { error: "Authentication required to submit feedback" }, status: :unauthorized
+        return
+      end
+
+      return if ContextDrop.config.submission_authorized?(self)
+
+      render json: { error: "Forbidden" }, status: :forbidden
+    end
+
+    def enforce_rate_limit!
+      limit_cfg = ContextDrop.config.rate_limit
+      return unless limit_cfg.is_a?(Hash)
+
+      max_requests = (limit_cfg[:max_requests] || limit_cfg["max_requests"]).to_i
+      period_seconds = (limit_cfg[:period] || limit_cfg["period"]).to_i
+      return if max_requests <= 0 || period_seconds <= 0
+
+      client_identifier = request.remote_ip.presence || "unknown"
+      bucket = (Time.now.to_i / period_seconds)
+      cache_key = "context_drop:rate_limit:#{client_identifier}:#{bucket}"
+
+      count = increment_rate_limit_counter(cache_key, period_seconds)
+      return if count <= max_requests
+
+      render json: { error: "Rate limit exceeded. Please try again later." }, status: :too_many_requests
+    end
+
+    def increment_rate_limit_counter(cache_key, period_seconds)
+      if defined?(Rails) && Rails.respond_to?(:cache) && Rails.cache && !Rails.cache.is_a?(ActiveSupport::Cache::NullStore)
+        current = Rails.cache.read(cache_key).to_i + 1
+        Rails.cache.write(cache_key, current, expires_in: period_seconds)
+        current
+      else
+        self.class.rate_limit_mutex.synchronize do
+          store = self.class.rate_limit_store
+          now = Time.now.to_i
+          store.delete_if { |_k, v| v[:expires_at] <= now }
+          entry = store[cache_key] ||= { count: 0, expires_at: now + period_seconds }
+          entry[:count] += 1
+          entry[:count]
+        end
+      end
+    end
+
+    def hashed_session_identifier
+      raw_id = session.id.to_s if respond_to?(:session) && session.respond_to?(:id) && session.id
+      return nil if raw_id.nil? || raw_id.empty?
+
+      Digest::SHA256.hexdigest(raw_id)[0, 32]
+    rescue StandardError
+      nil
+    end
+
+    def handle_invalid_csrf_token
+      render json: { error: "Invalid or missing CSRF authenticity token" }, status: :unprocessable_entity
+    end
+
+    def handle_upload_validation_error(exception)
+      render json: { error: exception.message }, status: exception.http_status
+    end
+
+    def handle_sensitive_element_error(exception)
+      render json: { error: exception.message }, status: :unprocessable_entity
+    end
+  end
+end

data/app/controllers/context_drop/attachments_controller.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ContextDrop
+  class AttachmentsController < ApplicationController
+    before_action :enforce_submission_authorization!
+    before_action :enforce_rate_limit!
+
+    def create
+      validated = ContextDrop::UploadValidator.validate!(params[:file])
+
+      blob_args = {
+        io: validated[:io],
+        filename: validated[:filename],
+        content_type: validated[:content_type]
+      }
+      if ContextDrop.config.active_storage_service
+        blob_args[:service_name] = ContextDrop.config.active_storage_service
+      end
+
+      blob = ActiveStorage::Blob.create_and_upload!(**blob_args)
+
+      render json: {
+        signed_blob_id: blob.signed_id,
+        filename: validated[:filename],
+        content_type: validated[:content_type],
+        byte_size: validated[:byte_size],
+        dimensions: validated[:dimensions]
+      }, status: :created
+    end
+  end
+end

data/app/controllers/context_drop/configs_controller.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ContextDrop
+  class ConfigsController < ApplicationController
+    before_action :enforce_submission_authorization!, only: [:show]
+
+    def show
+      render json: ContextDrop.config.public_widget_config, status: :ok
+    end
+
+    def widget_bundle
+      bundle_path = ContextDrop::Engine.root.join("app/assets/javascripts/context_drop/context_drop.js")
+      if File.exist?(bundle_path)
+        send_file bundle_path, type: "application/javascript", disposition: "inline"
+      else
+        head :not_found
+      end
+    end
+  end
+end

data/app/controllers/context_drop/dashboard/feedbacks_controller.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module ContextDrop
+  module Dashboard
+    class FeedbacksController < ApplicationController
+      layout "context_drop/application"
+
+      before_action :enforce_dashboard_authorization!
+
+      PER_PAGE = 25
+
+      def index
+        @status_counts = {
+          "all" => ContextDrop::Feedback.count,
+          "new" => ContextDrop::Feedback.new_records.count,
+          "reviewed" => ContextDrop::Feedback.reviewed.count,
+          "resolved" => ContextDrop::Feedback.resolved.count,
+          "dismissed" => ContextDrop::Feedback.dismissed.count
+        }
+
+        scope = ContextDrop::Feedback.includes(:submitter, :element_references, :attachments).recent
+
+        @current_status = params[:status].to_s.strip
+        if ContextDrop::Feedback::STATUSES.include?(@current_status)
+          scope = scope.where(status: @current_status)
+        else
+          @current_status = ""
+        end
+
+        @page_url_filter = params[:page_url].to_s.strip
+        if @page_url_filter.present?
+          scope = scope.where("context_drop_feedbacks.page_url LIKE ?", "%#{sanitize_sql_like(@page_url_filter)}%")
+        end
+
+        @search_query = (params[:q] || params[:query]).to_s.strip
+        if @search_query.present?
+          pattern = "%#{sanitize_sql_like(@search_query)}%"
+          scope = scope.left_outer_joins(:element_references).where(
+            "context_drop_feedbacks.message LIKE :q OR " \
+            "context_drop_element_references.selector LIKE :q OR " \
+            "context_drop_element_references.dom_path LIKE :q OR " \
+            "context_drop_element_references.text_content LIKE :q",
+            q: pattern
+          ).distinct
+        end
+
+        @total_filtered = scope.count
+        @page = [params[:page].to_i, 1].max
+        @total_pages = [(@total_filtered.to_f / PER_PAGE).ceil, 1].max
+        @feedbacks = scope.limit(PER_PAGE).offset((@page - 1) * PER_PAGE)
+      end
+
+      def show
+        @feedback = ContextDrop::Feedback
+                    .includes(:submitter, :element_references, :attachments)
+                    .find(params[:id])
+      end
+
+      def update
+        @feedback = ContextDrop::Feedback.find(params[:id])
+        next_status = (params[:status] || params.dig(:feedback, :status)).to_s.strip
+
+        unless ContextDrop::Feedback::STATUSES.include?(next_status)
+          respond_to do |format|
+            format.json { render json: { error: "Invalid status '#{next_status}'" }, status: :unprocessable_entity }
+            format.html do
+              redirect_to dashboard_feedback_path(@feedback), alert: "Invalid status '#{next_status}'."
+            end
+          end
+          return
+        end
+
+        @feedback.update!(status: next_status)
+
+        respond_to do |format|
+          format.json do
+            render json: {
+              id: @feedback.id,
+              status: @feedback.status,
+              updated_at: @feedback.updated_at.iso8601
+            }, status: :ok
+          end
+          format.html do
+            redirect_to dashboard_feedback_path(@feedback), notice: "Feedback ##{@feedback.id} marked as #{@feedback.status}."
+          end
+        end
+      end
+
+      private
+
+      def enforce_dashboard_authorization!
+        return if ContextDrop.config.dashboard_authorized?(self)
+
+        respond_to do |format|
+          format.json { render json: { error: "Forbidden" }, status: :forbidden }
+          format.any { render plain: "403 Forbidden — Not authorized to view ContextDrop Dashboard", status: :forbidden }
+        end
+      end
+
+      def sanitize_sql_like(str)
+        ActiveRecord::Base.sanitize_sql_like(str.to_s)
+      rescue StandardError
+        str.to_s.gsub(/[%_\\]/) { |m| "\\#{m}" }
+      end
+    end
+  end
+end

data/app/controllers/context_drop/feedbacks_controller.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module ContextDrop
+  class FeedbacksController < ApplicationController
+    before_action :enforce_submission_authorization!
+    before_action :enforce_rate_limit!
+
+    def create
+      payload = extract_feedback_payload
+      raw_elements = Array(payload["element_references"])
+      raw_attachments = Array(payload["attachments"])
+
+      if raw_attachments.size > ContextDrop.config.max_attachments.to_i
+        render json: {
+          error: "Attachments count (#{raw_attachments.size}) exceeds maximum allowed (#{ContextDrop.config.max_attachments})"
+        }, status: :unprocessable_entity
+        return
+      end
+
+      if raw_elements.size > ContextDrop.config.max_element_references.to_i
+        render json: {
+          error: "Element references count (#{raw_elements.size}) exceeds maximum allowed (#{ContextDrop.config.max_element_references})"
+        }, status: :unprocessable_entity
+        return
+      end
+
+      feedback = nil
+
+      ContextDrop::Feedback.transaction do
+        feedback = ContextDrop::Feedback.new(
+          submitter: current_context_drop_submitter,
+          session_id: hashed_session_identifier,
+          message: payload["message"].to_s.strip.presence,
+          page_url: (payload["page_url"].presence || request.referer).to_s.strip,
+          user_agent: (payload["user_agent"].presence || request.user_agent).to_s.strip.presence,
+          metadata: ContextDrop::MetadataSanitizer.sanitize_feedback_metadata(payload["metadata"]),
+          status: "new"
+        )
+
+        element_refs_by_client_ref = {}
+        raw_elements.each_with_index do |raw_el, idx|
+          sanitized_el = ContextDrop::MetadataSanitizer.sanitize_element_reference(raw_el)
+          el_record = feedback.element_references.build(sanitized_el)
+          client_key = sanitized_el[:client_ref].presence || idx.to_s
+          element_refs_by_client_ref[client_key] = el_record
+        end
+
+        pending_file_attachments = []
+        raw_attachments.each do |raw_att|
+          att_hash = stringify_hash(raw_att)
+          att_type = (att_hash["attachment_type"] || att_hash["type"] || "image").to_s.strip.downcase
+          att_meta = ContextDrop::MetadataSanitizer.sanitize_attachment_metadata(att_hash["metadata"])
+
+          linked_ref_key = (
+            att_hash["element_reference_ref"] ||
+            att_hash["element_attachment_ref"] ||
+            att_hash["client_ref"] ||
+            att_meta["element_attachment_ref"] ||
+            att_meta["client_ref"]
+          ).to_s.strip.presence
+
+          linked_el = linked_ref_key ? element_refs_by_client_ref[linked_ref_key] : nil
+          file_source = resolve_attachment_file_source(att_hash)
+
+          if file_source[:dimensions] && att_meta["image_dimensions"].nil?
+            att_meta["image_dimensions"] = {
+              "width" => file_source[:dimensions][0],
+              "height" => file_source[:dimensions][1]
+            }
+          end
+
+          att_record = feedback.attachments.build(
+            attachment_type: att_type,
+            element_reference: linked_el,
+            metadata: att_meta
+          )
+          pending_file_attachments << [att_record, linked_el, file_source]
+        end
+
+        unless feedback.valid?
+          render json: { error: feedback.errors.full_messages.join(", "), errors: feedback.errors.full_messages },
+                 status: :unprocessable_entity
+          raise ActiveRecord::Rollback
+        end
+
+        feedback.save!
+
+        pending_file_attachments.each do |att_record, linked_el, file_source|
+          if linked_el && att_record.element_reference_id.nil?
+            att_record.update_column(:element_reference_id, linked_el.id)
+          end
+          attach_binary_to_record!(att_record, file_source)
+        end
+      end
+
+      return if performed?
+
+      invoke_on_feedback_created(feedback)
+
+      render json: {
+        id: feedback.id,
+        status: feedback.status,
+        attachments_count: feedback.attachments.size,
+        element_references_count: feedback.element_references.size,
+        created_at: feedback.created_at.iso8601
+      }, status: :created
+    end
+
+    private
+
+    def extract_feedback_payload
+      raw = params[:feedback].is_a?(ActionController::Parameters) || params[:feedback].is_a?(Hash) ? params[:feedback] : params
+      hash = stringify_hash(raw)
+
+      %w[metadata element_references attachments].each do |key|
+        next unless hash[key].is_a?(String)
+
+        begin
+          hash[key] = JSON.parse(hash[key])
+        rescue JSON::ParserError
+          # Leave as-is if not valid JSON string
+        end
+      end
+
+      hash
+    end
+
+    def resolve_attachment_file_source(att_hash)
+      if att_hash["signed_blob_id"].present?
+        { type: :signed_blob, signed_blob_id: att_hash["signed_blob_id"].to_s }
+      elsif att_hash["file"].present?
+        validated = ContextDrop::UploadValidator.validate!(att_hash["file"])
+        { type: :validated_io, validated: validated, dimensions: validated[:dimensions] }
+      elsif att_hash["data_url"].present? || att_hash["data"].present?
+        raw_data = (att_hash["data_url"] || att_hash["data"]).to_s
+        decoded = decode_base64_image(raw_data, att_hash["filename"])
+        validated = ContextDrop::UploadValidator.validate!(decoded)
+        { type: :validated_io, validated: validated, dimensions: validated[:dimensions] }
+      else
+        { type: :none }
+      end
+    end
+
+    def attach_binary_to_record!(att_record, file_source)
+      return unless att_record.respond_to?(:file)
+
+      case file_source[:type]
+      when :signed_blob
+        blob = ActiveStorage::Blob.find_signed!(file_source[:signed_blob_id])
+        validate_existing_blob!(blob)
+        att_record.file.attach(blob)
+      when :validated_io
+        val = file_source[:validated]
+        att_record.file.attach(
+          io: val[:io],
+          filename: val[:filename],
+          content_type: val[:content_type]
+        )
+      end
+    rescue ActiveSupport::MessageVerifier::InvalidSignature, ActiveRecord::RecordNotFound
+      raise ContextDrop::UploadValidator::ValidationError, "Invalid or expired signed_blob_id"
+    end
+
+    def validate_existing_blob!(blob)
+      max_size = ContextDrop.config.max_attachment_size.to_i
+      if max_size.positive? && blob.byte_size > max_size
+        raise ContextDrop::UploadValidator::ValidationError, "Attached blob exceeds maximum allowed size"
+      end
+
+      allowed_types = Array(ContextDrop.config.allowed_content_types)
+      return if allowed_types.include?(blob.content_type)
+
+      raise ContextDrop::UploadValidator::ValidationError, "Attached blob has disallowed content type"
+    end
+
+    def decode_base64_image(raw_data, custom_filename = nil)
+      b64_payload = if raw_data.include?(";base64,")
+                      raw_data.split(";base64,", 2).last
+                    else
+                      raw_data
+                    end
+      bytes = ContextDrop::Base64Util.strict_decode64(b64_payload.strip)
+      {
+        io: StringIO.new(bytes),
+        filename: custom_filename.presence || "screenshot.png"
+      }
+    rescue ArgumentError
+      raise ContextDrop::UploadValidator::ValidationError, "Invalid base64 attachment data"
+    end
+
+    def invoke_on_feedback_created(feedback)
+      callback = ContextDrop.config.on_feedback_created
+      callback.call(feedback) if callback.respond_to?(:call)
+    rescue StandardError => e
+      Rails.logger.error("[ContextDrop] on_feedback_created callback error: #{e.class}: #{e.message}") if defined?(Rails.logger) && Rails.logger
+    end
+
+    def stringify_hash(obj)
+      if obj.respond_to?(:to_unsafe_h)
+        obj.to_unsafe_h.transform_keys(&:to_s)
+      elsif obj.is_a?(Hash)
+        obj.transform_keys(&:to_s)
+      else
+        {}
+      end
+    end
+  end
+end

data/app/controllers/context_drop/health_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ContextDrop
+  class HealthController < ApplicationController
+    def show
+      render json: { status: "ok", version: ContextDrop::VERSION }, status: :ok
+    end
+  end
+end

data/app/controllers/context_drop/mcp_controller.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "json"
+
+module ContextDrop
+  class McpController < ApplicationController
+    skip_before_action :verify_authenticity_token
+    skip_before_action :ensure_context_drop_enabled!
+
+    before_action :ensure_mcp_enabled!
+    before_action :authenticate_mcp_request!
+
+    def create
+      raw_body = request.raw_post.to_s
+      payload = JSON.parse(raw_body)
+      response = ContextDrop::MCP::Dispatcher.call(payload)
+
+      if response.nil?
+        head :accepted
+      else
+        render json: response, status: :ok
+      end
+    rescue JSON::ParserError => e
+      render json: {
+        jsonrpc: "2.0",
+        id: nil,
+        error: {
+          code: -32_700,
+          message: "Parse error: #{e.message}"
+        }
+      }, status: :ok
+    end
+
+    private
+
+    def ensure_mcp_enabled!
+      return if ContextDrop.config.mcp_enabled
+
+      render json: { error: "Not Found" }, status: :not_found
+    end
+
+    def authenticate_mcp_request!
+      if ContextDrop.config.authorize_mcp.respond_to?(:call)
+        return if ContextDrop.config.authorize_mcp.call(self)
+
+        render json: { error: "Unauthorized MCP request" }, status: :unauthorized
+        return
+      end
+
+      expected_key = ContextDrop.config.mcp_api_key.to_s
+      if expected_key.strip.empty?
+        render json: { error: "Unauthorized: MCP API key is not configured" }, status: :unauthorized
+        return
+      end
+
+      auth_header = request.headers["Authorization"].to_s
+      provided_token = auth_header.start_with?("Bearer ") ? auth_header.sub(/\ABearer\s+/i, "").strip : ""
+
+      if provided_token.bytesize == expected_key.bytesize &&
+         ActiveSupport::SecurityUtils.secure_compare(provided_token, expected_key)
+        return
+      end
+
+      render json: { error: "Unauthorized: Invalid or missing Bearer token" }, status: :unauthorized
+    end
+  end
+end

data/app/helpers/context_drop/widget_helper.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "json"
+require "erb"
+
+module ContextDrop
+  module WidgetHelper
+    # Renders the `<context-drop-widget>` custom element and script tag when ContextDrop is enabled
+    # and the current visitor is authorized to submit feedback.
+    #
+    # Supports per-page option overrides (`position:`, `placeholder:`, `metadata:`, `endpoint:`).
+    def context_drop_widget(**options)
+      cfg = ContextDrop.config
+      return nil unless cfg.enabled
+
+      controller_instance = respond_to?(:controller) ? controller : nil
+      return nil unless cfg.submission_authorized?(controller_instance)
+
+      widget_config = cfg.public_widget_config(options)
+      mount_path = resolve_context_drop_mount_path(options[:endpoint])
+      custom_metadata = options[:metadata].is_a?(Hash) ? options[:metadata] : {}
+
+      attrs = {
+        "data-endpoint" => mount_path,
+        "data-position" => widget_config[:position],
+        "data-placeholder" => widget_config[:placeholder],
+        "data-config" => JSON.generate(widget_config),
+        "data-metadata" => JSON.generate(custom_metadata)
+      }
+
+      attr_string = attrs.map { |k, v| %(#{k}="#{ERB::Util.html_escape(v)}") }.join(" ")
+      widget_html = "<context-drop-widget #{attr_string}></context-drop-widget>"
+
+      script_html = if respond_to?(:javascript_include_tag)
+                      begin
+                        javascript_include_tag("context_drop/context_drop", defer: true)
+                      rescue StandardError
+                        %(<script src="#{ERB::Util.html_escape(mount_path)}/assets/context_drop.js" defer="defer"></script>)
+                      end
+                    else
+                      %(<script src="#{ERB::Util.html_escape(mount_path)}/assets/context_drop.js" defer="defer"></script>)
+                    end
+
+      output = "#{widget_html}\n#{script_html}"
+      output.respond_to?(:html_safe) ? output.html_safe : output
+    end
+
+    private
+
+    def resolve_context_drop_mount_path(explicit_endpoint = nil)
+      return explicit_endpoint.to_s.chomp("/") if explicit_endpoint && !explicit_endpoint.to_s.strip.empty?
+
+      if respond_to?(:context_drop) && context_drop.respond_to?(:root_path)
+        context_drop.root_path.to_s.chomp("/")
+      else
+        "/context_drop"
+      end
+    rescue StandardError
+      "/context_drop"
+    end
+  end
+end