pwn 0.5.685 → 0.5.686

data/lib/pwn/ai/open_ai.rb

@@ -544,114 +544,6 @@ module PWN
         raise e
       end
 
-      # Supported Method Parameters::
-      # usage = PWN::AI::OpenAI.get_plan_usage(
-      #   timeout: 'optional - seconds (default 8)'
-      # )
-      #
-      # Subscription / billing usage for the PS1 percent suffix.
-      # Tries (1) dashboard billing hard-limit vs month-to-date spend,
-      # then (2) Admin organization costs. Returns {available:false}
-      # when neither yields used+limit (never prompts for credentials).
-      public_class_method def self.get_plan_usage(opts = {})
-        timeout = opts[:timeout] || 8
-        return { available: false, engine: :openai } unless plan_usage_credentials?
-
-        now = Time.now.utc
-        start_of_month = Time.utc(now.year, now.month, 1)
-
-        sub = parse_plan_usage_json(
-          raw: open_ai_rest_call(
-            rest_call: 'dashboard/billing/subscription',
-            timeout: timeout,
-            spinner: false,
-            quiet: true,
-            non_interactive: true
-          )
-        )
-        usage = parse_plan_usage_json(
-          raw: open_ai_rest_call(
-            rest_call: 'dashboard/billing/usage',
-            params: {
-              start_date: start_of_month.strftime('%Y-%m-%d'),
-              end_date: now.strftime('%Y-%m-%d')
-            },
-            timeout: timeout,
-            spinner: false,
-            quiet: true,
-            non_interactive: true
-          )
-        )
-
-        if sub.is_a?(Hash) && usage.is_a?(Hash)
-          limit_usd = (
-            sub[:hard_limit_usd] ||
-            sub[:system_hard_limit_usd] ||
-            sub[:soft_limit_usd] ||
-            sub[:system_soft_limit_usd]
-          ).to_f
-          used_usd = usage[:total_usage].to_f / 100.0
-          normalized = PWN::AI.normalize_plan_usage(
-            used: used_usd,
-            limit: limit_usd,
-            source: 'dashboard/billing',
-            engine: :openai
-          )
-          return normalized if normalized[:available]
-        end
-
-        costs = parse_plan_usage_json(
-          raw: open_ai_rest_call(
-            rest_call: 'organization/costs',
-            params: { start_time: start_of_month.to_i },
-            timeout: timeout,
-            spinner: false,
-            quiet: true,
-            non_interactive: true
-          )
-        )
-        if costs.is_a?(Hash)
-          spent = Array(costs[:data]).sum do |row|
-            amt = row.is_a?(Hash) ? (row[:amount] || row[:results] || {}) : {}
-            if amt.is_a?(Hash)
-              (amt[:value] || amt[:amount] || 0).to_f
-            else
-              amt.to_f
-            end
-          end
-          limit_usd = sub.is_a?(Hash) ? (sub[:hard_limit_usd] || sub[:system_hard_limit_usd]).to_f : 0.0
-          normalized = PWN::AI.normalize_plan_usage(
-            used: spent,
-            limit: limit_usd,
-            source: 'organization/costs',
-            engine: :openai
-          )
-          return normalized if normalized[:available]
-        end
-
-        { available: false, engine: :openai }
-      rescue StandardError
-        { available: false, engine: :openai }
-      end
-
-      private_class_method def self.plan_usage_credentials?
-        engine = PWN::Env.dig(:ai, :openai) || {}
-        oauth = engine[:oauth].is_a?(Hash) ? engine[:oauth] : {}
-        real_config_value?(value: engine[:key]) ||
-          real_config_value?(value: oauth[:bearer_token]) ||
-          real_config_value?(value: oauth[:refresh_token])
-      end
-
-      private_class_method def self.parse_plan_usage_json(opts = {})
-        raw = opts[:raw]
-        return nil if raw.nil?
-
-        parsed = JSON.parse(raw.to_s, symbolize_names: true)
-        parsed.is_a?(Hash) ? parsed : nil
-      rescue JSON::ParserError, TypeError
-        nil
-      end
-
       # Supported Method Parameters::
       # response = PWN::AI::OpenAI.chat_with_tools(
       #   messages: 'required - full OpenAI-format messages array (system/user/assistant/tool)',
@@ -1287,8 +1179,6 @@ module PWN
         puts "USAGE:
           models = #{self}.get_models
 
