pwn 0.5.721 → 0.5.723

data/lib/pwn/ai/agent/tools/metrics.rb

@@ -59,3 +59,19 @@ PWN::AI::Agent::Registry.register(
     { reset: true, tools_cleared: before, file: PWN::AI::Agent::Metrics::METRICS_FILE }
   }
 )
+
+PWN::AI::Agent::Registry.register(
+  name: 'ai_usage',
+  toolset: 'metrics',
+  schema: {
+    name: 'ai_usage',
+    description: 'Per-call token counts and cumulative cost plus configured model routing.',
+    parameters: { type: 'object', properties: { session_id: { type: 'string' } } }
+  },
+  handler: lambda { |args|
+    {
+      usage: PWN::AI::Agent::Metrics.usage(session_id: args[:session_id] || args['session_id']),
+      routing: PWN::AI::Agent::Metrics.routing
+    }
+  }
+)

data/lib/pwn/ai/agent/tools/pty_session.rb

@@ -10,12 +10,12 @@ PWN::AI::Agent::Registry.register(
     description: 'Open a persistent PTY (gdb, r2, ssh, sh). Returns {id, pid}.',
     parameters: {
       type: 'object',
-      properties: { cmd: { type: 'string' }, command: { type: 'string' } },
+      properties: { cmd: { type: 'string' }, command: { type: 'string' }, name: { type: 'string' } },
       required: %w[cmd]
     }
   },
   handler: lambda { |args|
-    PWN::Plugins::ProcessTube.spawn(cmd: args[:cmd] || args[:command] || args['cmd'])
+    PWN::Plugins::ProcessTube.spawn(cmd: args[:cmd] || args[:command] || args['cmd'], name: args[:name] || args['name'])
   }
 )
 PWN::AI::Agent::Registry.register(
@@ -26,12 +26,12 @@ PWN::AI::Agent::Registry.register(
     description: 'Write a line to a PTY opened by pty_open.',
     parameters: {
       type: 'object',
-      properties: { id: { type: 'string' }, line: { type: 'string' }, data: { type: 'string' } },
+      properties: { id: { type: 'string' }, name: { type: 'string' }, line: { type: 'string' }, data: { type: 'string' } },
       required: %w[id]
     }
   },
   handler: lambda { |args|
-    PWN::Plugins::ProcessTube.write_line(id: args[:id] || args['id'], line: args[:line] || args[:data] || args['line'])
+    PWN::Plugins::ProcessTube.write_line(id: args[:id] || args[:name] || args['id'] || args['name'], line: args[:line] || args[:data] || args['line'])
   }
 )
 PWN::AI::Agent::Registry.register(

data/lib/pwn/ai/agent/tools/ruby_eval.rb

@@ -54,11 +54,12 @@ PWN::AI::Agent::Registry.register(
 
     code = args[:code].to_s
     if code.strip.empty? || PWN::AI::Agent::ToolGuard.placeholder?(text: code)
-      return {
-        stdout: '',
-        error: 'invalid_payload',
-        hint: 'code is required (string). Do not send ..., {...}, {…}, or empty. Example: pwn_eval(code="1 + 1").'
-      }
+      return PWN::AI::Agent::ToolGuard.invalid_payload(
+        hint: 'code is required (string). Do not send ..., {...}, {…}, or empty. Example: pwn_eval(code="1 + 1"). Triple-dot inside quoted/heredoc bodies is allowed.',
+        offending_token: '...',
+        text: code,
+        suggestion: 'replace ellipsis or placeholders with concrete Ruby'
+      )
     end
 
     old_stdout = $stdout

data/lib/pwn/ai/agent/tools/shell.rb

@@ -56,11 +56,20 @@ PWN::AI::Agent::Registry.register(
                         .gsub(/\\+\s*\z/, '')
                         .strip
     timeout = PWN::AI::Agent::ToolGuard.deadline_s(timeout: args[:timeout], kind: :shell, payload: cmd)
+    if cmd.bytesize > PWN::AI::Agent::ToolGuard::MAX_PAYLOAD_BYTES
+      return PWN::AI::Agent::ToolGuard.invalid_payload(
+        hint: "command exceeds max payload size #{PWN::AI::Agent::ToolGuard::MAX_PAYLOAD_BYTES} bytes",
+        text: cmd,
+        byte_range: [PWN::AI::Agent::ToolGuard::MAX_PAYLOAD_BYTES, cmd.bytesize],
+        code: 'PAYLOAD_TOO_LARGE'
+      )
+    end
     if cmd.empty? || PWN::AI::Agent::ToolGuard.placeholder?(text: cmd)
       return PWN::AI::Agent::ToolGuard.invalid_payload(
         hint: 'command is required (string). Do not send ..., {...}, {…}, or empty. ' \
-              'Example: shell(command="uname -r").',
+              'Example: shell(command="uname -r"). Triple-dot inside quoted/heredoc bodies is allowed.',
         offending_token: '...',
+        text: cmd,
         code: 'SYNTAX_DENY',
         suggestion: 'replace ellipsis or placeholders with a concrete command'
       )

data/lib/pwn/ai/agent/tools/skills.rb

@@ -241,6 +241,36 @@ PWN::AI::Agent::Registry.register(
   }
 )
 
+PWN::AI::Agent::Registry.register(
+  name: 'skills_create',
+  toolset: 'skills',
+  schema: {
+    name: 'skills_create',
+    description: 'Create a new skill under ~/.pwn/skills. Requires confirm:true (operator gate).',
+    parameters: {
+      type: 'object',
+      properties: {
+        name: { type: 'string' },
+        sop_markdown: { type: 'string' },
+        content: { type: 'string' },
+        description: { type: 'string' },
+        confirm: { type: 'boolean' }
+      },
+      required: %w[name]
+    }
+  },
+  handler: lambda { |args|
+    raise ArgumentError, 'refusing to create a skill without confirm:true' unless args[:confirm] == true
+
+    PWN::Config.write_skill(
+      name: args[:name],
+      description: args[:description],
+      content: args[:sop_markdown] || args[:content] || args['sop_markdown'] || args['content'],
+      pwn_skills_path: PWN::Config.pwn_skills_path
+    ).merge(saved: true)
+  }
+)
+
 PWN::AI::Agent::Registry.register(
   name: 'skill_add_reference',
   toolset: 'skills',

data/lib/pwn/ai/agent/tools/swarm.rb

@@ -102,7 +102,10 @@ PWN::AI::Agent::Registry.register(
           type: 'string',
           description: 'Existing swarm to join (from swarm_list / a prior ' \
                        'agent_ask). Omit to auto-create a new swarm.'
-        }
+        },
+        unit: { type: 'string', description: 'Claim key host:phase so two children do not duplicate work.' },
+        ttl: { type: 'integer', description: 'Claim TTL seconds (defaults to 300).' },
+        engagement_id: { type: 'string', description: 'Claim namespace (defaults to swarm_id).' }
       },
       required: %w[name request]
     }
