pwn 0.5.561 → 0.5.573

data/lib/pwn/plugins/repl.rb

@@ -4,6 +4,7 @@ require 'curses'
 require 'fileutils'
 require 'meshtastic'
 require 'pry'
+require 'reline'
 require 'tty-prompt'
 require 'unicode/display_width'
 require 'yaml'
@@ -12,10 +13,59 @@ module PWN
   module Plugins
     # This module contains methods related to the pwn REPL Driver.
     module REPL
-      # Supported Method Parameters::
-      # PWN::Plugins::REPL.refresh_ps1_proc(
-      #   mode: 'required - :splat or nil'
-      # )
+      # Custom input handler for pwn-ai to support multi-line submissions:
+      # - SHIFT+ENTER (common terminal sequences) or Ctrl+J / Alt+Enter inserts a newline (continue editing)
+      # - plain ENTER submits the full prompt (possibly multi-line) to the AI
+      # - Multi-line pastes are supported (Reline handles \n in buffer; submit with ENTER)
+      class PwnAIInput
+        attr_reader :line_buffer
+
+        def initialize
+          @line_buffer = ''
+        end
+
+        def readline(prompt)
+          # Common escape sequences for SHIFT+ENTER across terminals (xterm, modern, etc.)
+          shift_enter_seqs = [
+            # Common SHIFT+ENTER sequences across terminals (xterm, gnome-terminal, kitty, wezterm, recent xterm w/ modifyOtherKeys, etc.)
+            # If SHIFT+ENTER still submits in your terminal, try Ctrl+J or Alt+Enter (M-^J) as alternatives (terminals vary in emitted bytes for SHIFT+ENTER)
+            '\\e[13;2~',
+            '\\e[1;2~',
+            '\\e\\r',
+            '\\e\\n',
+            '\\e[13;2u',
+            '\\u001b[13;2u',
+            '\\e[27;2;13~',
+            '\\e[27;2;13u',
+            '\\e[13;2u',
+            '\\e[1;2~',
+            '\\e[27;2;13~'
+          ]
+          shift_enter_seqs.each do |seq|
+            Reline.config.add_oneshot_key_binding(seq.bytes, :key_newline)
+          end
+
+          begin
+            # readmultiline with confirm block that *always* returns true:
+            #   => normal ENTER triggers finish/submit of the (multi-line) buffer
+            # The bound SHIFT+ENTER (and built-in Ctrl+J / M-^M) trigger key_newline (insert \n, stay in edit)
+            # Reline in multiline mode also handles multi-line pastes by splitting on \n in the buffer.
+            @line_buffer = Reline.readmultiline(prompt, true) { |_buffer| true } || ''
+          ensure
+            Reline.config.reset_oneshot_key_bindings
+          end
+          @line_buffer
+        end
+
+        # Compatibility with Pry input expectations (used by hooks for line_buffer, and possibly completer/tty checks)
+        def tty?
+          true
+        end
+
+        def winsize
+          [TTY::Screen.rows || 24, TTY::Screen.columns || 80]
+        end
+      end
 
       public_class_method def self.refresh_ps1_proc(opts = {})
         mode = opts[:mode]
@@ -117,13 +167,147 @@ module PWN
         end
 
         Pry::Commands.create_command 'pwn-ai' do
-          description 'Initiate pwn.ai chat interface.'
+          description 'Initiate pwn.ai autonomous agent TUI (instruct tasks using PWN modules + CLI tools; memory/sessions/agents/cron/skills-aware from PWN::Config/PWN::Memory etc).'
 
           def process
             pi = pry_instance
             pi.config.pwn_ai = true
+            pi.config.pwn_ai_agent = true
             pi.config.color = false if pi.config.pwn_ai