-          usage = #{self}.get_plan_usage
-
           # One-time ChatGPT/Codex OAuth enrollment (device-code flow):
           bearer = #{self}.obtain_oauth_bearer_token
           # Subsequent runs silently refresh via ai.openai.oauth.refresh_token

data/lib/pwn/ai/open_web_ui.rb

@@ -413,16 +413,6 @@ module PWN
         raise e
       end
 
-      # Supported Method Parameters::
-      # usage = PWN::AI::OpenWebUI.get_plan_usage
-      #
-      # Open WebUI is a local gateway with no subscription / plan-usage
-      # endpoint. Always unavailable so the PS1 shows the infinity glyph.
-      public_class_method def self.get_plan_usage(opts = {})
-        _unused = opts
-        { available: false, engine: :openwebui, unlimited: true }
-      end
-
       # Coerce OpenAI-wire message history into Ollama-native shapes before
       # POST /api/chat (or Open WebUI /ollama/api/chat):
       # - function.arguments must be a Hash/Array object, not a JSON string
@@ -693,8 +683,6 @@ module PWN
         puts "USAGE:
           models = #{self}.get_models
 
-          usage = #{self}.get_plan_usage
-
           response = #{self}.chat(
             request: 'required - message to Open WebUI',
             model: 'optional - model to use for text generation (defaults to PWN::Env[:ai][:openwebui][:model])',

data/lib/pwn/ai.rb

@@ -14,92 +14,6 @@ module PWN
     autoload :OpenWebUI, 'pwn/ai/open_web_ui'
     autoload :RedTeam, 'pwn/ai/red_team'
 
-    PLAN_USAGE_CACHE_TTL = 60
-    PLAN_USAGE_INFINITY = "\u221E"
-    ENGINE_MODULES = {
-      openai: 'PWN::AI::OpenAI',
-      grok: 'PWN::AI::Grok',
-      ollama: 'PWN::AI::Ollama',
-      openwebui: 'PWN::AI::OpenWebUI',
-      anthropic: 'PWN::AI::Anthropic',
-      gemini: 'PWN::AI::Gemini'
-    }.freeze
-
-    # Supported Method Parameters::
-    # usage = PWN::AI.normalize_plan_usage(
-    #   used: 'required - numeric used amount',
-    #   limit: 'required - numeric limit / allowance',
-    #   source: 'optional - endpoint / origin label',
-    #   engine: 'optional - engine symbol'
-    # )
-    public_class_method def self.normalize_plan_usage(opts = {})
-      used = opts[:used]
-      limit = opts[:limit]
-      used_f = used&.to_f
-      limit_f = limit&.to_f
-      available = !used_f.nil? && !limit_f.nil? && limit_f.positive?
-      percent = available ? ((used_f / limit_f) * 100.0).round : nil
-      percent = 0 if percent && percent.negative?
-      percent = 100 if percent && percent > 100
-      {
-        available: available,
-        used: used_f,
-        limit: limit_f,
-        percent: percent,
-        source: opts[:source],
-        engine: opts[:engine]
-      }
-    end
-
-    # Supported Method Parameters::
-    # usage = PWN::AI.plan_usage(
-    #   engine: 'optional - engine symbol (defaults to PWN::Env[:ai][:active])',
-    #   ttl: 'optional - cache seconds (default 60)',
-    #   force: 'optional - bypass cache (default false)'
-    # )
-    public_class_method def self.plan_usage(opts = {})
-      engine = (opts[:engine] || PWN::Env.dig(:ai, :active)).to_s.downcase.to_sym
-      ttl = (opts[:ttl] || PLAN_USAGE_CACHE_TTL).to_i
-      ttl = PLAN_USAGE_CACHE_TTL if ttl <= 0
-      cache = (@plan_usage_cache ||= {})
-      now = Time.now.to_i
-      hit = cache[engine]
-      return hit[:value] if !opts[:force] && hit.is_a?(Hash) && (now - hit[:at].to_i) < ttl
-
-      klass_name = ENGINE_MODULES[engine]
-      value = { available: false, engine: engine }
-      if klass_name
-        begin
-          klass = Object.const_get(klass_name)
-          value = klass.get_plan_usage if klass.respond_to?(:get_plan_usage)
-          value = { available: false, engine: engine } unless value.is_a?(Hash)
-          value[:engine] ||= engine
-        rescue StandardError
-          value = { available: false, engine: engine }
-        end
-      end
-      cache[engine] = { at: now, value: value }
-      value
-    end
-
-    # Supported Method Parameters::
-    # glyph = PWN::AI.plan_usage_glyph(
-    #   engine: 'optional - engine symbol (defaults to PWN::Env[:ai][:active])',
-    #   usage: 'optional - precomputed usage hash'
-    # )
-    #
-    # Returns "19%" when used/limit are known, otherwise the infinity glyph.
-    # Local engines (ollama / openwebui) always return infinity.
-    public_class_method def self.plan_usage_glyph(opts = {})
-      engine = (opts[:engine] || PWN::Env.dig(:ai, :active)).to_s.downcase.to_sym
-      return PLAN_USAGE_INFINITY if %i[ollama openwebui].include?(engine)
-
-      usage = opts[:usage] || plan_usage(engine: engine)
-      return PLAN_USAGE_INFINITY unless usage.is_a?(Hash) && usage[:available] && !usage[:percent].nil?
-
-      "#{usage[:percent].to_i}%"
-    end
-
     # Display a List of Every PWN::AI Module
 
     # Author(s):: 0day Inc. <support@0dayinc.com>

