portage-cli 0.11.0 → 0.13.0

data/lib/portage/cli/find.rb

@@ -24,6 +24,12 @@ module Portage
     # search ranker and the purchase decision to `--yes` in one breath is how
     # you end up owning a counterfeit from a shop you've never heard of, so
     # picking a store stays an explicit act (see Cli.run_buy's `--store` gate).
+    #
+    # `store:` narrows the same pipeline to one store the caller already
+    # named — the live re-check of an index hit or an earlier offer. No
+    # search backend or OfferSource runs; the store is probed and its catalog
+    # searched, read-only, so its offers carry the same shape, `offer_ref`
+    # and history entry as any other find.
     class Find
       CART_CAP = "dev.ucp.shopping.cart".freeze
       CHECKOUT_CAP = "dev.ucp.shopping.checkout".freeze
@@ -43,8 +49,11 @@ module Portage
       #   candidate on it is never probed (see #call): it still surfaces as
       #   a candidate, marked `handoff_only: true`, so an agent can list it
       #   ("Amazon also sells this") without this process ever fetching it.
+      # @param store [String, nil] a store URL (see Find.store_origin): search
+      #   only that store, live, and skip every backend and OfferSource.
       def initialize(query:, limit: MAX_PROBES, max_price: nil, backends: nil, cache: nil, throttle: THROTTLE,
-                     offer_sources: nil, handoff_only: nil)
+                     offer_sources: nil, handoff_only: nil, store: nil)
+        @store = store
         @query = query.to_s
         @limit = [limit, MAX_PROBES].min
         @max_price = max_price
@@ -55,6 +64,27 @@ module Portage
         @handoff_only = handoff_only || HandoffOnly.new
       end
 
