miniradio_server 0.0.3 → 0.1.0

data/lib/miniradio_server/app.rb

@@ -1,17 +1,22 @@
-# -*- coding: utf-8 -*-
-require 'rack'
-require 'open3' # Used in convert_to_hls
-require 'tilt/slim'
-require 'mp3info'
-require 'json'
+require "rack"
+require "open3" # Used in convert_to_hls
+require "tilt/slim"
+require "mp3info"
+require "json"
+require "uri"
+require "uri/rfc2396_parser"
 
 # Required to use the handler from Rack 3+
 # You might need to run: gem install rackup
-require 'rackup/handler/webrick'
+require "rackup/handler/webrick"
 
 # Rack application class
 module MiniradioServer
   class App
+    MAX_ARTWORK_BYTES = 5 * 1024 * 1024
+    URL_PARSER = URI::RFC2396_Parser.new
+    private_constant :URL_PARSER
+
     def initialize(mp3_dir, cache_dir, ffmpeg_cmd, segment_duration, logger)
       @mp3_dir = Pathname.new(mp3_dir).realpath
       @cache_dir = Pathname.new(cache_dir).realpath
@@ -20,16 +25,23 @@ module MiniradioServer
       @logger = logger
       # For managing locks during conversion processing (using Mutex per file)
       @conversion_locks = Hash.new { |h, k| h[k] = Mutex.new } # Mutex is built-in, no require needed
+      @locks_mutex = Mutex.new
     end
 
     def call(env)
-      request_path = env['PATH_INFO']
+      request_path = env["PATH_INFO"]
       @logger.info "Request received: #{request_path}"
 
       # Root URL
       match = request_path.match(%r{^/$|^/index(\.html)$})
       if match
-        return response(200, index, 'text/html')
+        return response(200, index, "text/html")
+      end
+
+      if (artwork = request_path.match(%r{^/artwork/([^/]+)$}))
+        _basename, source, error = mp3_source(artwork[1])
+        return error if error
+        return serve_artwork(source)
       end
 
       # Path pattern: /stream/{mp3_basename}/{playlist or segment}
@@ -41,37 +53,25 @@ module MiniradioServer
         return not_found_response("Not Found (Invalid Path Format)")
       end
 
-      mp3_basename = URI.decode_uri_component(match[1]) # e.g., "your_music" (without extension)
+      mp3_basename, original_mp3_path, error = mp3_source(match[1])
+      return error if error
       requested_filename = match[2] # e.g., "playlist.m3u8" or "segment001.mp3"
       extension = match[3].downcase # "m3u8" or "mp3"
-
-      # --- Check if the original MP3 file exists ---
-      # Security: Check for directory traversal in basename
-      if mp3_basename.include?('..') || mp3_basename.include?('/')
-        @logger.warn "Invalid MP3 base name requested: #{mp3_basename}"
-        return forbidden_response("Invalid filename.")
-      end
-      original_mp3_path = @mp3_dir.join("#{mp3_basename}.mp3")
-
-      unless original_mp3_path.exist? && original_mp3_path.file?
-        @logger.warn "Original MP3 file not found: #{original_mp3_path}"
-        return not_found_response("Not Found (Original MP3)")
-      end
+      return not_found_response if extension == "m3u8" && requested_filename != "playlist.m3u8"
 
       # --- Build cache paths ---
       cache_subdir = @cache_dir.join(mp3_basename)
       hls_playlist_path = cache_subdir.join("playlist.m3u8")
       requested_cache_file_path = cache_subdir.join(requested_filename)
 
-      # Security: Check if the requested cache file path is within the cache subdirectory
-      # Use string comparison as realpath fails if the file doesn't exist yet
-      unless requested_cache_file_path.to_s.start_with?(cache_subdir.to_s + File::SEPARATOR) || requested_cache_file_path == hls_playlist_path
+      # Check lexical paths and resolved ancestors, including symlinks.
+      unless within_directory?(cache_subdir, @cache_dir) && within_directory?(requested_cache_file_path, cache_subdir)
         @logger.warn "Attempted access outside cache directory: #{requested_cache_file_path}"
         return forbidden_response("Access denied.")
       end
 
       # --- Process based on request type ---
