itsi 0.1.20 → 0.2.3

data/gems/server/lib/itsi/server/rack_interface.rb

@@ -1,7 +1,6 @@
 module Itsi
   class Server
     module RackInterface
-
       # Builds a handler proc that is compatible with Rack applications.
       def self.for(app)
         require "rack"

data/gems/server/lib/itsi/server/route_tester.rb

@@ -1,16 +1,68 @@
 module Itsi
   class Server
+    # Utility module for printing Itsi route information
     module RouteTester
-
       require "set"
       require "strscan"
-
+      require "debug"
       def format_mw(mw)
-        case mw["type"]
+        mw_name, mw_args = mw
+        case mw_name
         when "app"
-          "app #{mw["parameters"]["app_proc"].inspect.split(" ")[1]}"
+          "\e[33mapp\e[0m(#{mw_args["app_proc"].inspect.split(" ")[1][0...-1]})"
+        when "log_requests"
+          if mw_args["before"] && mw_args["after"]
+            "\e[33mlog_requests\e[0m(before: #{mw_args["before"]["format"][0..6]}..., after: #{mw_args["after"]["format"][0..6]}...)"
+          elsif mw_args["before"]
+            "\e[33mlog_requests\e[0m(before: #{mw_args["before"]["format"][0..6]}...)"
+          elsif mw_args["after"]
+            "\e[33mlog_requests\e[0m(before: nil, after: #{mw_args["after"]["format"][0..6]}...)"
+          end
+        when "compress"
+          "\e[33mcompress\e[0m(#{mw_args["algorithms"].join(" ")}, #{mw_args["mime_types"]})"
+        when "cors"
+          "\e[33mcors\e[0m(#{mw_args["allow_origins"].join(" ")}, #{mw_args["allow_methods"].join(" ")})"
+        when "etag"
+          "\e[33metag\e[0m(#{mw_args["type"]}/#{mw_args["algorithm"]}, #{mw_args["handle_if_none_match"] ? "if_none_match" : ""})"
+        when "cache_control"
+          "\e[33mcache_control\e[0m(max_age: #{mw_args["max_age"]}, #{mw_args.select do |_, v|
+            v == true
+          end.keys.join(", ")})"
+        when "redirect"
+          "\e[33mredirect\e[0m(to: #{mw_args["to"]}, type: #{mw_args["type"]})"
+        when "static_assets"
+          "\e[33mstatic_assets\e[0m(path: #{mw_args["root_dir"]})"
+        when "auth_api_key"
+          "\e[33mauth_api_key\e[0m(keys: #{mw_args["valid_keys"].keys}#{mw_args["credentials_file"] ? ", credentials_file: #{mw_args["credentials_file"]}" : ""})"
+        when "auth_basic"
+          "\e[33mbasic_auth\e[0m(keys: #{mw_args["realm"]}#{mw_args["credentials_file"] ? ", credentials_file: #{mw_args["credentials_file"]}" : ""})"
+        when "auth_jwt"
+          "\e[33mjwt_auth\e[0m(#{mw_args["verifiers"].keys.join(",")})"
+        when "rate_limit"
+          key = mw_args["key"].is_a?(Hash) ? mw_args["key"]["parameter"] : mw_args["key"]
+          "\e[33mrate_limit\e[0m(rps: #{mw_args["requests"]}/#{mw_args["seconds"]}, key: #{key})"
+        when "allow_list"
+          "\e[33mallow_list\e[0m(patterns: #{mw_args["allowed_patterns"].join(", ")})"
+        when "deny_list"
+          "\e[33mdeny_list\e[0m(patterns: #{mw_args["denied_patterns"].join(", ")})"
+        when "csp"
+          "\e[33mcsp\e[0m(#{mw_args["policy"].map { |k, v| "#{k}: #{v.join(",")}" }.join(", ")})"
+        when "intrusion_protection"
+          [mw_args].flatten.map do |mw_args|
+            "\e[33mintrusion_protection\e[0m(banned_url_patterns: #{mw_args["banned_url_patterns"]&.length}, banned_header_patterns: #{mw_args["banned_header_patterns"]&.keys&.join(", ")}, #{mw_args["banned_time_seconds"]}s)"
+          end.join("\n")
+        when "request_headers"
+          [mw_args].flatten.map do |mw_args|
+            "\e[33mrequest_headers\e[0m(added: #{mw_args["additions"].keys}, removed: #{mw_args["removals"]})"
+          end.join("\n")
+        when "response_headers"
+          [mw_args].flatten.map do |mw_args|
+            "\e[33mresponse_headers\e[0m(added: #{mw_args["additions"].keys}, removed: #{mw_args["removals"]})"
+          end.join("\n")
+        when "static_response"
+          "\e[response_headers\e[0m(#{mw_args["code"]} body: #{mw_args["body"][0..10]})"
         else
