portage-cli 0.7.5 → 0.9.0

data/lib/portage/cli/webmcp_autofill_mode.rb

@@ -0,0 +1,39 @@
+require_relative "config"
+require_relative "setting"
+
+module Portage
+  module Cli
+    # docs/plans/webmcp-universal-outbound.md Phase 3 — the opt-in gate in
+    # front of filling the store's own checkout page. Off by default: only
+    # `--autofill` (a per-run CLI flag, forwarded to `Buy.new(autofill:)`)
+    # or `PORTAGE_WEBMCP_AUTOFILL=approve` / config.json's
+    # `"webmcp_autofill": "approve"` turn it on. Same Setting precedence
+    # everywhere else in this gem uses (WebmcpCheckoutMode, HandoffSpendMode)
+    # — override beats env beats config — except the override here is a
+    # boolean (the flag is either passed or it isn't), while the env/config
+    # level is a literal string, `"approve"`, not truthy-string parsing
+    # (Setting.flag?'s "1"/"true"/"yes"): a plan that could be
+    # `PORTAGE_WEBMCP_AUTOFILL=true` by accident from some other truthy
+    # convention shouldn't silently turn on typing into a checkout page.
+    #
+    # Turning this gate on is still only half of Phase 3's opt-in: even
+    # approved, nothing is typed until the shopper also approves the exact
+    # field/value pairs in WebmcpAutofillConfirm's own prompt.
+    module WebmcpAutofillMode
+      ENV_VAR = "PORTAGE_WEBMCP_AUTOFILL".freeze
+      CONFIG_KEY = "webmcp_autofill".freeze
+      APPROVE = "approve".freeze
+
+      module_function
+
+      # @param override [Boolean, nil] --autofill's value: true when the
+      #   flag was passed, nil otherwise (there's no --no-autofill; the flag
+      #   only ever turns this on, same as --dry-run/--yes elsewhere in Buy).
+      def approved?(override: nil, config: Config.load)
+        return true if override == true
+
+        Setting.resolve(env: ENV_VAR, config: config, config_key: CONFIG_KEY).to_s.strip.downcase == APPROVE
+      end
+    end
+  end
+end

data/lib/portage/cli/webmcp_mapping_confirm.rb

@@ -0,0 +1,68 @@
+module Portage
+  module Cli
+    # Turns a `Portage::Ucp::WebMcp::Matcher` proposal into `tool_names:`
+    # `Buy#webmcp_flow` can pass to `WebMcp.connect`, enforcing Phase 2's
+    # confirm-before-mutate rule (docs/plans/webmcp-universal-outbound.md):
+    # a read action (`search_catalog`, `get_product`, `get_cart`) is usable
+    # straight off the proposal — wrong at worst wastes a call. A mutating
+    # action (`create_cart`, `update_cart`, `create_checkout`) needs
+    # confirmation first, since a wrong guess there could add to, discard,
+    # or charge a stranger's cart.
+    #
+    # The prompt quotes a mutating tool's own `description` as what it is —
+    # page content, therefore untrusted — never as an instruction. Nothing
+    # here executes, follows, or acts on anything the description says; it
+    # is printed for the shopper to read and nothing more.
+    class WebmcpMappingConfirm
+      READ_ACTIONS = %w[search_catalog get_product get_cart].freeze
+
+      # @param interactive [Boolean] whether a prompt can actually be shown
+      #   and answered — false under --json or with no TTY on stdin (the
+      #   caller decides; this class has no opinion on how). false means a
+      #   proposal with any mutating action is always refused.
+      def initialize(interactive:, input: $stdin, output: $stdout)
+        @interactive = interactive
+        @input = input
+        @output = output
+      end
+
+      # @param proposal [Hash{String => Matcher::Proposal}]
+      # @param tools [Array<Hash>] the page's own tools, so the prompt can
+      #   quote a mutating tool's description.
+      # @return [Hash{String => String}, nil] a tool_names: hash covering
+      #   every proposed action, or nil when a mutating action was proposed
+      #   and couldn't be confirmed — no TTY, --json, or the shopper
+      #   declined. Never returns a partial mapping: either every mutating
+      #   action in the proposal is approved, or none of them are used.
+      def call(proposal, tools)
+        reads = proposal.slice(*READ_ACTIONS).transform_values(&:tool)
+        mutating = proposal.except(*READ_ACTIONS)
+        return reads if mutating.empty?
+        return nil unless confirmed?(mutating, tools)
+
+        reads.merge(mutating.transform_values(&:tool))
+      end
+
+      private
+
+      def confirmed?(mutating, tools) = @interactive && approve?(mutating, tools)
+
+      def approve?(mutating, tools)
+        @output.puts "This page's WebMCP tools weren't recognized as a known store platform. Based on their " \
+                     "names and schemas, here's the proposed mapping for cart/checkout actions — the " \
+                     "description text is quoted from the page itself, not a trusted instruction:"
+        mutating.each { |action, match| describe(action, match, tools) }
+        @output.print "Use this mapping? [y/N] "
+        @output.flush
+        @input.gets.to_s.strip.downcase == "y"
+      end
+
+      def describe(action, match, tools)
+        tool = tools.find { |t| (t["name"] || t[:name]).to_s == match.tool }
+        description = tool && (tool["description"] || tool[:description])
+        @output.puts "  #{action} -> #{match.tool} (confidence #{match.confidence}) — #{match.reason}"
+        @output.puts "    page description: #{description.inspect}" if description
+      end
+    end
+  end
+end