-      if extension == 'm3u8'
+      if extension == "m3u8"
         # M3U8 request: Check if conversion is needed, convert if necessary, and serve
         ensure_hls_converted(original_mp3_path, cache_subdir, hls_playlist_path) do |status, message|
           case status
@@ -84,60 +84,115 @@ module MiniradioServer
             return internal_server_error_response(message || "HLS conversion failed.")
           end
         end
-      elsif extension == 'mp3'
+      elsif extension == "mp3"
         # MP3 segment request: Serve from cache (404 if not found)
         # Normally, the m3u8 is requested first, so the cache should exist
         if requested_cache_file_path.exist? && requested_cache_file_path.file?
-          return serve_file(requested_cache_file_path)
+          serve_file(requested_cache_file_path)
         else
           # Segment request might come before m3u8, or an invalid request after conversion failure
           @logger.warn "Segment file not found (cache not generated or invalid request?): #{requested_cache_file_path}"
           # For simplicity, return 404. A more robust check might verify parent conversion status.
-          return not_found_response("Not Found (Segment)")
+          not_found_response("Not Found (Segment)")
         end
       else
         # Should not reach here
         @logger.error "Unexpected file extension: #{extension}"
-        return internal_server_error_response
+        internal_server_error_response
       end
-
     rescue SystemCallError => e # File access related errors (ENOENT, EACCES, etc.)
       @logger.error "File access error: #{e.message}"
       # Return 404 or 500 depending on the context
-      return not_found_response("Resource not found or access denied")
+      not_found_response("Resource not found or access denied")
     rescue => e
       @logger.error "Unexpected error occurred: #{e.message}"
       @logger.error e.backtrace.join("\n")
-      return internal_server_error_response
+      internal_server_error_response
     end
 
     def get_mp3_list
       r = []
       @mp3_dir.glob("*.mp3").each do |file|
-        mp3 = {}
-        Mp3Info.open(file) do |mp3info|
-          mp3[:title] = mp3info.tag.title
-          mp3[:artist] = mp3info.tag.artist
-          mp3[:album] = mp3info.tag.album
-          mp3[:file] = file.basename(".mp3")
+        next unless file.file? && within_directory?(file, @mp3_dir)
+        name = file.basename(".mp3").to_s
+        encoded_file = URL_PARSER.escape(name, /[^a-zA-Z0-9\-._~]/)
+        mp3 = {file: name, title: nil, artist: nil, album: nil,
+               url: "/stream/#{encoded_file}/playlist.m3u8", artwork_url: "/artwork/#{encoded_file}"}
+        begin
+          Mp3Info.open(file) do |mp3info|
+            mp3[:title] = mp3info.tag.title
+            mp3[:artist] = mp3info.tag.artist
+            mp3[:album] = mp3info.tag.album
+          end
+        rescue => e
+          @logger.warn "Unable to read metadata for #{name}: #{e.message}"
         end
         r << mp3
       end
       r
     end
-  
+
     def index
-        template = Tilt::SlimTemplate.new("#{__dir__}/templ/index.html.slim")
-        template.render(self, :mp3_list => get_mp3_list)
+      template = Tilt::SlimTemplate.new("#{__dir__}/templ/index.html.slim")
+      # JSON is data, but HTML still recognizes closing script tags inside it.
+      tracks_json = JSON.generate(get_mp3_list).gsub("<", '\\u003c').gsub(">", '\\u003e').gsub("&", '\\u0026')
+      template.render(self, tracks_json: tracks_json)
     end
 
     private
 