+      # The origin a `--store` value names: an http(s) URL (or a bare host,
+      # as `check` and `buy` accept) collapsed onto scheme://host[:port].
+      # @return [String, nil] nil for anything else, such as ftp:// or junk.
+      def self.store_origin(url)
+        text = url.to_s.strip
+        return nil if text.empty? || (text.include?("://") && !text.match?(%r{\Ahttps?://}i))
+
+        uri = URI.parse(text.include?("://") ? text : "https://#{text}")
+        origin_of_uri(uri)
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      def self.origin_of_uri(uri)
+        return nil unless uri.is_a?(URI::HTTP) && !uri.host.to_s.empty?
+
+        port = uri.port == uri.default_port ? "" : ":#{uri.port}"
+        "#{uri.scheme}://#{uri.host.downcase}#{port}"
+      end
+      private_class_method :origin_of_uri
+
       def call
         return report(message: "Nothing to search for — pass --query.") if @query.strip.empty?
 
@@ -88,6 +118,8 @@ module Portage
       # --- Step 1: ask the backends who might sell this ---
 
       def candidate_origins
+        return store_candidate if @store
+
         seen = {}
         @backends.each do |backend|
           urls_from(backend).each { |url| add_candidate(seen, backend, url) }
@@ -95,6 +127,15 @@ module Portage
         seen.values.first(@limit)
       end
 
+      # `--store`: the one candidate is the named store itself. A hand-off-only
+      # host stays a candidate, flagged, so #probe_candidates never fetches it.
+      def store_candidate
+        origin = self.class.store_origin(@store)
+        return [] unless origin
+
+        [{ origin: origin, source: "store", handoff_only: @handoff_only.host?(URI.parse(origin).host) }]
+      end
+
       # Keyed by host rather than by full origin: backends routinely hand back
       # both `http://` and `https://` for the same shop, and probing one host
       # twice over two schemes is a wasted request every time. https wins when
@@ -107,7 +148,8 @@ module Portage
         existing = seen[uri.host]
         return if existing && !upgradable?(existing, uri)
 
-        seen[uri.host] = { origin: origin_of(uri), source: existing ? existing[:source] : backend.name,
+        seen[uri.host] = { origin: OfferSources.origin_of(uri.to_s),
+                           source: existing ? existing[:source] : backend.name,
                            handoff_only: @handoff_only.host?(uri.host) }
       end
 
@@ -141,6 +183,8 @@ module Portage
       # #urls_from gives the URL backends. --max-price applies here exactly
       # as it does to a probed store's offers in #offer.
       def source_offers
+        return [] if @store
+
         offers = @offer_sources.flat_map do |source|
           source.offers(@query, limit: PER_STORE_RESULTS, context: BuyerContext.from_env)
         end
@@ -166,13 +210,6 @@ module Portage
         nil
       end
 
-      # Collapse every deep link a backend returns onto the origin, since
-      # that's the only thing `/.well-known/ucp` hangs off.
-      def origin_of(uri)
-        port = uri.port == uri.default_port ? "" : ":#{uri.port}"
-        "#{uri.scheme}://#{uri.host}#{port}"
-      end
-
       # --- Step 2: keep the ones that actually speak UCP ---
 
       # A cached *miss* is the only verdict that saves work here — a cached hit
@@ -281,6 +318,8 @@ module Portage
       end
 
       def no_candidates_message
+        return "#{@store.inspect} isn't an http(s) store URL." if @store
+
         names = @backends.map(&:name)
         return no_backends_message if names.empty?
 
@@ -312,6 +351,8 @@ module Portage
       end
 
       def summary(candidates, stores, offers)
+        return store_summary(candidates.first, stores, offers) if @store
+
         # Counted from the offers, not `stores`: an OfferSource's offers
         # come from stores that were never probed.
         selling = offers.map { |o| o[:store] }.uniq.length
@@ -320,6 +361,22 @@ module Portage
 
         "Checked #{candidates.length} store(s); none of them speak UCP."
       end
+
+      # The `--store` wording: say what happened to that one store, not "N
+      # stores".
+      def store_summary(candidate, stores, offers)
+        origin = candidate[:origin]
+        return "Found #{offers.length} offer(s) at #{origin}." if offers.any?
+        return handoff_only_message(origin) if candidate[:handoff_only]
+        return "#{origin} doesn't speak UCP, so there is no catalogue to search." if stores.empty?
+
+        "#{origin} speaks UCP but has nothing matching \"#{@query}\"."
+      end
+
+      def handoff_only_message(origin)
+        "#{origin} is a hand-off-only retailer: Portage never fetches it, so it wasn't searched. " \
+          "Open the site yourself."
+      end
     end
   end
 end

data/lib/portage/cli/generate/agent_profile.rb

@@ -178,7 +178,7 @@ module Portage
         end
 
         # Raw uncompressed EC point encoding: 0x04 || x (32 bytes) || y (32
-        # bytes) for P-256 — see Portage::Ucp::Security::Signature::CURVES,
+        # bytes) for P-256 — see Portage::Ucp::Security::EcJwk::CURVES,
         # which decodes the same layout in reverse when verifying.
         def coordinates(pkey)
           octets = pkey.public_key.to_bn.to_s(2)

data/lib/portage/cli/handoff_agents.rb

@@ -1,10 +1,9 @@
 require "json"
-require "net/http"
 require "open3"
 require "timeout"
 require "uri"
-require "portage/ucp/support/connection"
 require_relative "config"
+require_relative "notifier"
 require_relative "user_agent"
 
 module Portage
@@ -150,12 +149,13 @@ module Portage
         def excerpt(stderr, stdout) = (stderr.to_s.empty? ? stdout.to_s : stderr.to_s).strip[0, BODY_EXCERPT]
       end
 
-      # POSTs the payload as JSON — https only, same connection helper and
-      # short timeout as Notifier, failures swallowed into the return
-      # value rather than raised.
+      # POSTs the payload as JSON — https only, through Notifier.post_json
+      # (same connection helper as --notify-webhook, with a longer timeout),
+      # failures swallowed into the return value rather than raised. Never
+      # Notifier#call itself: that falls back to PORTAGE_NOTIFY_WEBHOOK_URL
+      # or config, so a blank agent URL would post to the global webhook.
       class Webhook
         TIMEOUT = 10
-        BODY_EXCERPT = 200
 
         def initialize(url)
           @url = url.to_s
@@ -164,21 +164,7 @@ module Portage
         def call(payload)
           return "agent webhook must be https" unless @url.start_with?("https://")
 
-          response = post(URI(@url), JSON.generate(payload))
-          return nil if response.is_a?(Net::HTTPSuccess)
-
-          "agent webhook answered #{response.code}: #{response.body.to_s[0, BODY_EXCERPT]}"
-        rescue StandardError => e
-          "agent webhook POST failed: #{e.message}"
-        end
-
-        private
-
-        def post(uri, body)
-          Portage::Ucp::Support::Connection.start(uri, route: :notify, open_timeout: TIMEOUT,
-                                                       read_timeout: TIMEOUT) do |http|
-            http.post(uri.request_uri, body, UserAgent.headers.merge("Content-Type" => "application/json"))
-          end
+          Notifier.post_json(@url, payload, timeout: TIMEOUT, label: "agent webhook")
         end
       end
     end

data/lib/portage/cli/handoff_reconciler.rb

@@ -4,10 +4,9 @@ require "portage/ucp"
 require "portage/ucp/client"
 require "portage/ucp/journal"
 require_relative "user_agent"
-require_relative "homepage_fetch"
+require_relative "adapter_session"
 require_relative "handoff_spend_mode"
 require_relative "reconcile_notifier"
-require_relative "permissive_authenticator"
 require_relative "handoff_only"
 require_relative "handoff_reconciler/wire_adapters"
 
@@ -230,7 +229,7 @@ module Portage
         raise ReconnectError, "#{uri.host} is hand-off only — never reconciled automatically" \
           if @handoff_only.host?(uri.host)
 
-        native_session(uri) || adapter_session(uri) ||
+        native_session(uri) || AdapterSession.call(uri) ||
           raise(ReconnectError, "no automated path back into #{store_url}")
       end
 
@@ -239,25 +238,6 @@ module Portage
       rescue Portage::Ucp::Client::DiscoveryError
         nil
       end
-
-      # Mirrors Buy's own own-store loopback fallback (#adapter_flow) — a
-      # later process re-discovers the platform from the homepage the same
-      # way, and must not assume the original process's session or
-      # credentials still exist, only that this platform's env vars are
-      # still set (see the plan's non-negotiable constraint).
-      def adapter_session(uri)
-        body, headers = HomepageFetch.call(uri)
-        platform = body && Portage::Ucp::Resolver.detect_platform(body, headers)
-        return nil unless platform
-
-        env = Portage::Ucp::Resolver.env_for(platform)
-        return nil unless Portage::Ucp::Resolver.missing_env(platform, env).empty?
-
-        adapter = Portage::Ucp::Resolver.build_adapter(platform, env)
-        Portage::Ucp::Client.for_adapter(adapter, authenticator: PermissiveAuthenticator.new)
-      rescue StandardError
-        nil
-      end
     end
   end
 end

data/lib/portage/cli/homepage_fetch.rb

@@ -13,21 +13,23 @@ module Portage
     module HomepageFetch
       REDIRECT_LIMIT = 5
 
+      # @param route [Symbol] Support::Connection route for every hop,
+      #   redirects included (:store, or :payment for PaymentMethods).
       # @return [Array(String, Hash), Array(nil, Hash)] the body and response
       #   headers, or [nil, {}] on any failure/redirect exhaustion — same
       #   "no automated path, not a crash" posture as the rest of the buy
       #   flow.
-      def self.call(uri, limit: REDIRECT_LIMIT)
+      def self.call(uri, limit: REDIRECT_LIMIT, route: :store)
         return [nil, {}] if limit.zero?
 
-        response = Portage::Ucp::Support::Connection.start(uri, route: :store, open_timeout: 5,
+        response = Portage::Ucp::Support::Connection.start(uri, route: route, open_timeout: 5,
                                                                 read_timeout: 5) do |http|
           http.get(uri.request_uri, UserAgent.headers)
         end
 
         case response
         when Net::HTTPRedirection
-          call(URI.join(uri, response["location"]), limit: limit - 1)
+          call(URI.join(uri, response["location"]), limit: limit - 1, route: route)
         when Net::HTTPSuccess
           [response.body, response.to_hash]
         else

data/lib/portage/cli/index/builder.rb

@@ -5,6 +5,7 @@ require_relative "../user_agent"
 require_relative "../classifier"
 require_relative "../probe_cache"
 require_relative "../handoff_only"
+require_relative "../offer_sources"
 require_relative "store"
 require_relative "product_store"
 require_relative "known_cache"
@@ -103,7 +104,7 @@ module Portage
         # Opt-in: a crawl is up to 21 more requests and 20s of pauses, where
         # a plain add is one probe.
         def add(url, crawl: false)
-          origin = origin_of(url)
+          origin = OfferSources.origin_of(url)
           return { added: false, message: "Not a valid http(s) URL: #{url}" } unless origin
           return store_manual_handoff_only(origin) if handoff_only_origin?(origin)
 
@@ -356,16 +357,6 @@ module Portage
         def progress(message)
           @out&.puts(message)
         end
-
-        def origin_of(url)
-          uri = URI.parse(url.to_s)
-          return nil unless uri.host && uri.scheme.to_s.start_with?("http")
-
-          port = uri.port == uri.default_port ? "" : ":#{uri.port}"
-          "#{uri.scheme}://#{uri.host}#{port}"
-        rescue URI::InvalidURIError
-          nil
-        end
       end
     end
   end

data/lib/portage/cli/index/known_cache.rb

@@ -5,7 +5,6 @@ require "fileutils"
 require "timeout"
 require "portage/ucp/support/connection"
 
-require_relative "../known_stores_url"
 require_relative "../user_agent"
 
 module Portage
@@ -32,6 +31,14 @@ module Portage
         STORES_PATH = File.join(Dir.home, ".portage", "index", "known-stores.json").freeze
         PRODUCTS_PATH = File.join(Dir.home, ".portage", "index", "known-products.json").freeze
 
+        # Published on the same jsdelivr `@main` channel AgentProfileUrl
+        # uses for the agent profile: free GitHub, no Actions, so a new
+        # entry reaches every install on its next refresh as soon as a PR
+        # merges, with no gem/brew release to wait on.
+        BASE_URL = "https://cdn.jsdelivr.net/gh/tomtom87/Portage@main/portage-cli/known-stores".freeze
+        STORES_URL = "#{BASE_URL}/stores.json".freeze
+        PRODUCTS_URL = "#{BASE_URL}/products.json".freeze
+
         STALE_AFTER = 7 * 24 * 60 * 60
         TIMEOUT = 5
 
@@ -44,7 +51,7 @@ module Portage
         FORBIDDEN_FIELDS = %w[price amount stock].freeze
 
         def initialize(stores_path: STORES_PATH, products_path: PRODUCTS_PATH,
-                       stores_url: KnownStoresUrl::STORES, products_url: KnownStoresUrl::PRODUCTS)
+                       stores_url: STORES_URL, products_url: PRODUCTS_URL)
           @stores_path = stores_path
           @products_path = products_path
           @stores_url = stores_url

data/lib/portage/cli/index/sources/stores_file.rb

@@ -1,6 +1,7 @@
 require "uri"
 
 require_relative "../../search_backends"
+require_relative "../../offer_sources"
 
 module Portage
   module Cli
@@ -36,21 +37,11 @@ module Portage
           private
 
           def sighting_for(url)
-            origin = origin_of(url)
+            origin = OfferSources.origin_of(url)
             return nil unless origin
 
             { origin: origin, url: nil, title: nil, brand: nil, gtin: nil }
           end
-
-          def origin_of(url)
-            uri = URI.parse(url.to_s)
-            return nil unless uri.host && uri.scheme.to_s.start_with?("http")
-
-            port = uri.port == uri.default_port ? "" : ":#{uri.port}"
-            "#{uri.scheme}://#{uri.host}#{port}"
-          rescue URI::InvalidURIError
-            nil
-          end
         end
       end
     end

data/lib/portage/cli/index/sources/wikidata.rb

@@ -5,6 +5,7 @@ require "timeout"
 require "portage/ucp/support/connection"
 
 require_relative "../../user_agent"
+require_relative "../../offer_sources"
 
 module Portage
   module Cli
@@ -73,21 +74,11 @@ module Portage
 
           def sighting_for(row)
             url = row.dig("website", "value")
-            origin = origin_of(url)
+            origin = OfferSources.origin_of(url)
             return nil unless origin
 
             { origin: origin, url: url, title: nil, brand: row.dig("itemLabel", "value"), gtin: nil }
           end
-
-          def origin_of(url)
-            uri = URI.parse(url.to_s)
-            return nil unless uri.host && uri.scheme.to_s.start_with?("http")
-
-            port = uri.port == uri.default_port ? "" : ":#{uri.port}"
-            "#{uri.scheme}://#{uri.host}#{port}"
-          rescue URI::InvalidURIError
-            nil
-          end
         end
       end
     end

data/lib/portage/cli/install_doctor.rb

@@ -3,7 +3,8 @@ require_relative "version"
 
 module Portage
   module Cli
-    # Phase 4 of docs/plans/homebrew-distribution.md's `doctor` checks: how
+    # Phase 4 of homebrew-distribution.md's `doctor` checks (see
+    # https://github.com/tomtom87/Portage/blob/d51200f/docs/plans/homebrew-distribution.md): how
     # this copy of portage-cli was installed (Homebrew formula or plain
     # `gem install`), which Ruby it runs on, which first-party adapter gems
     # it can load, and whether the `portage` a shell would actually run is

data/lib/portage/cli/notifier.rb

@@ -55,21 +55,25 @@ module Portage
       def call(payload)
         return nil unless enabled?
 
-        response = post(URI(webhook_url), JSON.generate(payload))
-        return nil if response.is_a?(Net::HTTPSuccess)
-
-        "webhook answered #{response.code}: #{response.body.to_s[0, BODY_EXCERPT]}"
-      rescue StandardError => e
-        "webhook POST failed: #{e.message}"
+        self.class.post_json(webhook_url, payload, timeout: TIMEOUT, label: "webhook")
       end
 
-      private
-
-      def post(uri, body)
-        Portage::Ucp::Support::Connection.start(uri, route: :notify, open_timeout: TIMEOUT,
-                                                     read_timeout: TIMEOUT) do |http|
-          http.post(uri.request_uri, body, UserAgent.headers.merge("Content-Type" => "application/json"))
+      # The one JSON POST both this and HandoffAgents::Webhook make, on the
+      # :notify route. `label` starts each failure message.
+      #
+      # @return [String, nil] the failure message, or nil on any 2xx.
+      def self.post_json(url, payload, timeout:, label:)
+        uri = URI(url)
+        response = Portage::Ucp::Support::Connection.start(uri, route: :notify, open_timeout: timeout,
+                                                                read_timeout: timeout) do |http|
+          http.post(uri.request_uri, JSON.generate(payload),
+                    UserAgent.headers.merge("Content-Type" => "application/json"))
         end
+        return nil if response.is_a?(Net::HTTPSuccess)
+
+        "#{label} answered #{response.code}: #{response.body.to_s[0, BODY_EXCERPT]}"
+      rescue StandardError => e
+        "#{label} POST failed: #{e.message}"
       end
     end
   end

data/lib/portage/cli/offer_sources.rb

@@ -63,9 +63,8 @@ module Portage
       end
 
       # Shared by every retailer source below: an offer's `store` is the
-      # origin of the item URL the API itself returned, same idea as
-      # ShopifyCatalog#origin_of — kept as one module method instead of
-      # four copies.
+      # origin of the item URL the API itself returned. The index builder
+      # and its sources use it too, rather than keeping their own copies.
       def self.origin_of(url)
         uri = URI.parse(url.to_s)
         return nil unless uri.host && uri.scheme.to_s.start_with?("http")
@@ -142,7 +141,7 @@ module Portage
 
         def offer(product)
           variant = Array(product["variants"]).first
-          origin = variant && origin_of(variant["url"])
+          origin = variant && OfferSources.origin_of(variant["url"])
           return nil unless origin
 
           amount, currency = price_of(product)
@@ -152,16 +151,6 @@ module Portage
           )
         end
 
-        def origin_of(url)
-          uri = URI.parse(url.to_s)
-          return nil unless uri.host && uri.scheme.to_s.start_with?("http")
-
-          port = uri.port == uri.default_port ? "" : ":#{uri.port}"
-          "#{uri.scheme}://#{uri.host}#{port}"
-        rescue URI::InvalidURIError
-          nil
-        end
-
         # Same wire shape as Find#price_of — a `price_range.min` Money
         # object, wire-hash-keyed same as every result that's passed through
         # Dispatcher#wrap's `to_wire_h`.

data/lib/portage/cli/payment_methods.rb

@@ -2,19 +2,13 @@ require "json"
 require "fileutils"
 require "securerandom"
 require "uri"
-require "net/http"
 require "portage/ucp"
 require "portage/ucp/client"
-require "portage/ucp/support/connection"
 
-# Buy::PermissiveAuthenticator (adapter-loopback auth) is used by
-# #adapter_session below — not require_relative'd here to avoid a load
-# cycle (buy.rb will require this file too, for PaymentMethods.default);
-# cli.rb requires "cli/buy" before "cli/payment_methods", so it's already
-# loaded by the time #enroll actually runs.
 require_relative "payment_methods/keychain_backend"
 require_relative "payment_methods/secret_service_backend"
 require_relative "payment_methods/env_backend"
+require_relative "adapter_session"
 require_relative "user_agent"
 require_relative "handoff_only"
 
@@ -220,7 +214,8 @@ module Portage
       # Same native-manifest-first, own-store-adapter-fallback discovery as
       # Buy#call — duplicated rather than extracted since Buy's version is
       # entangled with cart/checkout-specific branching this only needs the
-      # session object from.
+      # session object from. The adapter fallback itself is AdapterSession,
+      # shared with HandoffReconciler.
       def discover_session(url)
         native = Portage::Ucp::Client.discover(url, headers: UserAgent.headers)
         native if native
@@ -228,29 +223,11 @@ module Portage
         adapter_session(url)
       end
 
+      # The homepage fetch stays on the :payment route (forced direct unless
+      # a proxy is named for it), redirects included.
       def adapter_session(url)
-        uri = URI.parse(url.to_s =~ %r{\Ahttps?://}i ? url.to_s : "https://#{url}")
-        body, headers = fetch_homepage(uri)
-        platform = body && Portage::Ucp::Resolver.detect_platform(body, headers)
-        return nil unless platform
-
-        env = Portage::Ucp::Resolver.env_for(platform)
-        return nil if Portage::Ucp::Resolver.missing_env(platform, env).any?
-
-        adapter = Portage::Ucp::Resolver.build_adapter(platform, env)
-        Portage::Ucp::Client.for_adapter(adapter, authenticator: Buy::PermissiveAuthenticator.new)
-      rescue StandardError
-        nil
-      end
-
-      def fetch_homepage(uri)
-        response = Portage::Ucp::Support::Connection.start(uri, route: :payment, open_timeout: 5,
-                                                                read_timeout: 5) do |http|
-          http.get(uri.request_uri, UserAgent.headers)
-        end
-        response.is_a?(Net::HTTPSuccess) ? [response.body, response.to_hash] : [nil, {}]
-      rescue StandardError
-        [nil, {}]
+        uri = normalized_uri(url)
+        uri && AdapterSession.call(uri, route: :payment)
       end
 
       def payment_enrollment_advertised?(session)

data/lib/portage/cli/reconcile_notifier.rb

@@ -1,6 +1,7 @@
 require_relative "notifier"
 require_relative "macos_notifier"
 require_relative "reconcile_notify"
+require_relative "money"
 
 module Portage
   module Cli
@@ -55,11 +56,7 @@ module Portage
         parts.join(" — ")
       end
 
-      def format_amount(amount, currency)
-        return nil unless amount
-
-        "#{format('%.2f', amount / 100.0)}#{" #{currency}" if currency}"
-      end
+      def format_amount(amount, currency) = amount && Money.format_amount(amount, currency)
     end
   end
 end

data/lib/portage/cli/setup_wizard/steps/env_keys_step.rb

@@ -0,0 +1,40 @@
+require_relative "../../dot_env"
+
+module Portage
+  module Cli
+    class SetupWizard
+      module Steps
+        # Shared body of the wizard steps that only prompt for a few env vars
+        # and write the answers to ~/.portage/.env (Shipping, SearchKeys,
+        # RetailerKeys). A subclass defines #title, #default_yes?, FIELDS
+        # ({ "ENV_VAR" => "label" }), #intro and #unchanged_message, and
+        # overrides #secret? for fields that must never echo back.
+        class EnvKeysStep
+          def initialize(prompt:) = @prompt = prompt
+
+          def call
+            @prompt.say(intro)
+            assignments = collect
+            return @prompt.say(unchanged_message) if assignments.empty?
+
+            path = DotEnv.update!(assignments)
+            @prompt.say("Saved #{assignments.keys.join(', ')} to #{path} (chmod 600).")
+          end
+
+          private
+
+          def fields = self.class::FIELDS
+          def secret?(_var) = false
+
+          def collect
+            fields.each_with_object({}) do |(var, label), assignments|
+              hint = ENV.fetch(var, nil).to_s.empty? ? "not set" : "already set"
+              answer = secret?(var) ? @prompt.ask_secret(label, hint: hint) : @prompt.ask(label, hint: hint)
+              assignments[var] = answer if answer
+            end
+          end
+        end
+      end
+    end
+  end
+end