-            pi.config.color = true unless pi.config.pwn_ai
+
+            # Switch to custom multi-line input for pwn-ai (SHIFT+ENTER newline, ENTER submit)
+            pi.config.pwn_ai_original_input ||= Pry.config.input
+            Pry.config.input = PwnAIInput.new
+
+            # Load and make aware of skills folder (scaled in PWN::Config per user pwn_env_path parent)
+            skills_path = begin
+              PWN::Config.pwn_skills_path
+            rescue StandardError
+              "#{Dir.home}/.pwn/skills"
+            end
+            PWN::Config.load_skills(pwn_skills_path: skills_path)
+            skills_count = (PWN.const_defined?(:Skills) ? PWN::Skills.keys.length : 0)
+
+            # Hermes-equivalent memory/sessions/cron init for this pwn-ai activation
+            PWN::Config.load_memory
+            mem_count = (PWN.const_defined?(:Memory) ? PWN::Memory.load.keys.length : 0)
+            sess = begin
+              PWN::Sessions.create(title: "pwn-ai #{Time.now.strftime('%Y-%m-%d %H:%M')}", source: 'pwn-ai-repl')
+            rescue StandardError
+              nil
+            end
+            pi.config.pwn_ai_session_id = sess[:id] if sess
+            cron_count = (PWN.const_defined?(:Cron) ? PWN::Cron.list.keys.length : 0)
+
+            puts "\
+[*] pwn-ai agent TUI activated (PWN REPL driver w/ memory, sessions, delegation, cron)."
+            puts "[*] Memory facts: #{mem_count} | Session: #{pi.config.pwn_ai_session_id} | Cron jobs: #{cron_count} | Skills: #{skills_count}"
+            puts '[*] Instruct the AI agent to carry out a task, e.g.:'
+            puts "    'Use NmapIt to port scan target.com then use TransparentBrowser to spider and SAST::TestCaseEngine to analyze code if cloned. Generate report with PWN::Reports.'"
+            puts "    'Execute CLI nmap -sV target.com and summarize findings using PWN modules.'"
+            puts "[*] Skills loaded from #{skills_path} (#{skills_count} available) + memory/sessions/cron to expand autonomous capabilities."
+            puts "[*] Type 'toggle-pwn-ai' or normal pwn commands to exit agent mode.
+"
+          end
+        end
+
+        Pry::Commands.create_command 'pwn-ai-memory' do
+          description 'Manage pwn-ai persistent memory (Hermes equiv).'
+
+          def process
+            cmd = args[0]
+            case cmd
+            when 'list', 'recall', nil
+              q = args[1]
+              res = PWN::Memory.recall(query: q)
+              puts res.inspect
+            when 'remember'
+              key = args[1]
+              val = args[2..-1].join(' ')
+              PWN::Memory.remember(key: key, value: val)
+              puts "Remembered #{key}"
+            when 'forget'
+              PWN::Memory.forget(args[1])
+              puts "Forgot #{args[1]}"
+            when 'clear'
+              PWN::Memory.clear
+              puts 'Memory cleared'
+            else
+              puts PWN::Memory.help
+            end
+          end
+        end
+
+        Pry::Commands.create_command 'pwn-ai-sessions' do
+          description 'List/resume/delete pwn-ai sessions (Hermes equiv).'
+
+          def process
+            cmd = args[0]
+            case cmd
+            when 'list', nil
+              puts PWN::Sessions.list.inspect
+            when 'resume'
+              sid = args[1]
+              hist = PWN::Sessions.to_response_history(session_id: sid)
+              puts "Loaded session #{sid} with #{hist[:choices].size} entries (set manually into response_history if needed)"
+            when 'delete'
+              PWN::Sessions.delete(session_id: args[1])
+              puts "Deleted #{args[1]}"
+            when 'stats'
+              puts PWN::Sessions.stats
+            else
+              puts PWN::Sessions.help
+            end
+          end
+        end
+
+        Pry::Commands.create_command 'pwn-ai-cron' do
+          description 'Manage scheduled pwn-ai / cron jobs (Hermes equiv).'
+
+          def process
+            cmd = args[0]
+            case cmd
+            when 'list', nil
+              puts PWN::Cron.list.inspect
+            when 'create'
+              # simplistic: pwn-ai-cron create '0 * * * *' 'prompt here'
+              sched = args[1]
+              pr = args[2..-1].join(' ')
+              job = PWN::Cron.create(schedule: sched, prompt: pr)
+              puts "Created #{job}"
+            when 'run'
+              res = PWN::Cron.run(id: args[1])
+              puts res
+            when 'remove'
+              PWN::Cron.remove(id: args[1])
+              puts 'Removed'
+            else
+              puts PWN::Cron.help
+            end
+          end
+        end
+
+        Pry::Commands.create_command 'pwn-ai-delegate' do
+          description 'Delegate sub-task to a PWN::AI::Agent or simple sub-chat (Hermes delegation equiv).'
+
+          def process
+            goal = args.join(' ')
+            puts "[*] Delegating: #{goal}"
+            # Simple delegation: use a specialized agent if matches, else another chat turn
+            if goal =~ /sast|code|scan/i
+              res = PWN::AI::Agent::SAST.analyze(request: goal)
+            elsif goal =~ /vuln|report/i
+              res = PWN::AI::Agent::VulnGen.analyze(request: goal)
+            else
+              # fallback sub call to active engine (no full loop here)
+              engine = PWN::Env[:ai][:active].to_s.downcase.to_sym
+              case engine
+              when :anthropic then res = PWN::AI::Anthropic.chat(request: goal)
+              when :grok then res = PWN::AI::Grok.chat(request: goal)
+              else res = PWN::AI::Ollama.chat(request: goal)
+              end
+            end
+            puts res
           end
         end
 