+    # The stream and artwork routes share the same source validation.
+    def mp3_source(encoded_name)
+      name = URL_PARSER.unescape(encoded_name).force_encoding(Encoding::UTF_8)
+      if !name.valid_encoding? || name.include?("\0") || name.include?("..") || name.include?("/") || name.include?("\\")
+        return [nil, nil, forbidden_response("Invalid filename.")]
+      end
+      path = @mp3_dir.join("#{name}.mp3")
+      return [nil, nil, forbidden_response("Access denied.")] unless within_directory?(path, @mp3_dir)
+      return [nil, nil, not_found_response("Not Found (Original MP3)")] unless path.file?
+
+      [name, path, nil]
+    end
+
+    def serve_artwork(source)
+      Mp3Info.open(source) do |mp3|
+        mp3.tag2.pictures.each do |_name, data|
+          next unless data.is_a?(String) && data.bytesize <= MAX_ARTWORK_BYTES
+          data = data.b
+          mime = if data.start_with?("\x89PNG\r\n\x1a\n".b)
+            "image/png"
+          elsif data.start_with?("\xff\xd8\xff".b)
+            "image/jpeg"
+          end
+          next unless mime
+
+          return [200, {"content-type" => mime, "content-length" => data.bytesize.to_s,
+                        "cache-control" => "no-store", "x-content-type-options" => "nosniff"}, [data]]
+        end
+      end
+      not_found_response("No supported artwork")
+    rescue => e
+      @logger.warn "Unable to read artwork: #{e.message}"
+      not_found_response("No supported artwork")
+    end
+
+    # Resolve existing ancestors as well as files, so symlinks cannot escape a
+    # configured directory before conversion or when serving cached segments.
+    def within_directory?(path, directory)
+      return false unless path.to_s.start_with?(directory.to_s + File::SEPARATOR) || path == directory
+
+      ancestor = path
+      ancestor = ancestor.parent until ancestor.exist? || ancestor.symlink?
+      resolved = ancestor.realpath.join(path.relative_path_from(ancestor))
+      root = directory.exist? ? directory.realpath : directory
+      resolved == root || resolved.to_s.start_with?(root.to_s + File::SEPARATOR)
+    end
+
     # Check if HLS conversion is needed and execute if necessary (with lock)
     # Yields the status (:ok, :already_exists, :converting, :error) and an optional message to the block
     def ensure_hls_converted(input_mp3_path, output_dir, playlist_path)
-      mp3_basename = input_mp3_path.basename('.mp3').to_s
-      lock = @conversion_locks[mp3_basename] # Get the Mutex specific to this file
+      mp3_basename = input_mp3_path.basename(".mp3").to_s
+      lock = @locks_mutex.synchronize { @conversion_locks[mp3_basename] }
 
       # Check if the converted file already exists (check outside lock for speed)
       if playlist_path.exist?
@@ -174,7 +229,6 @@ module MiniradioServer
       end
     end
 
-
     # Convert MP3 file to HLS format (execute ffmpeg)
     # Returns: [Boolean (success/failure), String (error message or nil)]
     def convert_to_hls(input_mp3_path, output_dir)
@@ -187,21 +241,21 @@ module MiniradioServer
       # Build the ffmpeg command (using an array is safer for paths with spaces)
       cmd = [
         @ffmpeg_cmd,
-        '-y',                               # Overwrite existing files (just in case)
-        '-i', input_mp3_path.to_s,
-        '-c:a', 'copy',                     # Copy audio codec (no re-encoding)
-        '-f', 'hls',
-        '-hls_time', @segment_duration.to_s,
-        '-hls_list_size', '0',              # VOD (include all segments in the list)
-        '-hls_playlist_type', 'vod',        # Specify VOD playlist type
-        '-hls_segment_filename', segment_path_template.to_s,
+        "-y",                               # Overwrite existing files (just in case)
+        "-i", input_mp3_path.to_s,
+        "-c:a", "copy",                     # Copy audio codec (no re-encoding)
+        "-f", "hls",
+        "-hls_time", @segment_duration.to_s,
+        "-hls_list_size", "0",              # VOD (include all segments in the list)
+        "-hls_playlist_type", "vod",        # Specify VOD playlist type
+        "-hls_segment_filename", segment_path_template.to_s,
         playlist_path.to_s
       ]
 
