pwn 0.5.667 → 0.5.668

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa499352cfb75931341be5441fff894e39fbdff2292872d73a1e47617d89561f
-  data.tar.gz: b84bc29d866707b543f3813d60cd3df045b953aca991fd23af637ce126e9e1a9
+  metadata.gz: 21fe6bb04741fbc78392d434588c1c86d0f605db0988bfa2192f68e9baa870ec
+  data.tar.gz: cf66359fb95bb12f08705d11dd304625878115902133d9e1ad0f8becfa8fb83a
 SHA512:
-  metadata.gz: a79c88587274434b654149e2a45593e14e445ae7ac2d322e3bf45da6e3902709544de0ab061b03a449cdd170376771adf3fa46b06aac2cc2b3b65f808f474f56
-  data.tar.gz: 915b78058dd9af752236a97c4c040a5005d850af0ba3ed4554459858d64afcc2fa325c4c5bcc438d716753b5130ac37f97fa728d879eae430ac76d7cde6b0a34
+  metadata.gz: 35f079f6d7c765c6395f490f07c06ce3494b81487bba31c978367fc2b8a23a421a6b1d9a68cda02592fd94868ca343a13c441323b6e1dee0656f46ade8c88aef
+  data.tar.gz: b9a45751eaf30849ac1c98bd8d603df89d8522fb950dfc830f188769b0fc8e7b69848ed1f71053f7053da24a85e0c2f56f0f9a2c26b95de2040835a7e9871c47

data/.rubocop_todo.yml

@@ -73,6 +73,7 @@ Naming/AccessorMethodName:
     - 'lib/pwn/ai/grok.rb'
     - 'lib/pwn/ai/ollama.rb'
     - 'lib/pwn/ai/open_ai.rb'
+    - 'lib/pwn/ai/open_web_ui.rb'
     - 'lib/pwn/blockchain/btc.rb'
     - 'lib/pwn/plugins/jira_data_center.rb'
     - 'lib/pwn/plugins/vin.rb'

data/Gemfile

@@ -67,7 +67,7 @@ gem 'os', '1.1.4'
 gem 'ostruct', '0.6.3'
 gem 'packetfu', '2.0.0'
 gem 'packetgen', '4.1.1'
-gem 'pdf-reader', '2.15.1'
+gem 'pdf-reader', '2.16.0'
 gem 'pg', '1.6.3'
 gem 'pry', '0.16.0'
 gem 'pry-doc', '1.7.0'
@@ -89,12 +89,12 @@ gem 'ruby-nmap', '1.0.3'
 gem 'ruby-saml', '1.18.1'
 gem 'rvm', '1.11.3.9'
 gem 'savon', '2.17.4'
-gem 'selenium-devtools', '0.150.0'
-gem 'selenium-webdriver', '4.46.0'
+gem 'selenium-devtools', '0.151.0'
+gem 'selenium-webdriver', '4.47.0'
 gem 'slack-ruby-client', '3.2.0'
 gem 'socksify', '1.8.1'
 gem 'spreadsheet', '1.3.5'
-gem 'sqlite3', '2.9.5'
+gem 'sqlite3', '2.9.6'
 gem 'thin', '2.0.1'
 gem 'tty-prompt', '0.23.1'
 gem 'tty-spinner', '0.9.3'

data/lib/pwn/ai/agent/dispatch.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'securerandom'
 
 module PWN
   module AI
@@ -118,6 +119,165 @@ module PWN
           raise ArgumentError, "invalid JSON arguments: #{e.message}"
         end
 