@@ -339,6 +523,12 @@ module PWN
                             response_history: response_history,
                             spinner: false
                           )
+                        when :anthropic
+                          response = PWN::AI::Anthropic.chat(
+                            request: request,
+                            response_history: response_history,
+                            spinner: false
+                          )
                         end
 
                         response_history = {
@@ -742,9 +932,14 @@ module PWN
             pi.config.color = true
             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_speak = false if pi.config.pwn_ai_speak
             pi.config.completer = Pry::InputCompleter
+            if pi.config.pwn_ai_original_input
+              Pry.config.input = pi.config.pwn_ai_original_input
+              pi.config.pwn_ai_original_input = nil
+            end
             return unless pi.config.pwn_mesh
 
             pi.config.pwn_mesh = false
@@ -834,65 +1029,215 @@ module PWN
 
         Pry.config.hooks.add_hook(:after_read, :pwn_ai_hook) do |request, pi|
           if pi.config.pwn_ai && !request.chomp.empty?
-            request = pi.input.line_buffer.to_s
+            orig_request = pi.input.line_buffer.to_s
+            request = orig_request
             debug = pi.config.pwn_ai_debug
             engine = PWN::Env[:ai][:active].to_s.downcase.to_sym
             response_history = PWN::Env[:ai][engine][:response_history]
             speak_answer = pi.config.pwn_ai_speak
+            is_agent = (pi.config.pwn_ai_agent == true)
 
-            case engine
-            when :grok
-              response = PWN::AI::Grok.chat(
-                request: request.chomp,
-                response_history: response_history,
-                speak_answer: speak_answer,
-                spinner: true
-              )
-            when :ollama
-              response = PWN::AI::Ollama.chat(
-                request: request.chomp,
-                response_history: response_history,
-                speak_answer: speak_answer,
-                spinner: true
-              )
-            when :openai
-              response = PWN::AI::OpenAI.chat(
-                request: request.chomp,
+            # pwn-ai agent mode (Hermes TUI equiv): load skills context for autonomous task carrying
+            skills_context = ''
+            PWN::Skills.each { |n, m| skills_context += "\n--- SKILL #{n} ---\n#{m[:content].to_s[0, 1200]}\n" } if is_agent && PWN.const_defined?(:Skills) && PWN::Skills.is_a?(Hash)
+
+            memory_context = ''
+            memory_context = PWN::Memory.to_context(limit: 25) if is_agent && PWN.const_defined?(:Memory)
+
+            sess_id = begin
+              pi.config.pwn_ai_session_id
+            rescue StandardError
+              nil
+            end
+
+            # Pre-process for clear CLI execution intent (e.g. "what does `id` return?")
+            # This makes the agent actually *run* commands instead of just explaining them.
+            curr_req = request.chomp
+            if is_agent && sess_id && PWN.const_defined?(:Sessions)
+              begin
+                PWN::Sessions.append(session_id: sess_id, role: 'user', content: orig_request)
+              rescue StandardError
+                nil
+              end
+            end
+            if is_agent && request =~ /`([^`]+)`/
+              potential = ::Regexp.last_match(1).strip
+              # Looks like a shell command (not PWN ruby)
+              unless potential =~ /^(PWN::|def |class |require |puts |pp )/
+                curr_req = "The user wants the *actual raw output* of this command (do not just describe it): `#{potential}`. " \
+                           'To fulfill the request accurately, you MUST immediately output ONLY a bash code block with the exact command. ' \
+                           "Example format: ```bash\n#{potential}\n``` . After the host executes it, you will receive the OBSERVATION with the real output."
+              end
+            end
+
+            # Strict system prompt for agent mode (forces tool use over explanation)
+            system_role = nil
+            if is_agent
+              base = PWN::Env[:ai][engine][:system_role_content] || 'You are an ethical hacker.'
+              system_role = base + <<~PROMPT
+
+                                You are operating as a Hermes-style autonomous agent inside the PWN REPL driver.
+
+                                PRIMARY RULE FOR CLI AND TOOLS: When the user asks for the output of a command, "what does X return?", "run X", or anything that requires real execution, you MUST use a tool call.#{' '}
+                                NEVER just explain what a command does or what its output "would be".#{' '}
+                                To execute anything:
+                                  - Output *exactly and only* a fenced code block.
+                                  - For shell/CLI: ```bash
+                                <exact command here>
+                                ```
+                                  - For PWN Ruby modules: ```ruby
+                                PWN::Plugins::NmapIt.port_scan(...)
+                                ```
+                                The host will execute it (Ruby in full PWN context, bash via shell) and reply with an OBSERVATION containing the real result.#{' '}
+                                Then continue or give the final answer.
+
+                                Available tools include all PWN::Plugins (NmapIt, TransparentBrowser, etc.), SAST, Reports, and any CLI via bash blocks.
+                                Skills available this session:#{skills_context}
+                #{memory_context}
+
+                                PERSISTENT CAPABILITIES (use via ruby code blocks or direct calls):
+                                - Memory (cross-session): PWN::Memory.remember(key: :key, value: val, category: :fact|:preference|:lesson)
+                                  PWN::Memory.recall(query: 'foo'), PWN::Memory.forget(key)
+                                - Sessions: current session id = #{sess_id}; PWN::Sessions.append(session_id: '#{sess_id}', role: 'observation', content: obs)
+                                - Cron: PWN::Cron.create(schedule: '0 * * * *', prompt: 'task here', name: 'foo')
+                                  PWN::Cron.run(id: 'id'); list with PWN::Cron.list
+                                - Agents/Delegation: PWN::AI::Agent::SAST.analyze(request: ...); PWN::AI::Agent::VulnGen etc.
+                                  For sub-agents use threads or separate eval calls and feed results back as OBS.
+
+                                After receiving an observation, decide the next step or conclude.
+                                If you output text without a code block, it will be treated as your final answer to the user.
+              PROMPT
+            end
+
+            max_turns = is_agent ? 7 : 1
+            turn = 0
+            last_response = ''
+            tool_was_executed_this_turn = false
+
+            while turn < max_turns
+              chat_opts = {
+                request: curr_req,
                 response_history: response_history,
                 speak_answer: speak_answer,
                 spinner: true
-              )
-            else
-              raise "ERROR: Unsupported AI Engine: #{engine}"
-            end
-            # puts response.inspect
+              }
+              chat_opts[:system_role_content] = system_role if system_role
+
+              case engine
+              when :grok
+                response = PWN::AI::Grok.chat(**chat_opts)
+              when :ollama
+                response = PWN::AI::Ollama.chat(**chat_opts)
+              when :openai
+                response = PWN::AI::OpenAI.chat(**chat_opts)
+              when :anthropic
+                response = PWN::AI::Anthropic.chat(**chat_opts)
+              else
+                raise "ERROR: Unsupported AI Engine: #{engine}"
+              end
 