@@ -113,7 +116,10 @@ PWN::AI::Agent::Registry.register(
     PWN::AI::Agent::Swarm.ask(
       name: args[:name],
       request: args[:request],
-      swarm_id: args[:swarm_id]
+      swarm_id: args[:swarm_id],
+      unit: args[:unit],
+      ttl: args[:ttl],
+      engagement_id: args[:engagement_id]
     )
   }
 )

data/lib/pwn/ai/context.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'fileutils'
+require 'json'
+
+module PWN
+  module AI
+    # Attach files, hexdumps, disassembly, and HTTP transcripts to model
+    # context with auto-chunking. Oversize artifacts are summarized inline
+    # and persisted under ~/.pwn/artifacts/<session_id>/ with SHA-256.
+    module Context
+      WINDOW = 32_768
+      CHUNK = 8_192
+
+      public_class_method def self.attach_file(opts = {})
+        path = opts[:path].to_s
+        raise 'ERROR: path is required' if path.empty?
+        raise "ERROR: file not found: #{path}" unless File.file?(path)
+
+        range = opts[:range]
+        data = if range.is_a?(Range)
+                 File.binread(path, range.end - range.begin, range.begin).to_s
+               else
+                 File.binread(path)
+               end
+        persist_and_chunk(bytes: data, path: path, kind: 'file', session_id: opts[:session_id], mime: mime_of(path: path))
+      end
+
+      public_class_method def self.attach_hexdump(opts = {})
+        path = opts[:path].to_s
+        raise 'ERROR: path is required' if path.empty?
+        raise "ERROR: file not found: #{path}" unless File.file?(path)
+
+        offset = opts[:offset].to_i
+        length = (opts[:length] || 512).to_i
+        length = 512 if length <= 0
+        slice = File.binread(path, length, offset).to_s
+        hex = slice.unpack1('H*')
+        persist_and_chunk(bytes: hex, path: path, kind: 'hexdump', session_id: opts[:session_id], extra: { offset: offset, length: slice.bytesize })
+      end
+
+      public_class_method def self.attach_disasm(opts = {})
+        path = opts[:path].to_s
+        raise 'ERROR: path is required' if path.empty?
+
+        fn = opts[:function].to_s
+        text = if defined?(PWN::Plugins::Radare2) && File.file?(path)
+                 sid = PWN::Plugins::Radare2.open(path: path)
+                 addr = fn.empty? ? 'main' : fn
+                 PWN::Plugins::Radare2.disasm(session: sid, addr: addr, n: 64)
+               else
+                 File.binread(path).to_s[0, CHUNK]
+               end
+        persist_and_chunk(bytes: text.to_s, path: path, kind: 'disasm', session_id: opts[:session_id], extra: { function: fn })
+      end
+
+      public_class_method def self.attach_http_transcript(opts = {})
+        src = opts[:har_or_raw] || opts[:har] || opts[:raw] || opts[:path]
+        bytes = if src.to_s.empty?
+                  raise 'ERROR: har_or_raw is required'
+                elsif File.file?(src.to_s)
+                  File.binread(src.to_s)
+                else
+                  src.to_s
+                end
+        persist_and_chunk(bytes: bytes, path: src.to_s, kind: 'http_transcript', session_id: opts[:session_id])
+      end
+
+      public_class_method def self.authors
+        "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+      end
+
+      public_class_method def self.help
+        puts "USAGE:
+          # Attach a file (optionally a byte range) and chunk it for the model.
+          #{self}.attach_file(
+            path: 'required - filesystem path to attach',
+            range: 'optional - Range of bytes to attach instead of the whole file',
+            session_id: 'optional - pwn-ai session id for the artifact store'
+          )
+
+          # Attach a hexdump slice of a binary.
+          #{self}.attach_hexdump(
+            path: 'required - filesystem path of the binary',
+            offset: 'optional - byte offset (defaults to 0)',
+            length: 'optional - byte count (defaults to 512)',
+            session_id: 'optional - pwn-ai session id for the artifact store'
+          )
+
+          # Attach disassembly of a function (r2 when present).
+          #{self}.attach_disasm(
+            path: 'required - filesystem path of the binary',
+            function: 'optional - function or address (defaults to main)',
+            session_id: 'optional - pwn-ai session id for the artifact store'
+          )
+
+          # Attach a HAR or raw HTTP transcript.
+          #{self}.attach_http_transcript(
+            har_or_raw: 'required - HAR/raw string or filesystem path',
+            har: 'optional - alias for har_or_raw',
+            raw: 'optional - alias for har_or_raw',
+            path: 'optional - filesystem path of a HAR file',
+            session_id: 'optional - pwn-ai session id for the artifact store'
+          )
+
+          # Print the AUTHOR(S) string for this module.
+          #{self}.authors
+        "
+        constants.sort
+      end
+
+      private_class_method def self.persist_and_chunk(opts = {})
+        bytes = opts[:bytes].to_s
+        mime = opts[:mime].to_s
+        summary = if binary_mime?(mime: mime, bytes: bytes)
+                    binary_summary(bytes: bytes, path: opts[:path])
+                  else
+                    bytes[0, WINDOW]
+                  end
+        stored = if defined?(PWN::Plugins::ArtifactRegistry)
+                   PWN::Plugins::ArtifactRegistry.put(bytes: bytes, path: opts[:path], kind: opts[:kind], session_id: opts[:session_id])
+                 else
+                   sid = (opts[:session_id] || 'default').to_s
+                   sha = Digest::SHA256.hexdigest(bytes)
+                   dir = File.join(Dir.home, '.pwn', 'artifacts', sid)
+                   FileUtils.mkdir_p(dir)
+                   dest = File.join(dir, sha)
+                   File.binwrite(dest, bytes)
+                   { sha256: sha, path: dest, size: bytes.bytesize }
+                 end
+        chunks = []
+        body = summary.to_s
+        i = 0
+        while i < body.bytesize
+          chunks << body.byteslice(i, CHUNK)
+          i += CHUNK
+        end
+        {
+          sha256: stored[:sha256],
+          path: stored[:path],
+          size: bytes.bytesize,
+          kind: opts[:kind],
+          summarized: bytes.bytesize > WINDOW,
+          chunks: chunks,
+          extra: opts[:extra]
+        }.merge(opts[:extra].is_a?(Hash) ? opts[:extra] : {})
+      end
+
+      private_class_method def self.mime_of(opts = {})
+        path = opts[:path].to_s
+        return 'application/octet-stream' unless File.file?(path)
+
+        head = File.binread(path, 16).to_s
+        return 'application/x-elf' if head.start_with?("\x7fELF")
+        return 'application/x-mach-binary' if head.start_with?("\xCF\xFA\xED\xFE") || head.start_with?("\xCE\xFA\xED\xFE")
+        return 'application/x-dosexec' if head.start_with?('MZ')
+        return 'application/json' if path.end_with?('.json', '.har')
+        return 'text/plain' if head.force_encoding('UTF-8').valid_encoding?
+
+        'application/octet-stream'
+      end
+
+      private_class_method def self.binary_mime?(opts = {})
+        mime = opts[:mime].to_s
+        return true if mime.start_with?('application/x-') || mime == 'application/octet-stream'
+
+        bytes = opts[:bytes].to_s
+        bytes.encoding == Encoding::ASCII_8BIT && bytes.bytes.any? { |b| b < 9 || (b > 13 && b < 32) }
+      end
+
+      private_class_method def self.binary_summary(opts = {})
+        bytes = opts[:bytes].to_s
+        printable = bytes.gsub(/[^\x20-\x7e]/n, '').byteslice(0, 2_048)
+        entropy = shannon(bytes: bytes.byteslice(0, 4_096))
+        "strings=#{printable[0, 400]} entropy=#{entropy.round(2)} size=#{bytes.bytesize} path=#{opts[:path]}"
+      end
+
+      private_class_method def self.shannon(opts = {})
+        data = opts[:bytes].to_s
+        return 0.0 if data.empty?
+
+        freq = Hash.new(0)
+        data.each_byte { |b| freq[b] += 1 }
+        n = data.bytesize.to_f
+        freq.values.sum do |c|
+          p = c / n
+          p.positive? ? -p * Math.log2(p) : 0
+        end
+      end
+    end
+  end
+end