data/lib/pwn/plugins/log.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'fileutils'
 require 'json'
 require 'logger'
 require 'securerandom'
@@ -8,6 +9,35 @@ module PWN
   module Plugins
     # This plugin is used to instantiate a PWN logger with a custom message format
     module Log
+      TRACE_SKIP_METHODS = %i[
+        authors help to_s inspect class object_id hash eql? == equal? !
+        method public_send send __send__ instance_eval class_eval
+        public_class_method private_class_method
+      ].freeze
+      TRACE_SKIP_PREFIXES = %w[
+        PWN::Plugins::Log
+        PWN::Plugins::REPL
+        PWN::Banner
+      ].freeze
+      DEFAULT_TRACE_PREFIXES = %w[
+        PWN::AI
+        PWN::Memory
+        PWN::Sessions
+        PWN::Config
+        PWN::Cron
+        PWN::Plugins
+      ].freeze
+      SECRET_KEY_RX = /password|passwd|secret|token|api[_-]?key|authorization|bearer|cookie|session[_-]?id|private[_-]?key|decryptor|credential|ssh[_-]?key|client[_-]?secret|refresh[_-]?token|access[_-]?token|id[_-]?token|vault|csrf/i
+      SECRET_VALUE_RX = %r{
+        -----BEGIN\ [A-Z ]*PRIVATE\ KEY----- |
+        Bearer\s+[A-Za-z0-9\-._~+/]+=* |
+        \beyJ[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+ |
+        \b(?:sk|rk|pk|xai|xox[baprs]|ghp|gho|ghu|ghs|ghr|glpat|AKIA|ASIA|ya29)[-_][A-Za-z0-9\-_]{16,} |
+        \b(?:api[_-]?key|token|secret|password|passwd)\s*[:=]\s*\S+
+      }ix
+      DEBUG_VALUE_MAX = 240
+      DEBUG_ARGS_MAX = 1_800
+
       # Supported Method Parameters::
       # PWN::Log.create(
       # )
@@ -99,6 +129,271 @@ module PWN
         raise e
       end
 
+      public_class_method def self.debug_enabled?(opts = {})
+        return @debug_enabled == true if opts.is_a?(Hash)
+
+        @debug_enabled == true
+      end
+
+      public_class_method def self.debug_log_path(opts = {})
+        return @debug_path if opts.is_a?(Hash)
+
+        @debug_path
+      end
+
+      # Open /tmp/pwn-ai-DEBUG-TIMESTAMP.log, tee the same lines to the TUI
+      # (opts[:tee]), and TracePoint PWN modules that process a pwn-ai request.
+      DEBUG_LOG_MAX = 1_024_000
+
+      public_class_method def self.start_debug(opts = {})
+        return @debug_path if debug_enabled? && opts.is_a?(Hash)
+
+        ts = Time.now.strftime('%Y%m%d-%H%M%S')
+        path = opts[:path].to_s
+        path = "/tmp/pwn-ai-DEBUG-#{ts}.1.log" if path.empty?
+        stem, idx = debug_path_parts(path: path)
+        path = "#{stem}.#{idx}.log"
+        FileUtils.mkdir_p(File.dirname(path))
+        io = File.open(path, 'a')
+        io.sync = true
+        @debug_file = io
+        @debug_path = path
+        @debug_stem = stem
+        @debug_index = idx
+        @debug_tee = opts[:tee]
+        @debug_tui_quiet = false
+        @debug_enabled = true
+        start_trace!(prefixes: opts[:prefixes]) unless opts[:trace] == false
+        progress(msg: "debug session start path=#{path}", which_self: self)
+        path
+      end
+
+      public_class_method def self.stop_debug(opts = {})
+        reason = opts[:reason].to_s if opts.is_a?(Hash)
+        if debug_enabled?
+          tail = reason.to_s.empty? ? 'debug session stop' : "debug session stop reason=#{reason}"
+          progress(msg: tail, which_self: self)
+        end
+        stop_trace!
+        begin
+          @debug_file&.close unless @debug_file.nil? || @debug_file.closed?
+        rescue StandardError
+          nil
+        end
+        path = @debug_path
+        @debug_file = nil
+        @debug_path = nil
+        @debug_stem = nil
+        @debug_index = nil
+        @debug_tee = nil
+        @debug_tui_quiet = false
+        @debug_enabled = false
+        path
+      end
+
+      private_class_method def self.debug_path_parts(opts = {})
+        path = opts[:path].to_s
+        return [Regexp.last_match(1), Regexp.last_match(2).to_i] if path =~ /\A(.+)\.(\d+)\.log\z/
+
+        [path.sub(/\.log\z/, ''), 1]
+      end
+
+      private_class_method def self.roll_debug_log!(opts = {})
+        return if opts[:skip]
+        return if @debug_file.nil? || @debug_file.closed?
+        return if @debug_file.size < DEBUG_LOG_MAX
+
+        @debug_file.close
+        @debug_index = @debug_index.to_i + 1
+        path = "#{@debug_stem}.#{@debug_index}.log"
+        io = File.open(path, 'a')
+        io.sync = true
+        @debug_file = io
+        @debug_path = path
+        path
+      end
+
+      public_class_method def self.quiet_tui!(opts = {})
+        return if opts[:skip]
+
+        @debug_tui_quiet = true
+      end
+
+      public_class_method def self.loud_tui!(opts = {})
+        return if opts[:skip]
+
+        @debug_tui_quiet = false
+      end
+
+      # One progress line to the debug file and the TUI tee (same payload).
+      public_class_method def self.progress(opts = {})
+        return false unless debug_enabled?
+        return false if Thread.current[:pwn_log_progress]
+
+        Thread.current[:pwn_log_progress] = true
+        msg = sanitize_debug_text(text: opts[:msg].to_s)
+        which = opts[:which_self] || self
+        line = format_progress(msg: msg, which_self: which)
+        begin
+          @debug_file&.puts(line)
+          @debug_file&.flush
+          roll_debug_log!
+        rescue StandardError
+          nil
+        end
+        tee = opts.key?(:tee) ? opts[:tee] : @debug_tee
+        if !@debug_tui_quiet && tee.respond_to?(:puts)
+          begin
+            tee.puts(color_progress(line: line))
+          rescue StandardError
+            nil
+          end
+        end
+        true
+      ensure
+        Thread.current[:pwn_log_progress] = false
+      end
+
+      private_class_method def self.format_progress(opts = {})
+        msg = opts[:msg].to_s.tr("\n", ' ')[0, 4_000]
+        which = opts[:which_self]
+        who = if which.is_a?(Module)
+                (which.name || which.to_s).to_s
+              else
+                which.to_s
+              end
+        ts = Time.now.strftime('%Y-%m-%d %H:%M:%S.%L%z')
+        bits = ["[DEBUG #{ts}]"]
+        bits << who unless who.empty?
+        bits << msg unless msg.empty?
+        sanitize_debug_text(text: bits.join(' '))
+      end
+
+      private_class_method def self.color_progress(opts = {})
+        line = opts[:line].to_s
+        "\001\e[35m\002#{line}\001\e[0m\002"
+      end
+
+      private_class_method def self.trace_module_name(opts = {})
+        tp = opts[:tp]
+        return '' unless tp
+
+        mod = tp.self.is_a?(Module) ? tp.self : tp.defined_class
+        name = if mod.respond_to?(:name) && mod.name
+                 mod.name
+               else
+                 mod.to_s
+               end
+        name.to_s.sub(/\A#<Class:(.+?)>\z/, '\1')
+      end
+
+      private_class_method def self.secret_key?(opts = {})
+        opts[:key].to_s.match?(SECRET_KEY_RX)
+      end
+
+      private_class_method def self.sanitize_debug_text(opts = {})
+        text = opts[:text].to_s
+        text = text.gsub(SECRET_VALUE_RX, '[REDACTED]')
+        text.gsub(/-----BEGIN [A-Z ]*PRIVATE KEY-----.*?-----END [A-Z ]*PRIVATE KEY-----/m, '[REDACTED]')
+      end
+
+      private_class_method def self.inspect_debug(opts = {})
+        val = opts[:value]
+        key = opts[:key]
+        return '[REDACTED]' if secret_key?(key: key)
+        return format_debug_hash(hash: val) if val.is_a?(Hash)
+        return '[REDACTED]' if val.is_a?(String) && val.match?(SECRET_VALUE_RX)
+
+        raw = sanitize_debug_text(text: val.inspect)
+        raw = "#{raw[0, DEBUG_VALUE_MAX]}…" if raw.length > DEBUG_VALUE_MAX
+        raw
+      rescue StandardError
+        "#<#{val.class}>"
+      end
+
+      private_class_method def self.format_debug_hash(opts = {})
+        hash = opts[:hash]
+        return '{}' unless hash.is_a?(Hash)
+
+        parts = hash.map do |k, v|
+          "#{k}: #{inspect_debug(value: v, key: k)}"
+        end
+        "{#{parts.join(', ')}}"
+      end
+
+      private_class_method def self.trace_arguments(opts = {})
+        tp = opts[:tp]
+        return '' unless tp
+
+        bind = tp.binding
+        parts = []
+        Array(tp.parameters).each do |kind, name|
+          next if name.nil?
+          next if %i[rest keyrest block].include?(kind)
+          next unless bind.local_variable_defined?(name)
+
+          val = bind.local_variable_get(name)
+          if name == :opts && val.is_a?(Hash)
+            rendered = format_debug_hash(hash: val)
+            return rendered == '{}' ? '' : rendered
+          end
+
+          parts << "#{name}=#{inspect_debug(value: val, key: name)}"
+        end
+        out = parts.join(', ')
+        out = "#{out[0, DEBUG_ARGS_MAX]}…" if out.length > DEBUG_ARGS_MAX
+        out
+      rescue StandardError
+        ''
+      end
+
+      private_class_method def self.format_trace_call(opts = {})
+        tp = opts[:tp]
+        klass = trace_module_name(tp: tp)
+        meth = tp.method_id
+        args = trace_arguments(tp: tp)
+        args.to_s.empty? ? "#{klass}.#{meth}" : "#{klass}.#{meth}(#{args})"
+      end
+
+      private_class_method def self.traceable?(opts = {})
+        tp = opts[:tp]
+        prefixes = opts[:prefixes] || DEFAULT_TRACE_PREFIXES
+        name = trace_module_name(tp: tp)
+        return false if name.empty?
+        return false if TRACE_SKIP_PREFIXES.any? { |p| name.start_with?(p) }
+        return false unless prefixes.any? { |p| name.start_with?(p) }
+        return false if TRACE_SKIP_METHODS.include?(tp.method_id)
+
+        true
+      end
+
+      public_class_method def self.start_trace!(opts = {})
+        return @debug_tp if @debug_tp && opts.is_a?(Hash)
+
+        prefixes = Array(opts[:prefixes] || DEFAULT_TRACE_PREFIXES).map(&:to_s)
+        prefixes = DEFAULT_TRACE_PREFIXES if prefixes.empty?
+        @debug_tp = TracePoint.new(:call) do |tp|
+          next unless debug_enabled?
+          next unless traceable?(tp: tp, prefixes: prefixes)
+
+          progress(
+            msg: format_trace_call(tp: tp),
+            which_self: ''
+          )
+        rescue StandardError
+          nil
+        end
+        @debug_tp.enable
+        @debug_tp
+      end
+
+      public_class_method def self.stop_trace!(opts = {})
+        return if opts[:skip]
+
+        @debug_tp&.disable
+        @debug_tp = nil
+      end
+
       # Author(s):: 0day Inc. <support@0dayinc.com>
 
       public_class_method def self.authors
@@ -116,6 +411,13 @@ module PWN
             msg: 'required - message to log',
             which_self: 'required - pass in self object from module calling #{self}'
           )
+
+          path = #{self}.start_debug(
+            tee: $stdout,
+            path: 'optional - defaults to /tmp/pwn-ai-DEBUG-TIMESTAMP.log'
+          )
+          #{self}.progress(msg: 'stage', which_self: self)
+          #{self}.stop_debug
         "
       end
     end

