aspera-cli 4.26.2 → 4.27.1

data/lib/aspera/keychain/one_password_cli.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'aspera/environment'
+require 'aspera/keychain/one_password_base'
+require 'json'
+
+module Aspera
+  module Keychain
+    # Manage secrets using the 1Password CLI (`op`)
+    # https://developer.1password.com/docs/cli/
+    class OnePasswordCli < Base
+      include OnePasswordBase
+
+      OP_EXECUTABLE = 'op'
+      private_constant :OP_EXECUTABLE
+
+      # @param vault   [String, nil] Name or ID of the 1Password vault (optional, uses default vault if omitted)
+      # @param account [String, nil] Account shorthand for `op` (optional, uses default account if omitted)
+      def initialize(vault: nil, account: nil)
+        super()
+        @vault   = vault
+        @account = account
+      end
+
+      def info
+        h = {}
+        h[:vault]   = @vault   unless @vault.nil?
+        h[:account] = @account unless @account.nil?
+        h
+      end
+
+      def all
+        items = op_json('item', 'list', '--categories', ITEM_CATEGORY)
+        return items.map do |item|
+          item_to_secret(op_json('item', 'get', item['id'])).merge(id: item['id'])
+        end
+      end
+
+      def ids
+        op_json('item', 'list', '--categories', ITEM_CATEGORY).map { |item| {id: item['id'], label: item['title']} }
+      end
+
+      def set(options)
+        validate_set(options)
+        args = ['item', 'create', '--category', ITEM_CATEGORY, "--title=#{options[:label]}"]
+        args << "#{FIELD_USERNAME}=#{options[:username]}"           if options[:username]
+        args << "#{FIELD_PASSWORD}[password]=#{options[:password]}" if options[:password]
+        args << "#{FIELD_URL}[url]=#{options[:url]}"                if options[:url]
+        args << "#{FIELD_NOTES_ID}=#{options[:description]}"        if options[:description]
+        op_run(*args)
+        nil
+      end
+
+      def get(label:, id: nil, exception: true)
+        identifier = id || label
+        stdout, _stderr, status = op_capture('item', 'get', identifier, '--format=json')
+        if !status.success?
+          raise "Secret '#{label}' not found" if exception
+          return
+        end
+        full = JSON.parse(stdout)
+        return item_to_secret(full).merge(id: full['id'])
+      end
+
+      def delete(label:, id: nil)
+        op_run('item', 'delete', id || label)
+        nil
+      end
+
+      private
+
+      def common_flags
+        flags = []
+        flags.push('--vault',   @vault)   unless @vault.nil?
+        flags.push('--account', @account) unless @account.nil?
+        flags
+      end
+
+      def op_json(*args)
+        stdout, = op_capture(*args, '--format=json', exception: true)
+        JSON.parse(stdout)
+      end
+
+      def op_run(*args)
+        op_capture(*args, exception: true)
+        nil
+      end
+
+      def op_capture(*args, exception: true)
+        Environment.instance.class.secure_execute(
+          OP_EXECUTABLE, *args, *common_flags,
+          mode: :capture,
+          exception: exception
+        )
+      end
+    end
+  end
+end