data/lib/pwn/ai/http_retry.rb

@@ -38,11 +38,45 @@ module PWN
 
       public_class_method def self.retry_after_s(opts = {})
         retry_count = [opts[:retry_count].to_i, 1].max
-        retry_after = 0
+        headers = {}
         resp = opts[:response]
-        retry_after = resp.headers[:retry_after].to_i if resp.respond_to?(:headers) && resp.headers
-        retry_after = (0.5 * retry_count) if retry_after.to_f <= 0
-        retry_after
+        headers = resp.headers if resp.respond_to?(:headers) && resp.headers
+        ra = headers[:retry_after] || headers['retry-after'] || headers['Retry-After']
+        if ra.to_s.match?(/\A\d+(\.\d+)?\z/)
+          n = ra.to_f
+          return n if n.positive?
+        end
+
+        [2**retry_count, 60].min.to_f
+      end
+
+      public_class_method def self.quota_exhausted?(opts = {})
+        err = opts[:error]
+        blob = err.respond_to?(:message) ? err.message.to_s : err.to_s
+        blob = opts[:message].to_s if blob.empty?
+        if err.respond_to?(:response) && err.response
+          blob = "#{blob} #{err.response}"
+          blob = "#{blob} #{err.response.body}" if err.response.respond_to?(:body)
+        end
+        blob.match?(/insufficient_quota|credit_balance_exhausted|exceeded your current quota|billing_not_active|spend.?limit|no credits remaining/i)
+      rescue StandardError
+        false
+      end
+
+      public_class_method def self.quota_message(opts = {})
+        err = opts[:error]
+        blob = ''
+        blob = err.message.to_s if err.respond_to?(:message)
+        if err.respond_to?(:response) && err.response
+          blob = "#{blob} #{err.response}"
+          blob = "#{blob} #{err.response.body}" if err.response.respond_to?(:body)
+        end
+        blob = opts[:message].to_s if blob.strip.empty?
+        url = blob[%r{https://platform\.openai\.com/settings/organization/billing/?}] ||
+              'https://platform.openai.com/settings/organization/billing/'
+        'OpenAI API has no credits (insufficient_quota / credit_balance_exhausted). ' \
+          "Add prepaid API credits at #{url} — a ChatGPT Plus/Pro plan does not fund api.openai.com. " \
+          'Then retry; /model openai stays selected.'
       end
 
       # Tees provider REST events into the open pwn-ai DEBUG RN log and STDERR.
@@ -88,10 +122,22 @@ module PWN
             message: 'required - message value consumed by #retryable?'
           )
 
-          # Run retry after s and return its result
+          # Seconds to sleep after a 429 (Retry-After, else exponential 2..60).
           #{self}.retry_after_s(
-            retry_count: 'optional - retry count value consumed by #retry_after_s',
-            response: 'optional - response value consumed by #retry_after_s'
+            retry_count: 'optional - 1-based attempt used for exponential fallback',
+            response: 'optional - RestClient response with Retry-After header'
+          )
+
+          # True when a 429 body is billing/quota, not a retryable rate limit.
+          #{self}.quota_exhausted?(
+            error: 'optional - exception whose message/response body is inspected',
+            message: 'optional - raw error text when error is omitted'
+          )
+
+          # Operator-facing line for a billing/quota 429 (do not retry).
+          #{self}.quota_message(
+            error: 'optional - exception whose response body may contain the billing URL',
+            message: 'optional - raw error text when error is omitted'
           )
 
           # Tees provider REST events into the open pwn-ai DEBUG RN log and STDERR