source_monitor 0.1.1

data/app/assets/javascripts/source_monitor/controllers/dropdown_controller.js

@@ -0,0 +1,109 @@
+import { Controller } from "@hotwired/stimulus";
+
+export default class extends Controller {
+  static targets = ["menu"];
+  static values = {
+    transitionModule: { type: String, default: "stimulus-use" },
+    hiddenClass: { type: String, default: "hidden" }
+  };
+
+  connect() {
+    this.element.dataset.dropdownState = "initializing";
+    this.transitionEnabled = false;
+    if (typeof this.toggleTransition !== "function") {
+      this.toggleTransition = this.toggleVisibility.bind(this);
+    }
+
+    if (typeof this.leave !== "function") {
+      this.leave = this.hideMenu.bind(this);
+    }
+
+    this.loadTransitions()
+      .catch(() => null)
+      .finally(() => {
+        this.element.dataset.dropdownState = "ready";
+      });
+  }
+
+  disconnect() {
+    delete this.element.dataset.dropdownState;
+  }
+
+  // Dynamic import provides progressive enhancement: smooth transitions when stimulus-use
+  // is available, graceful fallback to CSS class toggling when not. This complexity is
+  // justified as it allows the engine to work without requiring stimulus-use as a dependency.
+  // Evaluated for simplification in Phase 20.05.07 - Decision: Keep current implementation.
+  async loadTransitions() {
+    if (!this.hasMenuTarget || this.transitionModuleValue === "") {
+      this.logFallback();
+      return;
+    }
+
+    try {
+      const module = await import(this.transitionModuleValue);
+      const useTransition = module?.useTransition || module?.default?.useTransition;
+
+      if (typeof useTransition === "function") {
+        useTransition(this, {
+          element: this.menuTarget,
+          hiddenClass: this.hiddenClassValue
+        });
+        this.transitionEnabled = true;
+      } else {
+        this.logFallback();
+      }
+    } catch (error) {
+      this.logFallback(error);
+    }
+  }
+
+  toggle(event) {
+    if (this.transitionEnabled && typeof this.toggleTransition === "function") {
+      this.toggleTransition();
+    } else {
+      this.toggleVisibility();
+    }
+  }
+
+  hide(event) {
+    if (!this.hasMenuTarget) return;
+    if (event && this.element.contains(event.target)) return;
+
+    if (this.transitionEnabled && typeof this.leave === "function") {
+      this.leave();
+    } else {
+      this.hideMenu();
+    }
+  }
+
+  toggleVisibility() {
+    this.isOpen() ? this.hideMenu() : this.showMenu();
+  }
+
+  showMenu() {
+    if (!this.hasMenuTarget) return;
+    this.menuTarget.classList.remove(this.hiddenClassValue);
+  }
+
+  hideMenu() {
+    if (!this.hasMenuTarget) return;
+    this.menuTarget.classList.add(this.hiddenClassValue);
+  }
+
+  isOpen() {
+    return this.hasMenuTarget && !this.menuTarget.classList.contains(this.hiddenClassValue);
+  }
+
+  logFallback(error = null) {
+    this.transitionEnabled = false;
+    if (!this._fallbackLogged && typeof window !== "undefined" && window.console) {
+      window.console.warn(
+        "SourceMonitor dropdown transitions unavailable; using CSS class toggling instead."
+      );
+      if (error && typeof window.console.debug === "function") {
+        window.console.debug(error);
+      }
+    }
+    this._fallbackLogged = true;
+  }
+}

data/app/assets/javascripts/source_monitor/controllers/modal_controller.js