data/lib/pwn/plugins/repl.rb

@@ -375,11 +375,10 @@ module PWN
             max_context = PWN::Env[:ai][engine][:max_prompt_length].to_i
             current_context_length = "#{PWN::Plugins::REPL.compact_context_tokens(tokens: used_tokens)}:" \
                                      "#{PWN::Plugins::REPL.compact_context_tokens(tokens: max_context)}"
-            plan_usage_glyph = PWN::AI.plan_usage_glyph(engine: engine)
 
             pname = "pwn.ai:#{engine}"
-            pname = "pwn.ai:#{engine}/#{model}/#{current_context_length}/#{plan_usage_glyph}" if model
-            pname = "pwn.ai:#{engine}/#{model}/#{current_context_length}/#{plan_usage_glyph}.SPEAK" if pi.config.pwn_ai_speak
+            pname = "pwn.ai:#{engine}/#{model}/#{current_context_length}" if model
+            pname = "pwn.ai:#{engine}/#{model}/#{current_context_length}.SPEAK" if pi.config.pwn_ai_speak
             pi.config.prompt_name = pname
 
             name = "\001\e[1m\002\001\e[33m\002#{pi.config.prompt_name}\001\e[0m\002"
@@ -1045,11 +1044,23 @@ module PWN
         end
 
         Pry::Commands.create_command 'toggle-pwn-ai-debug' do