data/lib/aspera/link_header.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'strscan'
+
+module Aspera
+  # Parse and represent an HTTP Link header as per RFC 8288.
+  # Inspired by the link_header gem, with the following fixes:
+  #   - rel lookup is case-insensitive (RFC 7230: parameter names are case-insensitive)
+  #   - uses StringScanner so commas inside <URI> are never mistaken for entry separators
+  #   - no external dependency
+  class LinkHeader
+    # A single link entry: one URI and its attribute pairs.
+    class Link
+      attr_reader :href, :attr_pairs
+
+      def initialize(href, attr_pairs)
+        @href = href
+        @attr_pairs = attr_pairs
+      end
+
+      # Retrieve an attribute value by name, case-insensitively.
+      def [](key)
+        pair = @attr_pairs.detect { |k, _v| k.casecmp?(key) }
+        pair&.last
+      end
+    end
+
+    attr_reader :links
+
+    def initialize(links = [])
+      @links = links
+    end
+
+    # Return the href of the first link whose +rel+ attribute matches +rel+.
+    # Comparison is case-insensitive per RFC 7230 s.3.2 and RFC 8288 s.3.
+    # Returns nil if no link with that relation exists.
+    # @param rel [String]
+    # @return [String, nil]
+    def find_href(rel: 'next')
+      @links.detect { |link| link['rel']&.casecmp?(rel) }&.href
+    end
+
+    class << self
+      # Parse a raw Link header value into a +LinkHeader+ instance.
+      # Uses StringScanner so that commas inside <URI> are not treated as separators.
+      # @param raw [String, nil]
+      # @return [LinkHeader]
+      def parse(raw)
+        return new unless raw && !raw.empty?
+
+        links = []
+        scanner = StringScanner.new(raw)
+
+        while scanner.scan(HREF_RE)
+          href  = scanner[1].strip
+          attrs = []
+          while scanner.scan(ATTR_RE)
+            key   = scanner[1]
+            # scanner[2] = full match (token or "quoted"), scanner[3] = content inside double-quotes
+            value = scanner[3] || scanner[2]
+            attrs << [key, value]
+            break unless scanner.scan(SEMI_RE)
+          end
+          links << Link.new(href, attrs)
+          break unless scanner.scan(COMMA_RE)
+        end
+
+        new(links)
+      end
+
+      private :new
+    end
+
+    # RFC 2616 token: any char except separators
+    TOKEN_RE  = /[^()<>@,;:\"\[\]?={}\s]+/  # RFC 2616 token
+    QUOTED_RE = /"((?:[^"\\]|\\.)*)"/       # double-quoted string with backslash escapes
+    HREF_RE   = /\s*<([^>]*)>\s*;?\s*/      # <URI> possibly followed by ;
+    ATTR_RE   = /(#{TOKEN_RE})\s*=\s*(#{TOKEN_RE}|#{QUOTED_RE})\s*/ # key=value or key="value"
+    SEMI_RE   = /;\s*/                       # parameter separator
+    COMMA_RE  = /,\s*/                       # link entry separator
+  end
+end

data/lib/aspera/log.rb

@@ -20,13 +20,13 @@ class Logger
 
   # Add custom level to logger severity, below debug level
   module Severity
-    1.upto(TRACE_MAX).each{ |level| const_set(:"TRACE#{level}", - level)}
+    1.upto(TRACE_MAX).each { |level| const_set(:"TRACE#{level}", - level) }
   end
 
   # Hash
   # key   [Integer] Log level (e.g. 0 for DEBUG)
   # value [Symbol]  Uppercase log level label (e.g. :DEBUG)
-  SEVERITY_LABEL = Severity.constants.to_h{ |name| [Severity.const_get(name), name]}
+  SEVERITY_LABEL = Severity.constants.to_h { |name| [Severity.const_get(name), name] }
 
   # Override
   # @param severity [Integer] Log severity as int
@@ -36,17 +36,20 @@ class Logger
   end
 
   class << self
-    # Define methods for a given log level
+    # Define logger methods for a given log level (e.g. `debug`, `debug?`, `debug!`)
+    # @param str_level [String] Log level name (e.g. "DEBUG", "TRACE1")
+    # @return [nil]
     def make_methods(str_level)
       int_level = ::Logger.const_get(str_level.upcase)
       method_base = str_level.downcase
-      define_method(method_base, ->(message = nil, &block){add(int_level, message, &block)})
-      define_method("#{method_base}?", ->{level <= int_level})
-      define_method("#{method_base}!", ->{self.level = int_level})
+      define_method(method_base, ->(message = nil, &block) { add(int_level, message, &block) })
+      define_method("#{method_base}?", -> { level <= int_level })
+      define_method("#{method_base}!", -> { self.level = int_level })
+      nil
     end
   end
   # Declare methods for all levels
-  Logger::Severity.constants.each{ |severity| make_methods(severity)}
+  Logger::Severity.constants.each { |severity| make_methods(severity) }
 end
 
 # Restore warnings
@@ -65,7 +68,7 @@ module Aspera
     LOG_TYPES = %i[stderr stdout syslog].freeze
 
     # Levels are :trace2,:trace1,:debug,:info,:warn,:error,fatal,:unknown
-    LEVELS = Logger::Severity.constants.sort{ |a, b| Logger::Severity.const_get(a) <=> Logger::Severity.const_get(b)}.map{ |c| c.downcase.to_sym}.freeze
+    LEVELS = Logger::Severity.constants.sort { |a, b| Logger::Severity.const_get(a) <=> Logger::Severity.const_get(b) }.map { |c| c.downcase.to_sym }.freeze
 
     # Class methods
     class << self
@@ -97,7 +100,7 @@ module Aspera
             JSON.pretty_generate(object) rescue PP.pp(object, +'')
           when :ruby
             PP.pp(object, +'')
-          else Aspera.error_unexpected_value(instance.dump_format){'dump format'}
+          else Aspera.error_unexpected_value(instance.dump_format) { 'dump format' }
           end
         "#{name.to_s.green}(#{instance.dump_format})#{object.class}=\n#{dump_text}"
       end
@@ -116,7 +119,7 @@ module Aspera
       # Returns the last 2 containers (module/class) and method caller
       def caller_method
         stack = caller
-        i = stack.rindex{ |line| line.include?('Logger')}
+        i = stack.rindex { |line| line.include?('Logger') }
         frame = stack[i + 1] if i && stack[i + 1]
         return '???' unless frame
         # Extract the "Class::Module::Method" or "Class#method" part
@@ -142,9 +145,13 @@ module Aspera
     attr_reader :logger_type, :logger
     attr_accessor :dump_format
 
+    # Set the program name used in log output
+    # @param value [String] Program name
+    # @return [nil]
     def program_name=(value)
       @program_name = value
       self.logger_type = @logger_type
+      nil
     end
 
     # Set log level of underlying logger given symbol level
@@ -154,15 +161,19 @@ module Aspera
       @logger.level = Logger::Severity.const_get(new_level.to_sym.upcase)
     end
 
+    # Set log formatter; accepts a symbol name, a Proc, or a Logger::Formatter instance
+    # @param formatter [String, Proc, Logger::Formatter] Formatter to use; one of: standard, default, caller
+    # @return [nil]
     def formatter=(formatter)
       if formatter.is_a?(String)
-        raise Error, "Unknown formatter #{formatter}, use one of: #{FORMATTERS.join(', ')}" unless FORMATTER_LAMBDAS.key?(formatter.to_sym)
+        Aspera.assert(FORMATTER_LAMBDAS.key?(formatter.to_sym), type: Error) { "Unknown formatter #{formatter}, use one of: #{FORMATTERS.join(', ')}" }
         formatter = FORMATTER_LAMBDAS[formatter.to_sym]
       elsif !formatter.respond_to?(:call) && !formatter.is_a?(Logger::Formatter)
         raise Error, 'Formatter must be a String, a Logger::Formatter or a Proc'
       end
       # Update formatter with password hiding
       @logger.formatter = SecretHider.instance.log_formatter(formatter)
+      nil
     end
 
     def formatter
@@ -176,7 +187,9 @@ module Aspera
       Logger::SEVERITY_LABEL[@logger.level].downcase
     end
 
-    # Change underlying logger, but keep log level (default: INFO)
+    # Change underlying logger output destination, keeping current log level
+    # @param new_log_type [Symbol] Log destination; one of LOG_TYPES (:stderr, :stdout, :syslog)
+    # @return [nil]
     def logger_type=(new_log_type)
       # [Integer]
       current_severity_integer = @logger&.level || ENV['AS_LOG_LEVEL']&.to_i || Logger::Severity::INFO
@@ -197,12 +210,13 @@ module Aspera
         end
         # Use `local2` facility, like other Aspera components
         @logger = Syslog::Logger.new(@program_name, Syslog::LOG_LOCAL2)
-      else Aspera.error_unexpected_value(new_log_type){"log type (#{LOG_TYPES.join(', ')})"}
+      else Aspera.error_unexpected_value(new_log_type) { "log type (#{LOG_TYPES.join(', ')})" }
       end
       @logger.level = current_severity_integer
       @logger_type = new_log_type
       # add secret hider to default logger
       self.formatter = @logger.formatter
+      nil
     end
 
     private
@@ -233,13 +247,13 @@ module Aspera
       [k, short_levl(k).apply(*v)]
     end.freeze
 
-    DEFAULT_FORMATTER = ->(s, _d, _p, m){"#{LVL_COLOR[s]} #{m}\n"}
+    DEFAULT_FORMATTER = ->(s, _d, _p, m) { "#{LVL_COLOR[s]} #{m}\n" }
 
     # pre-defined formatters
     FORMATTER_LAMBDAS = {
       standard: Logger::Formatter.new,
       default:  DEFAULT_FORMATTER,
-      caller:   ->(s, _d, _p, m){"#{LVL_COLOR[s]} #{Log.caller_method}\n#{m}\n"}
+      caller:   ->(s, _d, _p, m) { "#{LVL_COLOR[s]} #{Log.caller_method}\n#{m}\n" }
     }.freeze
 
     FORMATTERS = FORMATTER_LAMBDAS.keys

data/lib/aspera/markdown.rb

@@ -9,45 +9,128 @@ module Aspera
 
     class << self
       COL_WIDTH = 80
+
+      # Convert a Markdown heading text to a GitHub-flavoured anchor.
+      # Rules: downcase, keep letters/digits/spaces/hyphens, replace spaces with hyphens.
+      # Duplicate anchors are disambiguated by appending -1, -2, … (pass a seen Hash to track).
+      # @param text  [String]           raw heading text (without leading # and spaces)
+      # @param seen  [Hash{String=>Integer}, nil]  mutable counter; pass the same Hash across a document
+      # @return [String] anchor slug (without leading #)
+      def heading_to_anchor(text, seen: nil)
+        slug = text
+          .downcase
+          .gsub(/[`*_]/, '')           # strip inline code/bold/italic markers
+          .gsub(/&[a-z]+;/, '')        # strip HTML entities
+          .gsub(/[^\w\s-]/, '')        # keep word chars, spaces, hyphens
+          .gsub(/\s+/, '-')            # spaces → hyphens
+          .squeeze('-')                # collapse consecutive hyphens
+          .strip
+        if seen
+          count = seen[slug].to_i
+          seen[slug] = count + 1
+          slug = "#{slug}-#{count}" if count > 0
+        end
+        slug
+      end
+
+      # Extract the table of contents from a Markdown document.
+      # @param content [String]  full Markdown source
+      # @return [Array<Hash>]   array of { level, title, anchor }
+      HEADING_RE = /^(\#{1,6})\s+(.+)$/
+
+      def toc(content)
+        seen = {}
+        content.each_line.filter_map do |line|
+          m = line.match(HEADING_RE)
+          next unless m
+          title = m[2].strip
+          {level: m[1].length, title: title, anchor: heading_to_anchor(title, seen: seen)}
+        end
+      end
+
+      # Extract the content of a single section (heading + body until next heading of same/higher level).
+      # @param content   [String]  full Markdown source
+      # @param anchor    [String]  GitHub anchor slug (without #)
+      # @return [String, nil]  the section content, or nil if not found
+      def extract_section(content, anchor)
+        seen = {}
+        section_level = nil
+        result = []
+        content.each_line do |line|
+          m = line.match(HEADING_RE)
+          if m
+            slug = heading_to_anchor(m[2].strip, seen: seen)
+            if section_level.nil?
+              # not yet found: check if this heading matches
+              next unless slug == anchor
+              section_level = m[1].length
+            elsif m[1].length <= section_level
+              # already in section: stop at same/higher level heading
+              break
+            end
+          end
+          result << line if section_level
+        end
+        result.empty? ? nil : result.join
+      end
+
       # Generate markdown from the provided 2D table
       # @param table [Array<Array<String>>] 2D array of strings
       # @return [String] markdown table
       def table(table)
         # get max width of each columns
         col_widths = table.transpose.map do |col|
-          [col.flat_map{ |c| c.to_s.delete('`').split(HTML_BREAK).map(&:size)}.max, COL_WIDTH].min
+          [col.flat_map { |c| c.to_s.delete('`').split(HTML_BREAK).map(&:size) }.max, COL_WIDTH].min
         end
         headings = table.shift
-        table.unshift(col_widths.map{ |col_width| '-' * col_width})
+        table.unshift(col_widths.map { |col_width| '-' * col_width })
         table.unshift(headings)
-        lines = table.map{ |line| "| #{line.map{ |i| i.to_s.gsub('\\', '\\\\').gsub('|', '\|')}.join(' | ')} |\n"}
+        lines = table.map { |line| "| #{line.map { |i| i.to_s.gsub('\\', '\\\\').gsub('|', '\|') }.join(' | ')} |\n" }
         lines[1] = lines[1].tr(' ', '-')
         return lines.join.chomp
       end
 
       # Generate markdown list from the provided list
+      # @param items [Array<String>] list of items
+      # @return [String] markdown unordered list
       def list(items)
-        items.map{ |i| "- #{i}"}.join("\n")
+        items.map { |i| "- #{i}" }.join("\n")
       end
 
+      # Generate a markdown heading
+      # @param title [String] heading text
+      # @param level [Integer] heading level (1–6)
+      # @return [String] markdown heading
       def heading(title, level: 1)
         "#{'#' * level} #{title}\n\n"
       end
 
-      # type: NOTE CAUTION WARNING IMPORTANT TIP INFO
+      # Generate a GitHub-flavoured admonition block
+      # @param lines [Array<String>] lines of the admonition body
+      # @param type [String] admonition type: NOTE, CAUTION, WARNING, IMPORTANT, TIP, INFO
+      # @return [String] markdown admonition block
       def admonition(lines, type: 'INFO')
-        "> [!#{type}]\n#{lines.map{ |l| "> #{l}"}.join("\n")}\n\n"
+        "> [!#{type}]\n#{lines.map { |l| "> #{l}" }.join("\n")}\n\n"
       end
 
+      # Generate a fenced code block
+      # @param lines [Array<String>] lines of code
+      # @param type [String] language identifier for syntax highlighting
+      # @return [String] markdown fenced code block
       def code(lines, type: 'shell')
         "```#{type}\n#{lines.join("\n")}\n```\n\n"
       end
 
-      # inline code
+      # Wrap text in inline code backticks
+      # @param text [String] text to wrap
+      # @return [String] inline code span
       def icode(text)
         "`#{text}`"
       end
 
+      # Wrap text in a markdown paragraph (trailing blank line)
+      # @param text [String] paragraph content
+      # @return [String] paragraph with trailing newlines
       def paragraph(text)
         "#{text}\n\n"
       end

data/lib/aspera/nagios.rb

@@ -17,7 +17,7 @@ module Aspera
     # add methods to add nagios error levels, each take component name and message
     LEVELS.each_index do |code|
       name = "#{ADD_PREFIX}#{LEVELS[code]}".to_sym
-      define_method(name){ |comp, msg| @data.push({code: code, comp: comp, msg: msg})}
+      define_method(name) { |comp, msg| @data.push({code: code, comp: comp, msg: msg}) }
     end
 
     class << self
@@ -26,18 +26,18 @@ module Aspera
         Aspera.assert_type(data, Array)
         Aspera.assert(!data.empty?, 'data is empty')
         %w[status component message].each do |c|
-          Aspera.assert(data.first.key?(c)){"result must have #{c}"}
+          Aspera.assert(data.first.key?(c)) { "result must have #{c}" }
         end
-        res_errors = data.reject{ |s| s['status'].eql?('ok')}
+        res_errors = data.reject { |s| s['status'].eql?('ok') }
         # keep only errors in case of problem, other ok are assumed so
         data = res_errors unless res_errors.empty?
         # first is most critical
-        data.sort!{ |a, b| LEVELS.index(a['status'].to_sym) <=> LEVELS.index(b['status'].to_sym)}
+        data.sort! { |a, b| LEVELS.index(a['status'].to_sym) <=> LEVELS.index(b['status'].to_sym) }
         # build message: if multiple components: concatenate
         # message = data.map{|i|"#{i['component']}:#{i['message']}"}.join(', ').gsub("\n",' ')
         message = data
-          .group_by{ |d| d['component']}
-          .map{ |comp, items| "#{comp}:#{items.map{ |d| d['message']}.join(',')}"}
+          .group_by { |d| d['component'] }
+          .map { |comp, items| "#{comp}:#{items.map { |d| d['message'] }.join(',')}" }
           .join(', ')
           .tr("\n", ' ')
         status = data.first['status'].upcase
@@ -60,7 +60,7 @@ module Aspera
       remote_time = Time.parse(remote_date)
       diff_time = (remote_time - Time.now).abs
       diff_rounded = diff_time.round(-2)
-      Log.log.debug{"DATE: #{remote_date} #{remote_time} diff=#{diff_rounded}"}
+      Log.log.debug { "DATE: #{remote_date} #{remote_time} diff=#{diff_rounded}" }
       msg = "offset #{diff_rounded} sec"
       if diff_time >= DATE_CRIT_OFFSET
         add_critical(component, msg)
@@ -80,7 +80,7 @@ module Aspera
     # @return [Array] of Hash
     def status_list
       Aspera.assert(!@data.empty?, 'missing result')
-      @data.map{ |i| {'status' => LEVELS[i[:code]].to_s, 'component' => i[:comp], 'message' => i[:msg]}}
+      @data.map { |i| {'status' => LEVELS[i[:code]].to_s, 'component' => i[:comp], 'message' => i[:msg]} }
     end
   end
 end

data/lib/aspera/node_simulator.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'aspera/assert'
 require 'aspera/ascp/installation'
 require 'aspera/agent/direct'
 require 'aspera/log'
@@ -9,7 +10,7 @@ require 'json'
 module Aspera
   class NodeSimulator
     def initialize
-      @agent = Agent::Direct.new(management_cb: ->(event){process_event(event)})
+      @agent = Agent::Direct.new(management_cb: ->(event) { process_event(event) })
       @sessions = {}
     end
 
@@ -18,7 +19,7 @@ module Aspera
     end
 
     def all_sessions
-      @agent.sessions.map{ |session| session[:job_id]}.uniq.each.map{ |job_id| job_to_transfer(job_id)}
+      @agent.sessions.map { |session| session[:job_id] }.uniq.each.map { |job_id| job_to_transfer(job_id) }
     end
 
     # status: ('waiting', 'partially_completed', 'unknown', 'waiting(read error)',] 'running', 'completed', 'failed'
@@ -128,28 +129,29 @@ module Aspera
 
     # Process event from management port
     def process_event(event)
+      # Code duplicated on purpose, as implementation goes, blocks will be replaced
       case event['Type']
-      when 'NOP' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'NOP' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
       # rubocop:disable Lint/DuplicateBranch
-      when 'START' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
-      when 'QUERY' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
-      when 'QUERYRSP' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
-      when 'STATS' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
-      when 'STOP' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
-      when 'ERROR' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
-      when 'CANCEL' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
-      when 'DONE' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
-      when 'RATE' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
-      when 'FILEERROR' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
-      when 'SESSION' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
-      when 'NOTIFICATION' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
-      when 'INIT' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
-      when 'VLINK' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
-      when 'PUT' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
-      when 'WRITE' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
-      when 'CLOSE' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
-      when 'SKIP' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
-      when 'ARGSTOP' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'START' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
+      when 'QUERY' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
+      when 'QUERYRSP' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
+      when 'STATS' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
+      when 'STOP' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
+      when 'ERROR' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
+      when 'CANCEL' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
+      when 'DONE' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
+      when 'RATE' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
+      when 'FILEERROR' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
+      when 'SESSION' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
+      when 'NOTIFICATION' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
+      when 'INIT' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
+      when 'VLINK' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
+      when 'PUT' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
+      when 'WRITE' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
+      when 'CLOSE' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
+      when 'SKIP' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
+      when 'ARGSTOP' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
       # rubocop:enable Lint/DuplicateBranch
       else Aspera.error_unreachable_line
       end
@@ -162,19 +164,25 @@ module Aspera
     PATH_TRANSFERS = '/ops/transfers'
     PATH_ONE_TRANSFER = %r{/ops/transfers/(.+)$}
     PATH_BROWSE = '/files/browse'
-    # @param app_api [Api::AoC]
-    # @param app_context [String]
+    # @param credentials [Hash]
+    # @param simulator   [NodeSimulator]
     def initialize(server, credentials, simulator)
       super(server)
       @credentials = credentials
       @simulator = simulator
+      # Resolve once at startup; default to current working directory
+      @browse_root = File.realpath(credentials[:browse_root] || Dir.pwd)
     end
 
     require 'json'
     require 'time'
 
     def folder_to_structure(folder_path)
-      raise "Path does not exist or is not a directory: #{folder_path}" unless Dir.exist?(folder_path)
+      # Resolve and confine to browse_root (prevents path traversal via client-supplied path)
+      resolved = File.realpath(folder_path)
+      Aspera.assert(resolved.start_with?("#{@browse_root}/") || resolved.eql?(@browse_root)) { 'Browse path traversal attempt detected' }
+      Aspera.assert(Dir.exist?(resolved)) { "Path does not exist or is not a directory: #{resolved}" }
+      folder_path = resolved
 
       # Build self structure
       folder_stat = File.stat(folder_path)
@@ -240,7 +248,7 @@ module Aspera
       when PATH_BROWSE
         req = JSON.parse(request.body)
         # req['count']
-        set_json_response(request, response, folder_to_structure(req['path']))
+        set_json_response(request, response, folder_to_structure(req['path'] || @browse_root))
       else
         set_json_response(request, response, [{error: 'Bad request'}], code: 400)
       end
@@ -330,7 +338,7 @@ module Aspera
       response.status = code
       response['Content-Type'] = Mime::JSON
       response.body = json.to_json
-      Log.log.trace1{Log.obj_dump("response for #{request.request_method} #{request.path}", json)}
+      Log.log.trace1 { Log.obj_dump("response for #{request.request_method} #{request.path}", json) }
     end
   end
 end