-      @logger.info "Executing command: #{cmd.join(' ')}"
+      @logger.info "Executing command: #{cmd.join(" ")}"
 
       # Execute command (capture standard output, standard error, and status)
-      stdout, stderr, status = Open3.capture3(*cmd)
+      _stdout, stderr, status = Open3.capture3(*cmd)
 
       unless status.success?
         error_message = "ffmpeg exited with status #{status.exitstatus}. Stderr: #{stderr.strip}"
@@ -216,16 +270,15 @@ module MiniradioServer
       end
 
       # Log warnings from stderr even on success (if necessary), ignoring common deprecation warnings
-      unless stderr.empty? || stderr.strip.downcase.include?('deprecated')
+      unless stderr.empty? || stderr.strip.downcase.include?("deprecated")
         @logger.warn "ffmpeg stderr (on success): #{stderr.strip}"
       end
 
-      return [true, nil]
-
+      [true, nil]
     rescue Errno::ENOENT => e # Command not found, etc.
       error_message = "Error occurred during ffmpeg command preparation: #{e.message}"
       @logger.error error_message
-      return [false, error_message]
+      [false, error_message]
     rescue => e # Catch other exceptions around ffmpeg execution
       error_message = "Unexpected error occurred during ffmpeg execution: #{e.message}"
       @logger.error error_message
@@ -235,17 +288,17 @@ module MiniradioServer
       rescue => e_rm
         @logger.error "Error occurred while deleting cache directory: #{output_dir}, Error: #{e_rm.message}"
       end
-      return [false, error_message]
+      [false, error_message]
     end
 
     # Serve the file
     def serve_file(file_path)
       extension = file_path.extname.downcase
       content_type = case extension
-      when '.m3u8'
-        'application/vnd.apple.mpegurl' # Or 'audio/mpegurl'
-      when '.mp3'
-        'audio/mpeg'
+      when ".m3u8"
+        "application/vnd.apple.mpegurl" # Or 'audio/mpegurl'
+      when ".mp3"
+        "audio/mpeg"
       else
         @logger.warn "Serving attempt: Unsupported file type: #{file_path}"
         return forbidden_response("Unsupported file type.")
@@ -268,16 +321,15 @@ module MiniradioServer
         return internal_server_error_response("Failed to get file size")
       end
 
-
       headers = {
-        'Content-Type' => content_type,
-        'Content-Length' => file_size.to_s,
-        'Access-Control-Allow-Origin' => '*', # CORS header
+        "content-type" => content_type,
+        "content-length" => file_size.to_s,
+        "access-control-allow-origin" => "*", # CORS header
         # For HLS, it's often safer not to cache (especially for live streams)
         # For VOD, caching might be okay, but we'll disable it here for simplicity
-        'Cache-Control' => 'no-cache, no-store, must-revalidate',
-        'Pragma' => 'no-cache',
-        'Expires' => '0'
+        "cache-control" => "no-cache, no-store, must-revalidate",
+        "pragma" => "no-cache",
+        "expires" => "0"
       }
 
       @logger.info "Serving: #{file_path} (#{content_type}, #{file_size} bytes)"
@@ -285,7 +337,7 @@ module MiniradioServer
       # Return the File object as the response body (Rack handles streaming efficiently)
       begin
         # Open in binary mode
-        file_body = file_path.open('rb')
+        file_body = file_path.open("rb")
         [200, headers, file_body]
       rescue SystemCallError => e # Error during file opening
         @logger.error "Failed to open file: #{file_path}, Error: #{e.message}"
@@ -295,10 +347,10 @@ module MiniradioServer
     end
 
     # --- HTTP Status Code Response Methods ---
-    def response(status, message, content_type = 'text/plain', extra_headers = {})
+    def response(status, message, content_type = "text/plain", extra_headers = {})
       headers = {
-        'Content-Type' => content_type,
-        'Access-Control-Allow-Origin' => '*'
+        "content-type" => content_type,
+        "access-control-allow-origin" => "*"
       }.merge(extra_headers)
       # Returning the body as an array is the Rack specification
       [status, headers, [message + "\n"]]