-            last_response = ''
-            if response.nil?
-              last_response = "Model: #{model} not currently supported with API key."
-            else
-              if response[:choices].last.keys.include?(:text)
-                last_response = response[:choices].last[:text]
+              if response.nil?
+                last_response = 'Model not currently supported with API key.'
               else
-                last_response = response[:choices].last[:content]
+                if response[:choices].last.keys.include?(:text)
+                  last_response = response[:choices].last[:text].to_s
+                else
+                  last_response = response[:choices].last[:content].to_s
+                end
+                response_history = {
+                  id: response[:id],
+                  object: response[:object],
+                  model: response[:model],
+                  usage: response[:usage]
+                }
+                response_history[:choices] ||= response[:choices]
               end
 
-              response_history = {
-                id: response[:id],
-                object: response[:object],
-                model: response[:model],
-                usage: response[:usage]
-              }
-              response_history[:choices] ||= response[:choices]
+              puts "\n\001\e[32m\002#{last_response}\001\e[0m\002\n\n"
+              if is_agent && sess_id && PWN.const_defined?(:Sessions)
+                begin
+                  PWN::Sessions.append(session_id: sess_id, role: 'assistant', content: last_response)
+                rescue StandardError
+                  nil
+                end
+              end
+
+              if debug
+                puts 'DEBUG: response_history => '
+                pp response_history
+              end
+              PWN::Env[:ai][engine][:response_history] = response_history
+
+              # === Agent tool execution: parse code blocks from *this* response and actually run them ===
+              tool_was_executed_this_turn = false
+              if is_agent
+                # Robust regex: tolerate language specifier, extra whitespace, and text around the block
+                last_response.scan(/```(?:\s*(ruby|bash|sh|shell|zsh))?\s*\n?(.*?)\n?```/m).each do |lang, code|
+                  code = code.strip
+                  next if code.empty? || tool_was_executed_this_turn
+
+                  lang = (lang || 'bash').downcase
+                  puts "\001\e[33m\002[ pwn-ai AGENT EXEC #{lang} ]
\e[0m\002 #{code[0..90]}..."
+
+                  obs = ''
+                  begin
+                    if lang == 'ruby'
+                      require 'stringio'
+                      old_stdout = $stdout
+                      $stdout = StringIO.new
+                      res = eval(code, TOPLEVEL_BINDING) # rubocop:disable Security/Eval -- intentional for pwn-ai agent to run PWN Ruby modules/tools in REPL context
+                      captured = $stdout.string
+                      $stdout = old_stdout
+                      obs = (captured + "\n=> #{res.inspect}").strip
+                    else
+                      # CLI execution - use Open3 for cleaner capture (no extra shell if possible, but backticks are simple and work)
+                      require 'open3'
+                      stdout, stderr, status = Open3.capture3(code)
+                      obs = stdout
+                      obs += "\n[stderr]\n#{stderr}" unless stderr.to_s.strip.empty?
+                      obs += "\n[exit: #{status.exitstatus}]" unless status.success?
+                      obs = obs.strip
+                    end
+                  rescue StandardError => e
+                    obs = "ERROR executing #{lang} block: #{e.class} - #{e.message}"
+                  end
+
+                  puts "\001\e[36m\002[OBSERVATION from #{lang}]\001\e[0m\002\n#{obs[0..700]}\n"
+                  if is_agent && sess_id && PWN.const_defined?(:Sessions)
+                    begin
+                      PWN::Sessions.append(session_id: sess_id, role: 'observation', content: obs)
+                    rescue StandardError
+                      nil
+                    end
+                  end
+
+                  # Feed real result back to the model as the next "user" message in the loop
+                  curr_req = "OBSERVATION (#{lang} execution result for previous block):\n#{obs}\n\n" \
+                             "Now continue fulfilling the original user request: #{orig_request}. " \
+                             'If the task is complete, give the final answer (no more code blocks). Otherwise output the next needed tool block.'
+
+                  tool_was_executed_this_turn = true
+                  turn += 1
+                  break # one execution per model turn for controlled pacing
+                end
+              end
+
+              # If we executed something, loop to let the model react to the OBS
+              next if tool_was_executed_this_turn
+
+              # No tool executed this turn -> this last_response is the final answer
+              break
             end
-            puts "\n\001\e[32m\002#{last_response}\001\e[0m\002\n\n"
 
-            if debug
-              puts 'DEBUG: response_history => '
-              pp response_history
-              puts "\nresponse_history[:choices] Length: #{response_history[:choices].length}\n" unless response_history.nil?
+            # If in agent mode and the model never produced an executable block but the query clearly wanted execution,
+            # give one last chance with a strong reminder (helps weaker models like some Ollama ones)
+            if is_agent && !tool_was_executed_this_turn && orig_request =~ /`[^`]+`/ && turn < max_turns
+              reminder = 'The user explicitly asked about the output of a command in backticks. ' \
+                         'Do not describe the command. Output *only* the corresponding ```bash block now so the host can run it and give you the real result.'
+              curr_req = "#{reminder}\nOriginal: #{orig_request}"
+              # One final direct call (no full re-loop to avoid complexity)
+              # (The main loop already handled most cases; this is a safety net)
             end
