.

Author: gildesmarais

.devcontainer/Dockerfile

@@ -1,7 +1,7 @@
 FROM mcr.microsoft.com/devcontainers/ruby:3.4-bullseye
 
 # Install Node.js 20
-RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
+RUN curl -fsSL https://deb.nodesource.com/setup_22.x | bash - \
   && apt-get install -y nodejs
 
 # Install system dependencies

.devcontainer/scripts/setup.sh

@@ -46,7 +46,7 @@ ENV PORT=3000 \
 EXPOSE $PORT
 
 HEALTHCHECK --interval=30m --timeout=60s --start-period=5s \
-  CMD curl -f -H "Authorization: Bearer ${HEALTH_CHECK_TOKEN}" http://localhost:${PORT}/health_check.txt || exit 1
+  CMD curl -f -H "Authorization: Bearer ${HEALTH_CHECK_TOKEN}" http://localhost:${PORT}/api/v1/health || exit 1
 
 ARG USER=html2rss
 ARG UID=991

Dockerfile

@@ -60,7 +60,7 @@ task :test do
   sh <<~COMMAND
     docker exec html2rss-web-test curl -f \
       -H "Authorization: Bearer health-check-token-xyz789" \
-      http://127.0.0.1:3000/health_check.txt || exit 1
+      http://127.0.0.1:3000/api/v1/health || exit 1
   COMMAND
 
   # skipped as html2rss is used in development version

Rakefile

@@ -10,7 +10,6 @@
 require_relative 'app/auth'
 require_relative 'app/auto_source'
 require_relative 'app/feeds'
-require_relative 'app/health_check'
 require_relative 'app/local_config'
 require_relative 'app/exceptions'
 require_relative 'app/xml_builder'
@@ -120,21 +119,12 @@ def development? = self.class.development?
           r.response['Content-Type'] = 'application/json'
 
           r.on 'health' do
-            r.get 'ready' do
-              JSON.generate(Api::V1::Health.ready(r))
-            end
-            r.get 'live' do
-              JSON.generate(Api::V1::Health.live(r))
-            end
             r.get do
               JSON.generate(Api::V1::Health.show(r))
             end
           end
 
           r.on 'strategies' do
-            r.get String do |strategy_id|
-              JSON.generate(Api::V1::Strategies.show(r, strategy_id))
-            end
             r.get do
               JSON.generate(Api::V1::Strategies.index(r))
             end
@@ -148,9 +138,6 @@ def development? = self.class.development?
             r.post do
               JSON.generate(Api::V1::Feeds.create(r))
             end
-            r.get do
-              JSON.generate(Api::V1::Feeds.index(r))
-            end
           end
 
           r.get 'docs' do
@@ -171,16 +158,12 @@ def development? = self.class.development?
           end
         end
 
-        # Backward compatibility: /{feed_name} (no auth required)
         r.get String do |feed_name|
-          # Skip static file requests
           next if feed_name.include?('.') && !feed_name.end_with?('.xml', '.rss')
 
           handle_feed_generation(r, feed_name)
         end
-        r.get 'health_check.txt' do
-          handle_health_check(r)
-        end
+
         r.root do
           index_path = 'public/frontend/index.html'
           response['Content-Type'] = 'text/html'
@@ -198,43 +181,6 @@ def handle_feed_generation(router, feed_name)
         rss_content
       end
 
-      def handle_health_check(router)
-        router.response['Content-Type'] = 'text/plain'
-
-        verify_health_check_authorization!(router)
-        verify_health_status!
-
-        'success'
-      rescue UnauthorizedError => error
-        router.response.status = 401
-        error.message
-      rescue StandardError => error
-        router.response.status = 500
-
-        "health check error: #{error.message}"
-      end
-
-      def verify_health_check_authorization!(router)
-        health_account = HealthCheck.find_health_check_account
-        account = Auth.authenticate(router)
-
-        return if authorized_health_check_account?(account, health_account)
-
-        raise UnauthorizedError, 'health check requires bearer token'
-      end
-
-      def authorized_health_check_account?(account, health_account)
-        account && health_account &&
-          account[:username] == health_account[:username] &&
-          account[:token] == health_account[:token]
-      end
-
-      def verify_health_status!
-        return if HealthCheck.run == 'success'
-
-        raise 'unhealthy'
-      end
-
       def fallback_html
         <<~HTML
           <!DOCTYPE html>

app.rb

@@ -29,19 +29,6 @@ def build_token_index
 
       # @return [Array<Hash>]
       def accounts
-        load_accounts
-      end
-
-      # @param username [String]
-      # @return [Hash, nil]
-      def get_account_by_username(username)
-        return nil unless username
-
-        accounts.find { |account| account[:username] == username }
-      end
-
-      # @return [Array<Hash>]
-      def load_accounts
         auth_config = LocalConfig.global[:auth]
         return [] unless auth_config&.dig(:accounts)
 
@@ -53,6 +40,14 @@ def load_accounts
           }
         end
       end
+
+      # @param username [String]
+      # @return [Hash, nil]
+      def get_account_by_username(username)
+        return nil unless username
+
+        accounts.find { |account| account[:username] == username }
+      end
     end
   end
 end

app/account_manager.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
 require 'time'
+require 'html2rss/url'
 
+require_relative '../../account_manager'
 require_relative '../../auth'
 require_relative '../../auto_source'
 require_relative '../../feeds'
 require_relative '../../exceptions'
 require_relative '../../feed_token'
+require_relative '../../url_validator'
 
 module Html2rss
   module Web