@@ -318,8 +370,7 @@ module MiniradioServer
 
     def service_unavailable_response(message = "Service Unavailable")
       # Add Retry-After header suggesting a retry after 5 seconds
-      response(503, message, 'text/plain', { 'Retry-After' => '5' })
+      response(503, message, "text/plain", {"retry-after" => "5"})
     end
   end
 end
-

data/lib/miniradio_server/cli.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "optparse"
+require_relative "../miniradio_server"
+
+module MiniradioServer
+  module CLI
+    def self.run(argv = ARGV, out: $stdout, err: $stderr)
+      options = {
+        mp3_dir: MP3_SRC_DIR, cache_dir: HLS_CACHE_DIR,
+        port: SERVER_PORT, ffmpeg: FFMPEG_COMMAND,
+        segment_duration: HLS_SEGMENT_DURATION
+      }
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: miniradio_server [options]"
+        opts.on("--mp3-dir PATH", "Directory containing MP3 files") { |value| options[:mp3_dir] = value }
+        opts.on("--cache-dir PATH", "HLS cache directory") { |value| options[:cache_dir] = value }
+        opts.on("--port PORT", Integer, "HTTP port (default: 9292)") { |value| options[:port] = value }
+        opts.on("--ffmpeg PATH", "FFmpeg executable") { |value| options[:ffmpeg] = value }
+        opts.on("--version", "Print the version") {
+          out.puts(VERSION)
+          return 0
+        }
+        opts.on("-h", "--help", "Print this help") {
+          out.puts(opts)
+          return 0
+        }
+      end
+      remaining = parser.parse(argv)
+      raise OptionParser::InvalidArgument, remaining.join(" ") unless remaining.empty?
+      raise OptionParser::InvalidArgument, "port must be between 1 and 65535" unless (1..65535).cover?(options[:port])
+
+      logger = Logger.new(out)
+      logger.level = Logger::INFO
+      MiniradioServer.ensure_directories_exist([options[:mp3_dir], options[:cache_dir]], logger)
+      app = App.new(options[:mp3_dir], options[:cache_dir], options[:ffmpeg], options[:segment_duration], logger)
+      out.puts "Starting Miniradio Server #{VERSION} on port #{options[:port]}..."
+      out.puts "MP3 Source Directory: #{File.expand_path(options[:mp3_dir])}"
+      out.puts "HLS Cache Directory: #{File.expand_path(options[:cache_dir])}"
+      out.puts "Server URL: http://localhost:#{options[:port]}"
+      out.puts "Press Ctrl+C to stop."
+      Rackup::Handler::WEBrick.run(
+        Rack::Static.new(app, urls: ["/style", "/player.js"], root: File.expand_path("../public", __dir__)),
+        Port: options[:port], Logger: logger, AccessLog: []
+      )
+      0
+    rescue Interrupt
+      out.puts "\nShutting down server."
+      0
+    rescue OptionParser::ParseError, SystemCallError => e
+      err.puts "Error: #{e.message}"
+      1
+    end
+  end
+end

data/lib/miniradio_server/templ/index.html.slim

@@ -1,50 +1,61 @@
 doctype html
-html
+html lang="en"
     head
         meta charset="UTF-8"
         meta name="viewport" content="width=device-width, initial-scale=1.0"
         title Miniradio Server
         link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.min.css" type="text/css"
-        link rel="stylesheet" href="style/main.css" type="text/css"
-        script src="https://cdn.jsdelivr.net/npm/hls.js@1"
+        link rel="stylesheet" href="/style/main.css" type="text/css"
+        script src="https://cdn.jsdelivr.net/npm/hls.js@1" defer=true
+        script src="/player.js" defer=true
     body