@@ -0,0 +1,56 @@
+import { Controller } from "@hotwired/stimulus";
+
+export default class extends Controller {
+  static targets = ["panel"];
+  static classes = ["open"];
+
+  connect() {
+    this.handleEscape = this.handleEscape.bind(this);
+  }
+
+  disconnect() {
+    this.teardown();
+  }
+
+  open(event) {
+    if (event) event.preventDefault();
+    if (!this.hasPanelTarget) return;
+
+    this.panelTarget.classList.remove("hidden");
+    if (this.hasOpenClass) {
+      this.panelTarget.classList.add(this.openClass);
+    }
+
+    document.body.classList.add("overflow-hidden");
+    document.addEventListener("keydown", this.handleEscape);
+  }
+
+  close(event) {
+    if (event) event.preventDefault();
+    if (!this.hasPanelTarget) return;
+
+    this.panelTarget.classList.add("hidden");
+    if (this.hasOpenClass) {
+      this.panelTarget.classList.remove(this.openClass);
+    }
+
+    this.teardown();
+  }
+
+  backdrop(event) {
+    if (event.target === event.currentTarget) {
+      this.close(event);
+    }
+  }
+
+  handleEscape(event) {
+    if (event.key === "Escape") {
+      this.close(event);
+    }
+  }
+
+  teardown() {
+    document.body.classList.remove("overflow-hidden");
+    document.removeEventListener("keydown", this.handleEscape);
+  }
+}

data/app/assets/javascripts/source_monitor/controllers/notification_controller.js

@@ -0,0 +1,53 @@
+import { Controller } from "@hotwired/stimulus";
+
+export default class extends Controller {
+  static values = {
+    delay: { default: 5000, type: Number }
+  };
+
+  connect() {
+    if (!window.SourceMonitorControllers) {
+      window.SourceMonitorControllers = {};
+    }
+
+    this.clearTimeout();
+    this.registerController();
+    this.startTimer();
+  }
+
+  disconnect() {
+    this.clearTimeout();
+  }
+
+  hide(event) {
+    if (event) event.preventDefault();
+    this.clearTimeout();
+    this.dismiss();
+  }
+
+  registerController() {
+    window.SourceMonitorControllers.notification = this;
+  }
+
+  startTimer() {
+    if (this.delayValue <= 0) return;
+    this.timeoutId = window.setTimeout(() => this.dismiss(), this.delayValue);
+  }
+
+  dismiss() {
+    if (!this.element) return;
+    this.element.classList.add("opacity-0", "translate-y-2");
+    window.setTimeout(() => {
+      if (this.element && this.element.remove) {
+        this.element.remove();
+      }
+    }, 200);
+  }
+
+  clearTimeout() {
+    if (!this.timeoutId) return;
+
+    window.clearTimeout(this.timeoutId);
+    this.timeoutId = null;
+  }
+}

data/app/assets/javascripts/source_monitor/turbo_actions.js

@@ -0,0 +1,13 @@
+// Custom Turbo Stream action for client-side redirects
+// Usage: responder.redirect(url, action: "advance")
+// Note: Turbo is available globally via turbo_include_tags in the layout
+if (window.Turbo && window.Turbo.StreamActions) {
+	window.Turbo.StreamActions.redirect = function () {
+		const url = this.getAttribute("url");
+		const visitAction = this.getAttribute("visit-action") || "advance";
+
+		if (url) {
+			window.Turbo.visit(url, { action: visitAction });
+		}
+	};
+}

data/app/assets/stylesheets/source_monitor/application.tailwind.css

@@ -0,0 +1,13 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@layer base {
+  .fm-admin {
+    @apply min-h-screen bg-slate-50 text-slate-900;
+  }
+
+  .fm-admin a {
+    @apply text-blue-600 hover:text-blue-500;
+  }
+}