@@ -16,11 +19,6 @@ module V1
         module Feeds
           module_function
 
-          def index(_request)
-            feeds = Html2rss::Web::Feeds.list_feeds
-            { success: true, data: { feeds: feeds }, meta: { total: feeds.count } }
-          end
-
           def show(request, token)
             handle_token_based_feed(request, token)
           end
@@ -48,10 +46,6 @@ def handle_token_based_feed(request, token)
             generate_feed_response(request, feed_token.url)
           end
 
-          def extract_site_title(url)
-            AutoSource.extract_site_title(url)
-          end
-
           def validate_feed_token(token)
             feed_token = FeedToken.decode(token)
             raise UnauthorizedError, 'Invalid token' unless feed_token
@@ -63,21 +57,23 @@ def validate_feed_token(token)
           end
 
           def get_account_for_token(feed_token)
-            account = Auth.get_account_by_username(feed_token.username)
+            account = AccountManager.get_account_by_username(feed_token.username)
             raise UnauthorizedError, 'Account not found' unless account
 
             account
           end
 
           def validate_account_access(account, url)
-            raise ForbiddenError, 'Access Denied' unless Auth.url_allowed?(account, url)
+            raise ForbiddenError, 'Access Denied' unless UrlValidator.url_allowed?(account, url)
           end
 
           def generate_feed_response(request, url)
             strategy = select_strategy(request.params['strategy'])
             rss_content = AutoSource.generate_feed_content(url, strategy)
 
             request.response['Content-Type'] = 'application/xml'
+
+            # TODO: get ttl from feed
             HttpCache.expires(request.response, 600, cache_control: 'public')
 
             rss_content.to_s
@@ -97,15 +93,16 @@ def extract_create_params(request)
             strategy = select_strategy(request.params['strategy'])
             {
               url: url,
-              name: request.params['name'] || extract_site_title(url),
+              name: extract_site_title(url),
               strategy: strategy
             }
           end
 
           def validate_create_params(params, account)
             raise BadRequestError, 'URL parameter is required' if params[:url].nil? || params[:url].empty?
-            raise BadRequestError, 'Invalid URL format' unless Auth.valid_url?(params[:url])
-            raise ForbiddenError, 'URL not allowed for this account' unless Auth.url_allowed?(account, params[:url])
+            raise BadRequestError, 'Invalid URL format' unless UrlValidator.valid_url?(params[:url])
+            raise ForbiddenError, 'URL not allowed for this account' unless UrlValidator.url_allowed?(account,
+                                                                                                      params[:url])
           end
 
           def build_create_response(request, feed_data)
@@ -147,12 +144,18 @@ def feed_response_payload(feed_data)
             }
           end
 
+          def extract_site_title(url)
+            Html2rss::Url.for_channel(url).channel_titleized
+          rescue StandardError
+            nil
+          end
+
           module_function :extract_create_params, :validate_create_params, :build_create_response,
                           :authenticate_request, :select_strategy, :supported_strategies, :default_strategy,
-                          :feed_response_payload
+                          :feed_response_payload, :extract_site_title
           private_class_method :extract_create_params, :validate_create_params, :build_create_response,
                                :authenticate_request, :select_strategy, :supported_strategies, :default_strategy,
-                               :feed_response_payload
+                               :feed_response_payload, :extract_site_title
         end
       end
     end

app/api/v1/feeds.rb

@@ -3,8 +3,8 @@
 require 'time'
 
 require_relative '../../auth'
-require_relative '../../health_check'
 require_relative '../../exceptions'
+require_relative '../../local_config'
 
 module Html2rss
   module Web
@@ -16,17 +16,9 @@ module V1
         module Health
           module_function
 
-          def show(request) # rubocop:disable Metrics/MethodLength
-            health_check_account = HealthCheck.find_health_check_account
-            account = Auth.authenticate(request)
-
-            unless account && health_check_account && account[:token] == health_check_account[:token]
-              raise UnauthorizedError, 'Health check authentication required'
-            end
-
-            health_result = HealthCheck.run
-
-            raise InternalServerError, 'Health check failed' unless health_result == 'success'
+          def show(request)
+            authorize_health_check!(request)
+            verify_configuration!
 
             {
               success: true,
@@ -35,29 +27,25 @@ def show(request) # rubocop:disable Metrics/MethodLength
                   status: 'healthy',
                   timestamp: Time.now.iso8601,
                   version: '1.0.0',
-                  environment: ENV['RACK_ENV'] || 'development',
+                  environment: ENV.fetch('RACK_ENV', 'development'),
+                  uptime: Process.clock_gettime(Process::CLOCK_MONOTONIC),
                   checks: {}
                 }
               }
             }
           end
 
-          def ready(_request)
-            # Simple readiness check - just verify the app can respond
-            { success: true, data: { readiness: {
-              status: 'ready',
-              timestamp: Time.now.iso8601,
-              version: '1.0.0'
-            } } }
+          def authorize_health_check!(request)
+            account = Auth.authenticate(request)
+            return if account && account[:username] == 'health-check'
+
+            raise UnauthorizedError, 'Health check authentication required'
           end
 
-          def live(_request)
-            # Simple liveness check - just verify the app is running
-            { success: true, data: { liveness: {
-              status: 'alive',
-              timestamp: Time.now.iso8601,
-              uptime: Process.clock_gettime(Process::CLOCK_MONOTONIC)
-            } } }
+          def verify_configuration!
+            LocalConfig.yaml
+          rescue StandardError => error
+            raise InternalServerError, "Health check failed: #{error.message}"
           end
         end
       end