-        h1 Straming List
-        table.compact.striped
-            thead
-                tr
-                    th scope="col" Play
-                    th scope="col" Title
-                    th scope="col" Artist
-                    th scope="col" Album
-            tbody
-                - mp3_list.each_with_index do |mp3, i|
+        header.container
+            h1 Miniradio
+        main.container
+            section.now-playing aria-label="Current track"
+                div.track-details
+                    div.artwork
+                        img id="currentArtwork" alt="" hidden=true
+                        div id="artworkPlaceholder" aria-hidden="true"
+                            span ♪
+                            small No artwork
+                    div.track-metadata aria-live="polite"
+                        p id="playbackState" No track selected
+                        h2 id="currentTrack" Select a track
+                        p id="currentArtist"
+                        p id="currentAlbum"
+                div.custom-controls id="customControls" hidden=true
+                    div.time-labels
+                        span id="elapsedTime" 0:00
+                        span id="durationTime" --:--
+                    input id="seekControl" type="range" min="0" max="0" step="0.1" value="0" disabled=true aria-label="Playback position"
+                    div.transport role="group" aria-label="Playback controls"
+                        button id="prevButton" disabled=true aria-label="Previous track" ⏮ Previous
+                        button id="playPauseButton" disabled=true Play
+                        button id="nextButton" disabled=true aria-label="Next track" Next ⏭
+                        div.volume id="volumeControls"
+                            button id="muteButton" aria-pressed="false" Mute
+                            label for="volumeControl" Volume
+                            input id="volumeControl" type="range" min="0" max="1" step="0.01" value="1"
+                        small id="volumeHint" hidden=true Use your device’s volume controls.
+                    div.playback-options role="group" aria-label="Playback options"
+                        button id="startButton" Play all
+                        button id="loopButton" aria-pressed="false" Repeat track: OFF
+                        button id="shuffleButton" aria-pressed="false" Shuffle: OFF
+                audio id="player" controls=true preload="none"
+                p id="playerStatus" role="status"
+            h2.playlist-heading Tracks
+            table.compact.striped id="playlistTable"
+                thead
                     tr
-                        td
-                            audio controls=true id='audio-#{i+1}'
-                        td=mp3[:title] || mp3[:file]
-                        td=mp3[:artist]
-                        td=mp3[:album]
-        javascript:
-            function setupHLS(audioElementId, streamUrl) {
-                const audio = document.getElementById(audioElementId);
-
-                if (Hls.isSupported()) {
-                    const hls = new Hls();
-                    hls.loadSource(streamUrl);
-                    hls.attachMedia(audio);
-                    hls.on(Hls.Events.MANIFEST_PARSED, function () {
-                        console.log(`${audioElementId} loaded`);
-                    });
-                } else if (audio.canPlayType('application/vnd.apple.mpegurl')) {
-                    // HLS native support browser. ex.Safari
-                    audio.src = streamUrl;
-                } else {
-                    console.error('This browser cannot play HLS.');
-                }
-            }
-            var mp3s = #{{JSON.generate(mp3_list)}};
-            for (let i = 0; i < mp3s.length; i++) {
-                setupHLS(`audio-${i+1}`, `/stream/${mp3s[i].file}/playlist.m3u8`);
-            }
-        hr
-        p Miniradio ver #{MiniradioServer::VERSION}
+                        th scope="col" Play
+                        th scope="col" Title
+                        th scope="col" Artist
+                        th scope="col" Album
+                        th scope="col" Status
+                tbody
+            script id="tracks" type="application/json"
+                == tracks_json
+        footer.container
+            hr
+            p Miniradio ver #{MiniradioServer::VERSION}

data/lib/miniradio_server/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MiniradioServer
-  VERSION = "0.0.3"
+  VERSION = "0.1.0"
 end

data/lib/miniradio_server.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'logger'
-require 'pathname'
-require 'fileutils'
+require "logger"
+require "pathname"
+require "fileutils"
 
 require_relative "miniradio_server/version"
 
@@ -11,13 +11,13 @@ module MiniradioServer
 
   # --- Configuration ---
   # Directory containing the original MP3 files
-  MP3_SRC_DIR = File.expand_path('./mp3_files')
+  MP3_SRC_DIR = File.expand_path("./mp3_files")
   # Directory to cache the HLS converted content
