portage-cli 0.6.4 → 0.7.3

data/lib/portage/cli/reconcile_notify.rb

@@ -0,0 +1,38 @@
+require_relative "config"
+require_relative "setting"
+
+module Portage
+  module Cli
+    # docs/plans/handoff-reconcile.md Phase 3 — which channels fire when a
+    # handoff settles, from `portage buy --wait` or `portage orders
+    # reconcile` (see ReconcileNotifier). A comma list, same Setting
+    # precedence as every other standing preference here: an explicit
+    # `override:` beats PORTAGE_RECONCILE_NOTIFY, which beats config.json's
+    # "reconcile_notify". Unset is `webhook` only.
+    #
+    # "journal" is accepted but drives nothing here: the Phase 1 order
+    # snapshot journal write already happens unconditionally in
+    # HandoffReconciler#record_journal whenever a completed checkout carries
+    # an order. Naming it in `reconcile_notify` documents that as always-on
+    # rather than gating a second write path.
+    module ReconcileNotify
+      ENV_VAR = "PORTAGE_RECONCILE_NOTIFY".freeze
+      CONFIG_KEY = "reconcile_notify".freeze
+      CHANNELS = %w[webhook journal macos terminal].freeze
+      DEFAULT = %w[webhook].freeze
+
+      module_function
+
+      # @param extra [Array<String>] channels to force on regardless of
+      #   configuration — `portage buy --wait` forces `terminal` in plain
+      #   (non-`--json`) mode, so the shopper sees a line when it settles
+      #   even with nothing configured.
+      # @return [Array<String>]
+      def resolve(override: nil, config: Config.load, extra: [])
+        raw = Setting.resolve(override: override, env: ENV_VAR, config: config, config_key: CONFIG_KEY)
+        configured = raw.nil? ? DEFAULT : raw.to_s.split(",").map(&:strip)
+        ((configured & CHANNELS) + extra).uniq
+      end
+    end
+  end
+end

data/lib/portage/cli/search_backends.rb

@@ -2,6 +2,9 @@ require "net/http"
 require "uri"
 require "json"
 require "yaml"
+require "portage/ucp"
+require "portage/ucp/support/connection"
+require_relative "user_agent"
 
 module Portage
   module Cli
@@ -18,7 +21,6 @@ module Portage
     module SearchBackends
       OPEN_TIMEOUT = 5
       READ_TIMEOUT = 5
-      USER_AGENT = "portage-find".freeze
 
       # Reference works and marketplaces-of-links that a search backend will
       # happily return for a product query but that are never themselves a UCP
@@ -45,9 +47,9 @@ module Portage
       end
 
       def self.request(uri, headers)
-        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
-                                            open_timeout: OPEN_TIMEOUT, read_timeout: READ_TIMEOUT) do |http|
-          http.get(uri.request_uri, { "User-Agent" => USER_AGENT }.merge(headers))
+        Portage::Ucp::Support::Connection.start(uri, route: :search, open_timeout: OPEN_TIMEOUT,
+                                                     read_timeout: READ_TIMEOUT) do |http|
+          http.get(uri.request_uri, UserAgent.headers.merge(headers))
         end
       end
       private_class_method :request

data/lib/portage/cli/setting.rb

@@ -0,0 +1,44 @@
+module Portage
+  module Cli
+    # How portage-cli resolves a standing preference, in one place
+    # (docs/plans/checkout-handoff-delivery.md open decision #1): a
+    # per-invocation override (a flag) beats its PORTAGE_* env var, which
+    # beats its ~/.portage/config.json key (Config). CheckoutHandoff,
+    # Notifier, Buy and ConfidenceCheck all read their settings through it.
+    #
+    # nil or a blank string counts as unset at every level, so an exported
+    # but empty `PORTAGE_AUTO_OPEN_CHECKOUT=` falls through to config.json
+    # rather than silently meaning "off".
+    module Setting
+      TRUE_VALUES = %w[1 true yes].freeze
+
+      module_function
+
+      # @param override [Object, nil] the flag's value, nil when not passed.
+      # @param env [String, nil] the env var's name.
+      # @param config [Config, nil]
+      # @param config_key [String, nil]
+      # @return [Object, nil] the value from the first level that's set.
+      def resolve(override: nil, env: nil, config: nil, config_key: nil)
+        return override if set?(override)
+
+        from_env = env && ENV.fetch(env, nil)
+        return from_env if set?(from_env)
+
+        from_config = config_key && config&.get(config_key)
+        from_config if set?(from_config)
+      end
+
+      # The same precedence, read as yes/no: true, or a string in
+      # TRUE_VALUES (any case). Anything else, unset included, is no.
+      def flag?(**)
+        TRUE_VALUES.include?(resolve(**).to_s.strip.downcase)
+      end
+
+      def set?(value)
+        !(value.nil? || (value.is_a?(String) && value.strip.empty?))
+      end
+      private_class_method :set?
+    end
+  end
+end