-          description 'Display the response_history object while using pwn.ai'
+          description 'Stream pwn-ai module progress to the TUI and /tmp/pwn-ai-DEBUG-TIMESTAMP.log'
 
           def process
             pi = pry_instance
-            pi.config.pwn_ai_debug ? pi.config.pwn_ai_debug = false : pi.config.pwn_ai_debug = true
+            if pi.config.pwn_ai_debug
+              path = PWN::Plugins::Log.stop_debug
+              pi.config.pwn_ai_debug = false
+              if path
+                output.puts "pwn-ai debug OFF (was #{path})"
+              else
+                output.puts 'pwn-ai debug OFF'
+              end
+            else
+              path = PWN::Plugins::Log.start_debug(tee: output)
+              pi.config.pwn_ai_debug = true
+              output.puts "pwn-ai debug ON → #{path}"
+            end
           end
         end
 
@@ -1071,7 +1082,7 @@ module PWN
             pi.config.pwn_asm = false if pi.config.pwn_asm
             pi.config.pwn_ai = false if pi.config.pwn_ai
             pi.config.pwn_ai_agent = false if pi.config.pwn_ai_agent
-            pi.config.pwn_ai_debug = false if pi.config.pwn_ai_debug
+            # pi.config.pwn_ai_debug = false if pi.config.pwn_ai_debug
             pi.config.pwn_ai_speak = false if pi.config.pwn_ai_speak
             pi.config.completer = Pry::InputCompleter
             # pi.config.pwn_ai_original_input ||= Pry.config.input.clone
@@ -1215,10 +1226,19 @@ module PWN
                   request: orig_request,
                   session_id: sess_id,
                   enabled_toolsets: PWN::Env.dig(:ai, :agent, :toolsets),
-                  on_tool: on_tool
+                  on_tool: on_tool,
+                  debug: pi.config.pwn_ai_debug,
+                  debug_tee: $stdout
                 )
+                $stdout.flush
                 puts "\n\001\e[32m\002#{final}\001\e[0m\002\n\n"
-                pp PWN::Sessions.load(session_id: sess_id) if pi.config.pwn_ai_debug && sess_id && PWN.const_defined?(:Sessions)
+                $stdout.flush
+                if pi.config.pwn_ai_debug && sess_id && PWN.const_defined?(:Sessions)
+                  PWN::Plugins::Log.progress(
+                    msg: "session=#{sess_id}",
+                    which_self: PWN::Sessions
+                  )
+                end
                 request.replace('nil')
                 next
               rescue StandardError => e

data/lib/pwn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PWN
-  VERSION = '0.5.685'
+  VERSION = '0.5.686'
 end