-  HLS_CACHE_DIR = File.expand_path('./hls_cache')
+  HLS_CACHE_DIR = File.expand_path("./hls_cache")
   # Port the server will listen on
   SERVER_PORT = 9292
   # Path to the ffmpeg command (usually just 'ffmpeg' if it's in the system PATH)
-  FFMPEG_COMMAND = 'ffmpeg'
+  FFMPEG_COMMAND = "ffmpeg"
   # HLS segment duration in seconds
   HLS_SEGMENT_DURATION = 10
   # ---
@@ -38,69 +38,3 @@ module MiniradioServer
 end
 
 require_relative "miniradio_server/app"
-
-# --- Server Startup ---
-
-# Only run server startup logic if the script is executed directly
-if __FILE__ == $PROGRAM_NAME || 'bin/miniradio_server' == $PROGRAM_NAME || 'miniradio_server' == $PROGRAM_NAME
-  logger = Logger.new(STDOUT)
-  # Ensure directories exist before starting the app
-  # Use constants defined within the module
-  MiniradioServer.ensure_directories_exist(
-    [MiniradioServer::MP3_SRC_DIR, MiniradioServer::HLS_CACHE_DIR],
-    logger
-  )
-
-  logger.level = Logger::INFO
-
-  # Check encoding settings, especially for non-ASCII filenames
-  Encoding.default_external = Encoding::UTF_8 if Encoding.default_external != Encoding::UTF_8
-  # Encoding.default_internal = Encoding::UTF_8 # Set internal encoding if needed
-
-  # Use constants defined within the module
-  app = MiniradioServer::App.new(
-    MiniradioServer::MP3_SRC_DIR,
-    MiniradioServer::HLS_CACHE_DIR,
-    MiniradioServer::FFMPEG_COMMAND,
-    MiniradioServer::HLS_SEGMENT_DURATION,
-    logger
-  )
-
-  puts "Starting HLS conversion and streaming server on port #{MiniradioServer::SERVER_PORT}..."
-  puts "MP3 Source Directory: #{MiniradioServer::MP3_SRC_DIR}"
-  puts "HLS Cache Directory: #{MiniradioServer::HLS_CACHE_DIR}"
-  puts "Default External Encoding: #{Encoding.default_external}" # For confirmation log
-  puts "Server URL: http://localhost:9292"
-  puts "Example Streaming URL: http://localhost:#{MiniradioServer::SERVER_PORT}/stream/{mp3_filename_without_extension}/playlist.m3u8"
-  puts "e.g., If mp3_files/ contains my_music.mp3 -> http://localhost:#{MiniradioServer::SERVER_PORT}/stream/my_music/playlist.m3u8"
-  puts "Press Ctrl+C to stop."
-
-  begin
-    # Use Rackup::Handler::WEBrick, recommended for Rack 3+
-    Rackup::Handler::WEBrick.run(
-      Rack::Static.new(app, urls: ["/style", "/images"], root: "#{__dir__}/public"),
-      Port: MiniradioServer::SERVER_PORT,
-      Logger: logger,       # Share logger with WEBrick
-      AccessLog: []       # Disable WEBrick's own access log (logging handled by Rack app)
-      # , :DoNotReverseLookup => true # Disable DNS reverse lookup for faster responses (optional)
-    )
-  rescue Interrupt # When stopped with Ctrl+C
-    puts "\nShutting down server."
-  rescue Errno::EADDRINUSE # Port already in use
-    puts "Error: Port #{MiniradioServer::SERVER_PORT} is already in use."
-    exit(1)
-  rescue LoadError => e
-    # Error handling if rackup/handler/webrick is not found
-    if e.message.include?('rackup/handler/webrick')
-      puts "Error: Rackup WEBrick handler not found."
-      puts "Please install the rackup gem by running: `gem install rackup`"
-    else
-      puts "Library load error: #{e.message}"
-    end
-    exit(1)
-  rescue => e
-    puts "Server startup error: #{e.message}"
-    puts e.backtrace.join("\n")
-    exit(1)
-  end
-end