-          mw["type"]
+          "\e[33m#{mw.first}\e[0m"
         end
       end
 
@@ -21,12 +73,12 @@ module Itsi
         end.compact
         filter_str = filters.any? ? filters.join(", ") : "(none)"
 
-        middlewares = stack["middleware"]
+        middlewares = stack["middleware"].to_a
 
         puts "─" * 76
-        puts "Route:      #{route_str}"
-        puts "Conditions: #{filter_str}"
-        puts "Middleware: • #{format_mw(middlewares.first)}"
+        puts "\e[32mRoute:\e[0m      \e[33m#{route_str}\e[0m"
+        puts "\e[32mConditions:\e[0m \e[34m#{filter_str}\e[0m"
+        puts "\e[32mMiddleware:\e[0m • #{format_mw(middlewares.first)}"
         middlewares[1..].each do |mw|
           puts "            • #{format_mw(mw)}"
         end

data/gems/server/lib/itsi/server/signal_trap.rb

@@ -19,7 +19,7 @@ module Itsi
     end
 
     def server_running?
-      Itsi::Server.respond_to?(:running) && Itsi::Server.running?
+      Itsi::Server.respond_to?(:running?) && Itsi::Server.running?
     end
   end
 end

data/gems/server/lib/itsi/server/typed_handlers/param_parser.rb

@@ -23,21 +23,21 @@ module Itsi
             case v
             when true, 'true', '1', 1 then true
             when false, 'false', '0', 0 then false
-            else raise "Cannot cast #{v.inspect} to Boolean"
+            else raise ValidationError.new("Cannot cast #{v.inspect} to Boolean")
             end
           },
           FalseClass => ->(v){
             case v
             when true, 'true', '1', 1 then true
             when false, 'false', '0', 0 then false
-            else raise "Cannot cast #{v.inspect} to Boolean"
+            else raise ValidationError.new("Cannot cast #{v.inspect} to Boolean")
             end
           },
           :Boolean  => ->(v){
             case v
             when true, 'true', '1', 1 then true
             when false, 'false', '0', 0 then false
-            else raise "Cannot cast #{v.inspect} to Boolean"
+            else raise ValidationError.new("Cannot cast #{v.inspect} to Boolean")
             end
           },
           Date      => ->(v){ Date.parse(v.to_s) },
@@ -45,17 +45,6 @@ module Itsi
           DateTime  => ->(v){ DateTime.parse(v.to_s) }
         }.compare_by_identity
 
-        # Extracts the expected type and required flag from a schema definition.
-        def extract_schema(schema_def)
-          if schema_def.is_a?(Hash) && schema_def.key?(:_type)
-            expected_type = schema_def[:_type]
-            required = schema_def.fetch(:required, true)
-            [expected_type, required]
-          else
-            [schema_def, true]
-          end
-        end
-
         # Preprocess the schema into fixed keys (as symbols) and regex keys.
         # Memoizes the result based on the schema.
         def processed_schema(schema)
@@ -63,8 +52,9 @@ module Itsi
           @@schema_cache[schema] ||= begin
             fixed = {}
             regex = []
+            required_params = schema[:_required] || []
             schema.each do |k, schema_def|
-              expected_type, required = extract_schema(schema_def)
+              expected_type, required = schema_def, required_params.include?(k)
               if k.is_a?(Regexp)
                 regex << [k, [expected_type, required]]
               else