data/lib/portage/cli/user_agent.rb

@@ -0,0 +1,39 @@
+require "portage/ucp/client"
+require_relative "version"
+require_relative "config"
+require_relative "setting"
+
+module Portage
+  module Cli
+    # Every request this CLI makes — to a store, a search backend, a
+    # payment handler, or a notify webhook — names itself, then the client
+    # gem it speaks UCP through, so a merchant reading its logs sees
+    # "portage-cli/... portage-ucp-client/... (+https://github.com/...)"
+    # rather than Ruby's default and knows where to look.
+    #
+    # A caller running many agents behind one IP (or one that just wants
+    # its own contact info in the string a merchant might grep for) can
+    # override it — same Setting precedence as Notifier's webhook URL:
+    # PORTAGE_USER_AGENT beats ~/.portage/config.json's "user_agent" key,
+    # both of which beat this default. Resolved fresh on every call rather
+    # than frozen at load time, so a config.json edit or an ENV change
+    # takes effect without restarting whatever's driving this CLI.
+    module UserAgent
+      DEFAULT = "portage-cli/#{VERSION} #{Portage::Ucp::Client::USER_AGENT}".freeze
+      ENV_VAR = "PORTAGE_USER_AGENT".freeze
+      CONFIG_KEY = "user_agent".freeze
+
+      module_function
+
+      # @param config [Config]
+      # @return [String] never blank — falls back to DEFAULT.
+      def value(config: Config.load)
+        Setting.resolve(env: ENV_VAR, config: config, config_key: CONFIG_KEY) || DEFAULT
+      end
+
+      # @param config [Config]
+      # @return [Hash] a fresh header hash, safe for a caller to #merge into.
+      def headers(config: Config.load) = { "User-Agent" => value(config: config) }
+    end
+  end
+end

data/lib/portage/cli/version.rb

@@ -1,5 +1,5 @@
 module Portage
   module Cli
-    VERSION = "0.6.4".freeze
+    VERSION = "0.7.3".freeze
   end
 end

data/lib/portage/cli/webmcp.rb

@@ -0,0 +1,25 @@
+module Portage
+  module Cli
+    # docs/plans/handoff-reconcile.md Phase 4 — `portage-ucp-webmcp` is
+    # optional at runtime, not in portage-cli's gemspec, same posture as
+    # `Decisions.available?` for `portage-ucp-decision` and
+    # `Resolver.build_adapter` for a platform adapter gem: `require`, then
+    # rescue LoadError, so `gem install portage-cli` stays light and only a
+    # caller who actually passes `Buy.new(webmcp_bridge:)` ever needs it
+    # installed.
+    module Webmcp
+      # @return [Boolean] whether portage-ucp-webmcp could be loaded.
+      #   Memoized: `require` runs once per process.
+      def self.available?
+        return @available unless @available.nil?
+
+        @available = begin
+          require "portage/ucp/webmcp"
+          true
+        rescue LoadError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/portage/cli/webmcp_checkout_mode.rb

@@ -0,0 +1,28 @@
+require_relative "config"
+require_relative "setting"
+
+module Portage
+  module Cli
+    # docs/plans/handoff-reconcile.md Phase 4 — how `Buy`'s optional WebMCP
+    # path (see Webmcp, Buy#webmcp_flow) finishes a checkout it built in the
+    # browser. Same Setting precedence as HandoffSpendMode: no CLI flag (a
+    # WebMCP bridge is an injected collaborator, not something a shell
+    # invocation can name), so just PORTAGE_WEBMCP_CHECKOUT_MODE >
+    # config.json's "webmcp_checkout_mode". Unset, or anything not in
+    # MODES, is `express_stop`, the only mode actually implemented — see
+    # Buy#webmcp_token_unsupported_report for why `token` isn't yet.
+    module WebmcpCheckoutMode
+      ENV_VAR = "PORTAGE_WEBMCP_CHECKOUT_MODE".freeze
+      CONFIG_KEY = "webmcp_checkout_mode".freeze
+      MODES = %w[express_stop token].freeze
+      DEFAULT = "express_stop".freeze
+
+      module_function
+
+      def resolve(override: nil, config: Config.load)
+        mode = Setting.resolve(override: override, env: ENV_VAR, config: config, config_key: CONFIG_KEY)
+        MODES.include?(mode) ? mode : DEFAULT
+      end
+    end
+  end
+end