-            PWN::Env[:ai][engine][:response_history] = response_history
           end
         end
 

data/lib/pwn/plugins/xxd.rb

@@ -144,6 +144,25 @@ module PWN
         )
       end
 
+      # Supported Method Parameters::
+      # PWN::Plugins::XXD.reverse_dump(
+      #   string: 'required - continuous hex string to reverse (i.e. "68656c6c6f")',
+      #   file: 'required - path to binary file to dump'
+      # )
+
+      def self.reverse_hex_string(opts = {})
+        string = opts[:string]
+        file = opts[:file]
+
+        raise ArgumentError, 'string is required' if string.nil?
+
+        raise ArgumentError, 'output file is required' if file.nil?
+
+        File.binwrite(file, [string].pack('H*'))
+      rescue StandardError => e
+        raise e
+      end
+
       # Supported Method Parameters::
       # PWN::Plugins::XXD.reverse_dump(
       #   hexdump: 'required - hexdump returned from #dump method',
@@ -284,6 +303,11 @@ module PWN
           #    <step through via F7, F8, F9, etc. to get to desired instruction>
           #    ```
 
+          #{self}.reverse_hex_string(
+            string: 'required - continuous hex string to reverse (i.e. \"68656c6f\")',
+            file: 'required - path to binary file to dump'
+          )
+
           #{self}.reverse_dump(
             hexdump: 'required - hexdump returned from #dump method',
             file: 'required - path to binary file to dump',