+        # Supported Method Parameters::
+        # calls = PWN::AI::Agent::Dispatch.tool_calls_from_text(
+        #   text: 'required - assistant plain-text that may embed shell(...) / JSON tool forms'
+        # )
+        #
+        # Local / abliterated models often print tool invocations as content
+        # instead of native message.tool_calls. Supported shapes include:
+        #   shell(command="id") / shell({"command":"id"}) / shell("id")
+        #   {"name":"shell","arguments":{...}} / {"function":{"name":...}}
+        #   {"tool":"shell","arguments":{...}} / {"call":"shell","arguments":{...}}
+        #   call:shell{command: "uname -s"} / tool:shell{"command":"id"}
+        # When structured tool_calls are empty, Loop coerces those strings into
+        # OpenAI-shaped tool_call hashes so Dispatch runs them instead of
+        # treating the string as a FINAL answer.
+
+        public_class_method def self.tool_calls_from_text(opts = {})
+          text = opts[:text].to_s
+          return [] if text.strip.empty?
+
+          Registry.discover if defined?(Registry) && Registry.respond_to?(:discover)
+          known = if defined?(Registry)
+                    Registry.all.map { |e| e.name.to_s }.reject(&:empty?)
+                  else
+                    %w[shell pwn_eval]
+                  end
+          return [] if known.empty?
+
+          names_alt = known.map { |n| Regexp.escape(n) }.join('|')
+          calls = []
+          seen = {}
+
+          add = lambda do |name, args|
+            name = name.to_s
+            next unless known.include?(name)
+
+            args_h = case args
+                     when Hash then symbolize(hash: args)
+                     when String
+                       s = args.strip
+                       begin
+                         parsed = JSON.parse(s, symbolize_names: true)
+                         parsed.is_a?(Hash) ? parsed : { value: parsed }
+                       rescue JSON::ParserError
+                         h = {}
+                         s.scan(/([A-Za-z_]\w*)\s*[:=]\s*(?:"((?:\\.|[^"])*)"|'((?:\\.|[^'])*)'|([^\s,)}{]+))/) do
+                           k = Regexp.last_match(1)
+                           h[k.to_sym] = Regexp.last_match(2) || Regexp.last_match(3) || Regexp.last_match(4)
+                         end
+                         if h.empty?
+                           entry = (Registry.lookup(name: name) if defined?(Registry))
+                           req = Array(entry&.schema&.dig(:parameters, :required))
+                           h = req.length == 1 ? { req.first.to_sym => s } : { command: s }
+                         end
+                         h
+                       end
+                     else
+                       {}
+                     end
+            key = "#{name}|#{JSON.generate(args_h)}"
+            next if seen[key]
+
+            seen[key] = true
+            calls << {
+              id: "textcall_#{calls.length + 1}_#{SecureRandom.hex(3)}",
+              type: 'function',
+              function: {
+                name: name,
+                # OpenAI/xAI wire format requires a JSON string, not a map.
+                arguments: JSON.generate(args_h)
+              }
+            }
+          end
+
+          # Balanced-delimiter extractor used for name(...) and call:name{...}.
+          extract_balanced = lambda do |open_ch, close_ch, from|
+            depth = 1
+            i = from
+            in_s = nil
+            esc = false
+            while i < text.length && depth.positive?
+              ch = text[i]
+              if in_s
+                if esc
+                  esc = false
+                elsif ch == '\\'
+                  esc = true
+                elsif ch == in_s
+                  in_s = nil
+                end
+              elsif ['"', "'"].include?(ch)
+                in_s = ch
+              elsif ch == open_ch
+                depth += 1
+              elsif ch == close_ch
+                depth -= 1
+              end
+              i += 1
+            end
+            depth.zero? ? [text[from...(i - 1)].to_s.strip, i] : nil
+          end
+
+          # JSON object forms:
+          #   {"name":"shell","arguments":{...}}
+          #   {"function":{"name":"shell","arguments":{...}}}
+          #   {"tool":"shell","arguments":{...}} / {"call":"shell",...}
+          #   {"type":"call","name":"shell",...}
+          text.scan(/\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}/m).each do |blob|
+            begin
+              j = JSON.parse(blob, symbolize_names: true)
+            rescue JSON::ParserError
+              next
+            end
+            next unless j.is_a?(Hash)
+
+            name = (
+              j[:name] || j[:tool] || j[:call] ||
+              j.dig(:function, :name) || j.dig(:tool_call, :name)
+            ).to_s
+            # Skip pure type tags mistaken as names (e.g. {"call":{...}} trees).
+            next if name.empty? || %w[function tool_call].include?(name)
+
+            args = j[:arguments] || j[:args] || j[:parameters] ||
+                   j.dig(:function, :arguments) || j.dig(:tool_call, :arguments) || {}
+            add.call(name, args)
+          end
+
+          # Colon-brace forms (OpenWebUI / abliterated dumps):
+          #   call:shell{command: "uname -s"}
+          #   tool:shell{"command":"id"}
+          #   call:shell{command="id"}
+          rx_colon = /\b(?:call|tool)\s*:\s*(#{names_alt})\s*\{/i
+          idx = 0
+          while (m = text.match(rx_colon, idx))
+            name = m[1]
+            extracted = extract_balanced.call('{', '}', m.end(0))
+            if extracted
+              # Re-wrap: balanced extractor yields the interior only. Paren form
+              # shell({...}) keeps braces inside (...); brace form must restore
+              # them so JSON.parse / kwarg scan see a full object body.
+              add.call(name, "{#{extracted[0]}}")
+            end
+            idx = m.begin(0) + 1
+          end
+
+          # Call forms: shell(command="...") / shell({"command":"id"}) / shell("id")
+          rx = /\b(#{names_alt})\s*\(/i
+          idx = 0
+          while (m = text.match(rx, idx))
+            name = m[1]
+            extracted = extract_balanced.call('(', ')', m.end(0))
+            add.call(name, extracted[0]) if extracted
+            idx = m.begin(0) + 1
+          end
+
+          calls
+        rescue StandardError
+          []
+        end
+
         private_class_method def self.symbolize(opts = {})
           hash = opts[:hash] ||= {}
           hash.each_with_object({}) { |(k, v), m| m[k.to_sym] = v }
@@ -143,6 +303,7 @@ module PWN
               )
 
               PWN::AI::Agent::Dispatch.repair_name(name: 'run_shell')  # => 'shell'
+              PWN::AI::Agent::Dispatch.tool_calls_from_text(text: 'shell(command="id")')
 
               #{self}.authors
           USAGE

data/lib/pwn/ai/agent/extrospection.rb

@@ -1189,7 +1189,8 @@ module PWN
 
               bin = m[:name].to_s.split('_').first
               tc  = Array(delta[:changed]).find { |c| c[:path].to_s.include?("toolchain.#{bin}") }
-              miss = snap.dig(:toolchain, bin.to_sym).to_s.empty?
+              tc_map = snap[:toolchain].is_a?(Hash) ? snap[:toolchain] : {}
+              miss = tc_map[bin.to_sym].to_s.empty?
               next unless tc || miss
 
               findings << { kind: :tool_env_mismatch, tool: m[:name], success_rate: m[:success_rate], evidence: tc || "binary '#{bin}' not found in PATH", advice: "Re-verify `which #{bin}` / reinstall before relying on #{m[:name]}." }
@@ -1206,7 +1207,7 @@ module PWN
           end
 
           # 3) intel observations matching installed components
-          pkgs = snap[:toolchain] || {}
+          pkgs = snap[:toolchain].is_a?(Hash) ? snap[:toolchain] : {}
           observations(category: 'intel', limit: 100).each do |ob|
             blob = ob[:data].to_s.downcase
             pkgs.each do |bin, ver|
@@ -1218,7 +1219,7 @@ module PWN
           end
 
           # 4) :rf observations vs missing SDR hardware / binaries
-          rf = snap[:rf] || {}
+          rf = snap[:rf].is_a?(Hash) ? snap[:rf] : {}
           hw_present = %i[rtl_sdr hackrf flipper gqrx_sock].any? { |k| rf_present?(val: rf[k]) }
           observations(category: 'rf', limit: 50).each do |ob|
             miss = RF_BINS.select { |b| pkgs[b.to_sym].to_s.empty? }
@@ -1240,7 +1241,10 @@ module PWN
               Learning.outcomes(limit: 30, success: false).each do |o|
                 next unless o[:task].to_s.include?(host) || o[:details].to_s.include?(host)
 
-                findings << { kind: :target_web_drift, target: tgt, dom_sha: ob.dig(:data, :dom_sha), task: o[:task], advice: "Target #{host} DOM changed (#{ob[:timestamp]}) around this failure - re-recon before assuming your technique is wrong." }
+                dom_sha = case ob[:data]
+                          when Hash then ob[:data][:dom_sha] || ob[:data]['dom_sha']
+                          end
+                findings << { kind: :target_web_drift, target: tgt, dom_sha: dom_sha, task: o[:task], advice: "Target #{host} DOM changed (#{ob[:timestamp]}) around this failure - re-recon before assuming your technique is wrong." }
               end
             end
           end
@@ -1253,7 +1257,7 @@ module PWN
           end
 
           # 7) :intel observations whose source anchor is currently probe_web-unreachable -> downgrade
-          web = snap[:web] || {}
+          web = snap[:web].is_a?(Hash) ? snap[:web] : {}
           web.each do |host, fp|
             next unless fp.is_a?(Hash) && (fp[:reachable] == false || fp[:status].to_i >= 500)
 

data/lib/pwn/ai/agent/learning.rb

@@ -1088,7 +1088,8 @@ module PWN
         # Mistakes(tool:'assumption') so KNOWN MISTAKES warns every future
         # run off that specific hallucination.
         private_class_method def self.fact_check_local_final(opts = {})
-          return unless defined?(PWN::Env) && PWN::Env.dig(:ai, :active).to_s.downcase.to_sym == :ollama
+          eng = defined?(PWN::Env) ? PWN::Env.dig(:ai, :active).to_s.downcase.to_sym : nil
+          return unless %i[ollama openwebui].include?(eng)
           return unless defined?(Extrospection) && Extrospection.respond_to?(:verify)
 
           claims = opts[:final].to_s.scan(CLAIM_RX).flatten.compact.uniq