@@ -179,16 +169,22 @@ module Itsi
           end
 
           # Process regex keys (only string keys not already handled as fixed keys).
-          params.keys.select { |k| k.is_a?(String) }.each do |key|
+          params.keys.each do |key|
+            if key == :_required
+              params.delete(key)
+              next
+            end
             next if fixed_schema.has_key?(key.to_sym) || fixed_schema.has_key?(key)
-            regex_schema.each do |regex, (expected_type, _required)|
+            unless regex_schema.find do |regex, (expected_type, _required)|
               if regex.match(key)
                 new_path = path + [key]
                 err = cast_value!(params, key, expected_type, new_path)
                 errors << err if err
-                break  # only use the first matching regex
+                true  # only use the first matching regex
               end
             end
+              params.delete(key)
+            end
           end
 
           raise ValidationError.new(errors) unless errors.empty?

data/gems/server/lib/itsi/server/typed_handlers/source_parser.rb

@@ -2,37 +2,41 @@ module Itsi
   class Server
     module TypedHandlers
       module SourceParser
-        require 'prism'
-
+        require "prism"
 
+        # Source Parser interprets endpoint handlers
+        # and extracts arity and schema information.
         def self.extract_expr_from_source_location(proc)
-          source_lines = IO.readlines(proc.source_location.first)
+          source_location = proc.source_location
+          source_lines = IO.readlines(source_location.first)
 
           proc_line = source_location.last - 1
           first_line = source_lines[proc_line]
 
-          until first_line =~ /(?:lambda|proc|->|def|.*?do\s*\|)/ || proc_line.zero?
+          until first_line =~ /(?:lambda|proc|->|def|.*?do\s*|.*?\{.*?\|)/ || proc_line.zero?
             proc_line -= 1
             first_line = source_lines[proc_line]
           end
           lines = source_lines[proc_line..]
-          lines[0] = lines[0][/(?:lambda|proc|->|def|.*?do\s*\|).*/]
+          lines[0] = lines[0][/(?:lambda|proc|->|def|.*?do\s+|.*?\{.*?\|).*/]
           src_str = lines.first << "\n"
           intermediate = Prism.parse(src_str)
 
           lines[1..-1].each do |line|
             break if intermediate.success?
+
             token_count = 0
             line.split(/(?=\s|;|\)|\})/).each do |token|
               src_str << token
               token_count += 1
               intermediate = Prism.parse(src_str)
               next unless intermediate.success? && token_count > 1
+
               break
             end
           end
 
-          raise 'Source Extraction Failed' unless intermediate.success?
+          raise "Source Extraction Failed" unless intermediate.success?
 
           src = intermediate.value.statements.body.first.yield_self do |s|
             s.type == :call_node ? s.block : s
@@ -40,14 +44,13 @@ module Itsi
           params = src.parameters
           params = params.parameters if params.respond_to?(:parameters)
           requireds = (params&.requireds || []).map(&:name)
-          optionals = params&.optionals || []
           keywords =  (params&.keywords || []).map do |kw|
-            [kw.name, kw.value.slice.gsub(/^_\./, '$.')]
+            [kw.name, kw.value.slice.gsub(/^_\./, "$.")]
           end.to_h
 
           [requireds.length, keywords]
-        rescue
-          [ proc.parameters.first&.length || 0, {}]
+        rescue StandardError
+          [proc.parameters.select { |p| p == :req }&.length || 0, {}]
         end
       end
     end

data/gems/server/lib/itsi/server/typed_handlers.rb

@@ -5,10 +5,18 @@ module Itsi
   class Server
     module TypedHandlers
       def self.handler_for(proc, input_schema)
-        input_schema = proc.binding.eval(input_schema) if input_schema
-        lambda do |req|
-          req.params(input_schema) do |params|
-            proc.call(req, params: params)
+        if input_schema
+          input_schema = proc.binding.eval(input_schema)
+          lambda do |req|
+            req.params(input_schema) do |params|
+              proc.call(req, params: params)
+            end
+          end
+        else
+          lambda do |req|
+            req.params do |params|
+              proc.call(req, params)
+            end
           end
         end
       end