data/app/controllers/concerns/source_monitor/sanitizes_search_params.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module SourceMonitor
+  module SanitizesSearchParams
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_search_scope, instance_writer: false
+      class_attribute :_default_search_sorts, instance_writer: false, default: [ "created_at desc" ]
+    end
+
+    class_methods do
+      def searchable_with(scope:, default_sorts: [ "created_at desc" ])
+        self._search_scope = scope
+        self._default_search_sorts = default_sorts
+      end
+    end
+
+    private
+
+    def build_search_query(scope = nil, params: sanitized_search_params)
+      base_scope = scope || search_scope
+      query = base_scope.ransack(params)
+      query.sorts = default_search_sorts if query.sorts.blank?
+      query
+    end
+
+    def search_scope
+      if _search_scope.respond_to?(:call)
+        instance_exec(&_search_scope)
+      else
+        _search_scope
+      end
+    end
+
+    def default_search_sorts
+      _default_search_sorts
+    end
+
+    def sanitized_search_params
+      raw = params[:q]
+      return {} unless raw
+
+      hash =
+        if raw.respond_to?(:to_unsafe_h)
+          raw.to_unsafe_h
+        elsif raw.respond_to?(:to_h)
+          raw.to_h
+        elsif raw.is_a?(Hash)
+          raw
+        else
+          {}
+        end
+
+      sanitized = SourceMonitor::Security::ParameterSanitizer.sanitize(hash)
+
+      sanitized_params = sanitized.each_with_object({}) do |(key, value), memo|
+        next if value.nil?
+
+        cleaned_value = value.is_a?(String) ? value.strip : value
+        next if cleaned_value.respond_to?(:blank?) ? cleaned_value.blank? : cleaned_value.nil?
+
+        memo[key.to_s] = cleaned_value
+      end
+
+      assign_sanitized_params(sanitized_params)
+
+      sanitized_params
+    end
+
+    def assign_sanitized_params(sanitized_params)
+      return unless respond_to?(:params) && params
+
+      if params.is_a?(ActionController::Parameters)
+        params[:q] = ActionController::Parameters.new(sanitized_params)
+      else
+        params[:q] = sanitized_params
+      end
+    end
+  end
+end

data/app/controllers/source_monitor/application_controller.rb

@@ -0,0 +1,62 @@
+module SourceMonitor
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception, prepend: true
+
+    before_action :authenticate_source_monitor_user
+    before_action :authorize_source_monitor_access
+
+    helper_method :source_monitor_current_user, :source_monitor_user_signed_in?
+    after_action :broadcast_flash_toasts
+
+    private
+
+    FLASH_LEVELS = {
+      notice: :success,
+      alert: :error,
+      error: :error,
+      success: :success,
+      warning: :warning
+    }.freeze
+
+    TOAST_DURATION_DEFAULT = 5000
+    TOAST_DURATION_ERROR = 6000
+
+    def authenticate_source_monitor_user
+      SourceMonitor::Security::Authentication.authenticate!(self)
+    end
+
+    def authorize_source_monitor_access
+      SourceMonitor::Security::Authentication.authorize!(self)
+    end
+
+    def source_monitor_current_user
+      SourceMonitor::Security::Authentication.current_user(self)
+    end
+
+    def source_monitor_user_signed_in?
+      SourceMonitor::Security::Authentication.user_signed_in?(self)
+    end
+
+    def toast_delay_for(level)
+      level.to_sym == :error ? TOAST_DURATION_ERROR : TOAST_DURATION_DEFAULT
+    end
+
+    def broadcast_flash_toasts
+      return if flash.empty?
+      return unless request.format.html? || request.format.turbo_stream?
+
+      flash.each do |key, message|
+        next if message.blank?
+
+        Array(message).each do |msg|
+          SourceMonitor::Realtime.broadcast_toast(
+            message: msg,
+            level: FLASH_LEVELS[key.to_sym] || :info
+          )
+        end
+      end
+    ensure
+      flash.discard
+    end
+  end
+end

data/app/controllers/source_monitor/dashboard_controller.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SourceMonitor
+  class DashboardController < ApplicationController
+    def index
+      queries = SourceMonitor::Dashboard::Queries.new
+      url_helpers = SourceMonitor::Engine.routes.url_helpers
+
+      @stats = queries.stats
+      @recent_activity = SourceMonitor::Dashboard::RecentActivityPresenter.new(
+        queries.recent_activity,
+        url_helpers:
+      ).to_a
+      @quick_actions = SourceMonitor::Dashboard::QuickActionsPresenter.new(
+        queries.quick_actions,
+        url_helpers:
+      ).to_a
+      @job_adapter = SourceMonitor::Jobs::Visibility.adapter_name
+      @job_metrics = queries.job_metrics
+      fetch_schedule = queries.upcoming_fetch_schedule
+      @fetch_schedule_groups = fetch_schedule.groups
+      @fetch_schedule_reference_time = fetch_schedule.reference_time
+      @mission_control_enabled = SourceMonitor.mission_control_enabled?
+      @mission_control_dashboard_path = SourceMonitor.mission_control_dashboard_path
+    end
+  end
+end