data/lib/portage/cli/webmcp_mappings.rb

@@ -0,0 +1,84 @@
+require "json"
+require "fileutils"
+require "time"
+
+module Portage
+  module Cli
+    # Confirmed Phase 2 `tool_names:` mappings — `~/.portage/webmcp_mappings.json`
+    # (docs/plans/webmcp-universal-outbound.md) — keyed by the page's tool
+    # fingerprint (`Portage::Ucp::WebMcp::Fingerprint.for`: sorted tool names
+    # plus a hash of each one's own input schema), never by origin
+    # (decision 3): once a shopper confirms a mapping for one store, any
+    # other store whose WebMCP tools have the exact same shape reuses it
+    # with no prompt at all — in effect a local preset. A lookalike page
+    # whose schemas differ even slightly gets a different fingerprint and
+    # has to be confirmed again, so it can't borrow a mapping with a
+    # different shape underneath the same tool names.
+    #
+    # Same "absent file or absent key means unset, a corrupt file raises
+    # rather than silently falling back" posture as Config — this is
+    # deliberately its own file, not a key under config.json, since it's
+    # confirmed data (grows with use) rather than a standing preference.
+    class WebmcpMappings
+      PATH = File.join(Dir.home, ".portage", "webmcp_mappings.json").freeze
+
+      def self.load(path: PATH) = new(path: path, data: read(path))
+
+      def initialize(path: PATH, data: {})
+        @path = path
+        @data = data
+      end
+
+      # @param tools [Array<Hash>] the page's tools, as list_tools returns
+      #   them.
+      # @return [Hash{String => String}, nil] the confirmed tool_names: for
+      #   this exact fingerprint, or nil when none has been confirmed yet.
+      def lookup(tools)
+        entry = @data[fingerprint_for(tools)]
+        entry && entry["tool_names"].transform_keys(&:to_s)
+      end
+
+      # @param tool_names [Hash] action => tool name, as just confirmed.
+      #   Merged onto whatever this fingerprint already had (so confirming a
+      #   new action later doesn't drop an earlier one), never replaced
+      #   outright.
+      # @param origin [String, nil] recorded as metadata only — the lookup
+      #   key is the fingerprint alone (decision 3), never the origin.
+      # @return [Hash{String => String}] the fingerprint's tool_names: after
+      #   merging.
+      def confirm!(tools, tool_names:, origin: nil)
+        key = fingerprint_for(tools)
+        entry = @data[key] || { "tool_names" => {}, "origins" => [] }
+        entry["tool_names"] = entry["tool_names"].merge(tool_names.transform_keys(&:to_s))
+        entry["origins"] = (entry["origins"] + [origin]).compact.uniq if origin
+        entry["confirmed_at"] = Time.now.utc.iso8601
+        @data[key] = entry
+        write
+        entry["tool_names"]
+      end
+
+      def to_h = @data.dup
+
+      def self.read(path)
+        return {} unless File.readable?(path)
+
+        raw = File.read(path)
+        return {} if raw.empty?
+
+        parsed = JSON.parse(raw)
+        parsed.is_a?(Hash) ? parsed : {}
+      end
+      private_class_method :read
+
+      private
+
+      def fingerprint_for(tools) = Portage::Ucp::WebMcp::Fingerprint.for(tools)
+
+      def write
+        FileUtils.mkdir_p(File.dirname(@path))
+        File.write(@path, JSON.pretty_generate(@data))
+        File.chmod(0o600, @path)
+      end
+    end
+  end
+end