data/gems/server/lib/itsi/server/version.rb

@@ -2,6 +2,6 @@
 
 module Itsi
   class Server
-    VERSION = "0.1.20"
+    VERSION = "0.2.3"
   end
 end

data/gems/server/lib/itsi/server.rb

@@ -17,6 +17,9 @@ require_relative "http_response"
 require_relative "passfile"
 require_relative "../shell_completions/completions"
 
+require "securerandom"
+require "fileutils"
+
 module Itsi
   class Server
     extend RackInterface
@@ -24,21 +27,25 @@ module Itsi
     extend RouteTester
 
     class << self
-
       def running?
-        !!@running
+        @running && !@running.empty?
       end
 
       def start_in_background_thread(cli_params = {}, &blk)
-        @background_thread = start(cli_params, background: true, &blk)
+        @background_threads ||= []
+        server, background_thread = start(cli_params, background: true, &blk)
+        @background_threads << background_thread
+        server
       end
 
       def start(cli_params, background: false, &blk)
         itsi_file = Itsi::Server::Config.config_file_path(cli_params[:config_file])
+        Itsi.log_debug "Constructing server #{cli_params}: #{itsi_file}"
         server = new(cli_params, itsi_file, blk)
         previous_handler = Signal.trap(:INT, :DEFAULT)
         run = lambda do
-          @running = server
+          @running ||= []
+          @running << server
 
           if cli_params[:daemonize]
             Itsi.log_info("Itsi is running in the background. Writing pid to #{Itsi::Server::Config.pid_file_path}")
@@ -47,13 +54,15 @@ module Itsi
           end
           write_pid
 
+          Itsi.log_info "Starting Itsi..."
           server.start
-          @running = nil
+          @running.delete(server)
           Signal.trap(:INT, previous_handler)
           server
         end
-        background ? Thread.new(&run) : run[]
-      rescue
+        background ? [server, Thread.new(&run)] : run[]
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        Itsi.log_error e.message
       end
 
       def static(cli_params)
@@ -61,7 +70,8 @@ module Itsi
       end
 
       def stop
-        return unless pid = get_pid
+        return unless (pid = get_pid)
+
         Process.kill(:INT, pid)
         i = 0
         while i < 10
@@ -74,16 +84,18 @@ module Itsi
         end
       end
 
-      def stop_background_thread
-        @running&.stop
-        @background_thread&.join
+      def stop_background_threads
+        @running && @running.each(&:stop)
+        @background_threads&.each(&:join)
+        @background_threads = []
+        @running = []
       end
 
       def write_pid
         File.write(Itsi::Server::Config.pid_file_path, Process.pid)
       end
 
-      def get_pid(warn=true)
+      def get_pid(warn = true)
         pid = File.read(Itsi::Server::Config.pid_file_path).to_i
         if Process.kill(0, pid)
           pid
@@ -97,7 +109,7 @@ module Itsi
       end
 
       def test
-        Itsi::Server::Config.test!(cli_params = {})
+        Itsi::Server::Config.test!({})
       end
 
       def init
@@ -105,25 +117,25 @@ module Itsi
       end
 
       def reload
-        return unless pid = get_pid
+        return unless (pid = get_pid)
 
         Process.kill(:HUP, pid)
       end
 
       def restart
-        return unless pid = get_pid
+        return unless (pid = get_pid)
 
         Process.kill(:USR1, pid)
       end
 
       def passfile(options, subcmd)
         filename = options[:passfile]
-        unless filename
+        unless filename || subcmd == "echo"
           puts "Error: passfile not set. Use --passfile option to provide a path to a file containing hashed credentials."
           puts "This file contains hashed credentials and should not be included in source control without additional protection."
           exit(1)
         end
-        algorithm = options.fetch(:algorithm, 'sha256')
+        algorithm = options.fetch(:algorithm, "sha256")
 
         unless %w[sha256 sha512 bcrypt argon2 none].include?(algorithm)
           puts "Invalid algorithm"
@@ -131,9 +143,9 @@ module Itsi
         end
 
         case subcmd
-        when 'add', 'echo'
+        when "add", "echo"
           Passfile.send(subcmd, filename, algorithm)