data/app/controllers/source_monitor/fetch_logs_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SourceMonitor
+  class FetchLogsController < ApplicationController
+    def show
+      @log = FetchLog.includes(:source).find(params[:id])
+    end
+  end
+end

data/app/controllers/source_monitor/health_controller.rb

@@ -0,0 +1,10 @@
+module SourceMonitor
+  class HealthController < ApplicationController
+    def show
+      render json: {
+        status: "ok",
+        metrics: SourceMonitor::Metrics.snapshot
+      }
+    end
+  end
+end

data/app/controllers/source_monitor/items_controller.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module SourceMonitor
+  class ItemsController < ApplicationController
+    include ActionView::RecordIdentifier
+    include SourceMonitor::SanitizesSearchParams
+
+    searchable_with scope: -> { Item.active.includes(:source) }, default_sorts: [ "published_at desc", "created_at desc" ]
+
+    PER_PAGE = 25
+    SEARCH_FIELD = :title_or_summary_or_url_or_source_name_cont
+
+    before_action :set_item, only: %i[show scrape]
+    before_action :load_scrape_context, only: :show
+
+    def index
+      @search_params = sanitized_search_params
+      @q = build_search_query
+
+      scope = @q.result(distinct: true)
+      paginator = SourceMonitor::Pagination::Paginator.new(
+        scope:,
+        page: params[:page],
+        per_page: PER_PAGE
+      ).paginate
+
+      @items = paginator.records
+      @page = paginator.page
+      @has_next_page = paginator.has_next_page
+      @has_previous_page = paginator.has_previous_page
+
+      @search_term = @search_params[SEARCH_FIELD.to_s].to_s.strip
+      @search_field = SEARCH_FIELD
+    end
+
+    def show
+    end
+
+    def scrape
+      log_manual_scrape("controller:start", item: @item, extra: { format: request.format })
+
+      enqueue_result = SourceMonitor::Scraping::Enqueuer.enqueue(item: @item, reason: :manual)
+      log_manual_scrape(
+        "controller:enqueue_result",
+        item: @item,
+        extra: { status: enqueue_result.status, message: enqueue_result.message }
+      )
+      flash_key, flash_message = scrape_flash_payload(enqueue_result)
+      status = enqueue_result.failure? ? :unprocessable_entity : :ok
+
+      respond_to do |format|
+        format.turbo_stream do
+          log_manual_scrape("controller:respond_turbo", item: @item, extra: { status: status })
+
+          responder = SourceMonitor::TurboStreams::StreamResponder.new
+
+          if enqueue_result.enqueued? || enqueue_result.already_enqueued?
+            @item.reload
+            responder.replace_details(
+              @item,
+              partial: "source_monitor/items/details_wrapper",
+              locals: { item: @item }
+            )
+          end
+
+          if flash_message
+            level = flash_key == :notice ? :info : :error
+            responder.toast(message: flash_message, level:, delay_ms: toast_delay_for(level))
+          end
+
+          render turbo_stream: responder.render(view_context), status: status
+        end
+
+        format.html do
+          log_manual_scrape("controller:respond_html", item: @item)
+          if flash_key && flash_message
+            redirect_to source_monitor.item_path(@item), flash: { flash_key => flash_message }
+          else
+            redirect_to source_monitor.item_path(@item)
+          end
+        end
+      end
+    end
+
+    private
+
+    def set_item
+      @item = Item.active.includes(:source, :item_content).find(params[:id])
+    end
+
+    def load_scrape_context
+      @recent_scrape_logs = @item.scrape_logs.order(started_at: :desc).limit(5)
+      @latest_scrape_log = @recent_scrape_logs.first
+    end
+
+    def scrape_flash_payload(result)
+      case result.status
+      when :enqueued
+        [ :notice, "Scrape has been enqueued and will run shortly." ]
+      when :already_enqueued
+        [ :notice, result.message ]
+      else
+        [ :alert, result.message || "Unable to enqueue scrape for this item." ]
+      end
+    end
+
+    def log_manual_scrape(stage, item:, extra: {})
+      return unless defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+
+      payload = { stage:, item_id: item&.id }.merge(extra.compact)
+      Rails.logger.info("[SourceMonitor::ManualScrape] #{payload.to_json}")
+    rescue StandardError
+      nil
+    end
+  end
+end