-        when 'remove', 'list'
+        when "remove", "list"
           Passfile.send(subcmd, filename)
         else
           puts "Valid subcommands are: add | remove | list"
@@ -141,31 +153,104 @@ module Itsi
         end
       end
 
+      def unique_path(dir, filename)
+        base = File.basename(filename, ".*")
+        ext  = File.extname(filename)
+        candidate = File.join(dir, filename)
+        return candidate unless File.exist?(candidate)
+
+        i = 1
+        loop do
+          new_name = "#{base}_#{i}#{ext}"
+          candidate = File.join(dir, new_name)
+          return candidate unless File.exist?(candidate)
+
+          i += 1
+        end
+      end
+
+      def save_or_print(filename, content, options)
+        if options[:save_dir]
+          FileUtils.mkdir_p(options[:save_dir])
+          path = unique_path(options[:save_dir], filename)
+          File.write(path, content)
+          puts "Written to #{path}"
+        else
+          puts content
+        end
+      end
+
+      def secret(options)
+        require "openssl"
+        require "base64"
+
+        puts "Enter algorithm (one of: HS256, HS384, HS512, RS256, RS384, RS512, PS256, PS384, PS512, ES256, ES384):"
+        alg = $stdin.gets.chomp.upcase
+
+        case alg
+        when /^HS(\d+)$/
+          bits = ::Regexp.last_match(1).to_i
+          bytes = bits / 8
+          key = SecureRandom.random_bytes(bytes)
+          pem = Base64.strict_encode64(key)
+          content = "=== HMAC #{bits}-bit Secret (base64) ===\n#{pem}\n"
+          save_or_print("hmac_#{bits}_secret.txt", content, options)
+
+        when /^RS/, /^PS/
+          rsa = OpenSSL::PKey::RSA.new(2048)
+          priv = rsa.to_pem
+          pub  = rsa.public_key.to_pem
+          save_or_print("rsa_private.pem", "=== RSA Private Key ===\n#{priv}", options)
+          save_or_print("rsa_public.pem",  "=== RSA Public Key ===\n#{pub}", options)
+
+        when "ES256", "ES384"
+          curve = (alg == "ES256" ? "prime256v1" : "secp384r1")
+          ec = OpenSSL::PKey::EC.new(curve)
+          ec.generate_key
+          priv = ec.to_pem
+          pub_ec = ec.dup
+          pub_ec.private_key = nil
+          pub = pub_ec.to_pem
+          save_or_print("ecdsa_private.pem", "=== ECDSA Private Key ===\n#{priv}", options)
+          save_or_print("ecdsa_public.pem",  "=== ECDSA Public Key ===\n#{pub}", options)
+
+        else
+          warn "Unsupported algorithm: #{alg}"
+          exit 1
+        end
+      end
+
       def add_worker
-        return unless pid = get_pid
+        return unless (pid = get_pid)
 
         Process.kill(:TTIN, pid)
       end
 
       def remove_worker
-        return unless pid = get_pid
+        return unless (pid = get_pid)
 
         Process.kill(:TTOU, pid)
       end
 
       def status
-        return unless pid = get_pid
+        return unless (pid = get_pid)
+
         Itsi.log_info("Itsi running on #{pid}")
         Process.kill(:USR2, pid)
       end
 
       def load_route_middleware_stack(cli_params)
-        Config.build_config(cli_params, Itsi::Server::Config.config_file_path(cli_params[:config_file_path]))[
-          "middleware_loader"
-          ][]
+        middleware, errors = Config.build_config(cli_params,
+                                                 Itsi::Server::Config.config_file_path(cli_params[:config_file_path]))
+        if errors.any?
+          puts errors
+          []
+        else
+          middleware["middleware_loader"][]
+        end
       end
 
-      def test_route(cli_params = {}, route_str)
+      def test_route(cli_params, route_str)
         matched_route = load_route_middleware_stack(cli_params).find do |route|
           route["route"] =~ route_str
         end
@@ -187,7 +272,6 @@ module Itsi
       end
 
       alias serve start
-
     end
   end
 end