data/app/controllers/source_monitor/logs_controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SourceMonitor
+  class LogsController < ApplicationController
+    def index
+      @query_result = SourceMonitor::Logs::Query.new(params: params).call
+      @filter_set = @query_result.filter_set
+      @filter_params = @filter_set.to_params.symbolize_keys
+      @rows = SourceMonitor::Logs::TablePresenter.new(
+        entries: @query_result.entries,
+        url_helpers: SourceMonitor::Engine.routes.url_helpers
+      ).rows
+    end
+  end
+end

data/app/controllers/source_monitor/scrape_logs_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SourceMonitor
+  class ScrapeLogsController < ApplicationController
+    def show
+      @log = ScrapeLog.includes(:item, :source).find(params[:id])
+    end
+  end
+end

data/app/controllers/source_monitor/source_bulk_scrapes_controller.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module SourceMonitor
+  class SourceBulkScrapesController < ApplicationController
+    include SourceMonitor::SourceTurboResponses
+
+    ITEMS_PREVIEW_LIMIT = SourceMonitor::Scraping::BulkSourceScraper::DEFAULT_PREVIEW_LIMIT
+
+    before_action :set_source
+
+    def create
+      selection = bulk_scrape_params[:selection]
+      normalized_selection = SourceMonitor::Scraping::BulkSourceScraper.normalize_selection(selection) || :current
+      @bulk_scrape_selection = normalized_selection
+
+      result = SourceMonitor::Scraping::BulkSourceScraper.new(
+        source: @source,
+        selection: normalized_selection,
+        preview_limit: ITEMS_PREVIEW_LIMIT
+      ).call
+
+      respond_to_bulk_scrape(result)
+    end
+
+    private
+
+    def set_source
+      @source = Source.find(params[:source_id])
+    end
+
+    def bulk_scrape_params
+      params.fetch(:bulk_scrape, {}).permit(:selection)
+    end
+  end
+end

data/app/controllers/source_monitor/source_fetches_controller.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SourceMonitor
+  class SourceFetchesController < ApplicationController
+    include SourceMonitor::SourceTurboResponses
+
+    before_action :set_source
+
+    def create
+      SourceMonitor::Fetching::FetchRunner.enqueue(@source.id)
+      render_fetch_enqueue_response("Fetch has been enqueued and will run shortly.")
+    rescue StandardError => error
+      handle_fetch_failure(error)
+    end
+
+    private
+
+    def set_source
+      @source = Source.find(params[:source_id])
+    end
+  end
+end

data/app/controllers/source_monitor/source_health_checks_controller.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module SourceMonitor
+  class SourceHealthChecksController < ApplicationController
+    include SourceMonitor::SourceTurboResponses
+
+    before_action :set_source
+
+    def create
+      SourceMonitor::SourceHealthCheckJob.perform_later(@source.id)
+      render_fetch_enqueue_response(
+        "Health check enqueued",
+        health_status_override: processing_badge
+      )
+    rescue StandardError => error
+      handle_fetch_failure(error, prefix: "Health check")
+    end
+
+    private
+
+    def set_source
+      @source = Source.find(params[:source_id])
+    end
+
+    def processing_badge
+      {
+        label: "Processing",
+        classes: "bg-blue-100 text-blue-700",
+        show_spinner: true,
+        status: "processing"
+      }
+    end
+  end
+end