@shopify/cli-kit 3.38.0 → 3.40.0

package/assets/cli-ruby/lib/shopify_cli/core/entry_point.rb

@@ -0,0 +1,64 @@
+require "shopify_cli"
+
+module ShopifyCLI
+  module Core
+    module EntryPoint
+      class << self
+        def call(args, ctx = Context.new)
+          show_warnings(ctx, args.join(" "))
+
+          ProjectType.load_all
+
+          task_registry = ShopifyCLI::Tasks::Registry
+
+          command, command_name, args = ShopifyCLI::Resolver.call(args)
+          executor = ShopifyCLI::Core::Executor.new(ctx, task_registry, log_file: ShopifyCLI.log_file)
+          ShopifyCLI::Core::Monorail.log(command_name, args) do
+            executor.call(command, command_name, args)
+          end
+        end
+
+        def show_warnings(ctx, args)
+          # Only instruct the user to update the CLI, or warn them that they're
+          # using CLI2 not CLI3, if they're running CLI2 directly. Otherwise the
+          # warnings will be confusing and/or incorrect.
+          return if Environment.run_as_subprocess?
+
+          show_sunset_warning(ctx, args)
+
+          if ctx.development? && !ctx.testing?
+            ctx.warn(
+              ctx.message(
+                "core.warning.development_version",
+                File.join(ShopifyCLI::ROOT, "bin", ShopifyCLI::TOOL_NAME)
+              )
+            )
+            # because `!ctx.new_version.nil?` will change the config by calling ::Config.set
+            # it's important to keep the checks in this order so that we don't trigger it while testing
+            # since changing the config will throw errors
+          elsif !ctx.testing? && !ctx.new_version.nil?
+            ctx.warn(ctx.message("core.warning.new_version", ShopifyCLI::VERSION, ctx.new_version))
+          end
+
+          if ShopifyCLI::Core::CliVersion.using_3_0?
+            ctx.warn(ctx.message("core.warning.in_3_0_directory"))
+          end
+        end
+
+        def show_sunset_warning(ctx, args)
+          return if ctx.testing?
+
+          if args.start_with?("app create") || args.start_with?("app extension create")
+            ctx.warn(ctx.message("core.warning.sunset_create_app"))
+          elsif args.start_with?("app")
+            ctx.warn(ctx.message("core.warning.sunset_app"))
+          elsif args.start_with?("theme")
+            ctx.warn(ctx.message("core.warning.sunset_theme"))
+          else
+            ctx.warn(ctx.message("core.warning.sunset"))
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/core/executor.rb

@@ -0,0 +1,23 @@
+require "shopify_cli"
+
+module ShopifyCLI
+  module Core
+    class Executor < CLI::Kit::Executor
+      ruby2_keywords def initialize(ctx, task_registry, *args)
+        @ctx = ctx || ShopifyCli::Context.new
+        @task_registry = task_registry || ShopifyCli::Tasks::TaskRegistry.new
+        super(*args)
+      end
+
+      def call(command, command_name, args)
+        command.task_registry = @task_registry
+        command.ctx = @ctx
+        with_traps do
+          with_logging do |_id|
+            command.call(args, command_name)
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/core/finalize.rb

@@ -0,0 +1,13 @@
+module ShopifyCLI
+  module Core
+    # This class is just a dummy to make sure that we don't trigger warnings on the first time the updated code runs.
+    # The old code would try to call the Finalizer after it is done updating, which would then trigger an autoload of
+    # this class and fail.
+    module Finalize
+      class << self
+        def deliver!
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/core/help_resolver.rb

@@ -0,0 +1,20 @@
+require "cli/kit"
+
+module ShopifyCLI
+  module Core
+    class HelpResolver < CLI::Kit::Resolver
+      def call(args)
+        args = args.dup
+        return super(args) unless args.first
+        if args.first.include?("-h") || args.first.include?("--help")
+          help = Commands::Help
+          help.ctx = Context.new
+          help.call([], nil)
+          raise ShopifyCLI::AbortSilent
+        else
+          super(args)
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/core/monorail.rb

@@ -0,0 +1,122 @@
+require "json"
+require "net/http"
+require "time"
+require "rbconfig"
+
+module ShopifyCLI
+  module Core
+    module Monorail
+      ENDPOINT_URI = URI.parse("https://monorail-edge.shopifysvc.com/v1/produce")
+      INVOCATIONS_SCHEMA = "app_cli_command/5.0"
+
+      # Extra hash of data that will be sent in the payload
+      @metadata = {}
+
+      class << self
+        attr_accessor :metadata
+
+        def log(name, args, &block) # rubocop:disable Lint/UnusedMethodArgument
+          command, command_name = Commands::Registry.lookup_command(name)
+          full_command = self.full_command(command, args, resolved_command: [command_name])
+
+          start_time = now_in_milliseconds
+          err = nil
+
+          begin
+            yield
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            err = e
+            raise
+          ensure
+            # If there's an error, we don't prompt from here and we let the exception
+            # reporter do that.
+            if report?(prompt: err.nil?)
+              send_event(start_time, full_command, args - full_command, err&.message)
+            end
+          end
+        end
+
+        def full_command(command, args, resolved_command:)
+          resolved_command = resolved_command.dup
+          if command
+            subcommand, subcommand_name = command.subcommand_registry.lookup_command(args.first)
+            resolved_command << subcommand_name if subcommand
+            if subcommand&.subcommand_registry
+              resolved_command = full_command(subcommand, args.drop(1), resolved_command: resolved_command)
+            end
+          end
+          resolved_command
+        end
+
+        private
+
+        def now_in_milliseconds
+          (Time.now.utc.to_f * 1000).to_i
+        end
+
+        def report?(prompt:)
+          return true if Environment.send_monorail_events?
+          ReportingConfigurationController.check_or_prompt_report_automatically(source: :usage, prompt: prompt)
+        end
+
+        def send_event(start_time, commands, args, err = nil)
+          end_time = now_in_milliseconds
+          headers = {
+            'Content-Type': "application/json; charset=utf-8",
+            'X-Monorail-Edge-Event-Created-At-Ms': start_time.to_s,
+            'X-Monorail-Edge-Event-Sent-At-Ms': end_time.to_s,
+          }
+          begin
+            Net::HTTP.start(
+              ENDPOINT_URI.host,
+              ENDPOINT_URI.port,
+              # timeouts for opening a connection, reading, writing (in seconds)
+              open_timeout: 0.2, read_timeout: 0.2, write_timeout: 0.2,
+              use_ssl: ENDPOINT_URI.scheme == "https"
+            ) do |http|
+              payload = build_payload(start_time, end_time, commands, args, err)
+              post = Net::HTTP::Post.new(ENDPOINT_URI.request_uri, headers)
+              post.body = JSON.dump(payload)
+              http.request(post)
+            end
+          rescue
+            # silently fail on errors, fire-and-forget approach
+          end
+        end
+
+        def build_payload(start_time, end_time, commands, args, err = nil)
+          {
+            schema_id: INVOCATIONS_SCHEMA,
+            payload: {
+              project_type: project_type_from_dir_or_cmd(commands[0]).to_s,
+              command: commands.join(" "),
+              args: args.join(" "),
+              time_start: start_time,
+              time_end: end_time,
+              total_time: end_time - start_time,
+              success: err.nil?,
+              error_message: err,
+              uname: RbConfig::CONFIG["host"],
+              cli_version: ShopifyCLI::VERSION,
+              ruby_version: RUBY_VERSION,
+              is_employee: ShopifyCLI::Shopifolk.acting_as_shopify_organization?,
+            }.tap do |payload|
+              payload[:api_key] = metadata.delete(:api_key)
+              payload[:partner_id] = metadata.delete(:organization_id) || ShopifyCLI::DB.get(:organization_id)
+              if Project.has_current?
+                project = Project.current(force_reload: true)
+                payload[:api_key] = project.env&.api_key
+                payload[:partner_id] = project.config["organization_id"]
+              end
+              payload[:metadata] = JSON.dump(metadata) unless metadata.empty?
+            end,
+          }
+        end
+
+        def project_type_from_dir_or_cmd(command)
+          Project.current_project_type || (command unless ShopifyCLI::Commands.core_command?(command)) || nil
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/core.rb

@@ -0,0 +1,9 @@
+module ShopifyCLI
+  module Core
+    autoload :EntryPoint, "shopify_cli/core/entry_point"
+    autoload :Executor, "shopify_cli/core/executor"
+    autoload :HelpResolver, "shopify_cli/core/help_resolver"
+    autoload :Monorail, "shopify_cli/core/monorail"
+    autoload :CliVersion, "shopify_cli/core/cli_version"
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/db.rb

@@ -0,0 +1,114 @@
+require "pstore"
+require "forwardable"
+
+module ShopifyCLI
+  # Persists transient data like access tokens that may be cleared
+  # when user clears their session
+  #
+  # All of the instance methods documented here can be used as class methods. All class
+  # methods are forwarded to a new instance of the database, pointing at the default
+  # path.
+  class DB
+    extend SingleForwardable
+    def_delegators :new, :keys, :exists?, :set, :get, :del, :clear
+
+    attr_reader :db # :nodoc:
+
+    def initialize(path: File.join(ShopifyCLI.cache_dir, ".db.pstore")) # :nodoc:
+      @db = PStore.new(path)
+    end
+
+    # Get all keys that exist in the database.
+    #
+    # #### Returns
+    # - `keys`: an array of string or symbol keys that exist in the database
+    #
+    # #### Usage
+    #
+    #   ShopifyCLI::DB.keys
+    #
+    def keys
+      db.transaction(true) { db.roots }
+    end
+
+    # Check to see if a key exists in the database, the key will only exist if it
+    # has a value so if the key exists then there is also a value.
+    #
+    # #### Parameters
+    # - `key`: a string or a symbol representation of a key that is stored in the DB
+    #
+    # #### Returns
+    # - `exists`: a boolean value if the key exists in the database
+    #
+    # #### Usage
+    #
+    #   exists = ShopifyCLI::DB.exists?('shopify_exchange_token')
+    #
+    def exists?(key)
+      db.transaction(true) { db.root?(key) }
+    end
+
+    # Persist a value by key in the local storage
+    #
+    # #### Parameters
+    # - `**args`: a hash of keys and values to persist in the database
+    #
+    # #### Usage
+    #
+    #   ShopifyCLI::DB.set(shopify_exchange_token: 'token', metric_consent: true)
+    #
+    def set(**args)
+      db.transaction do
+        args.each do |key, val|
+          if val.nil?
+            db.delete(key)
+          else
+            db[key] = val
+          end
+        end
+      end
+    end
+
+    # Gets a value from the DB that is associated with the supplied key
+    #
+    # #### Parameters
+    # - `key`: a string or a symbol representation of a key that is stored in the DB
+    #
+    # #### Returns
+    # - `value`: will be the previously saved value or nil if the key does not exist
+    #   in the database.
+    #
+    # #### Usage
+    #
+    #   ShopifyCLI::DB.get(:shopify_exchange_token)
+    #
+    def get(key)
+      val = db.transaction(true) { db[key] }
+      val = yield if val.nil? && block_given?
+      val
+    end
+
+    # Deletes a value from the local storage
+    #
+    # #### Parameters
+    # - `*args`: an array of strings or symbols that are keys to be removed from the database
+    #
+    # #### Usage
+    #
+    #   ShopifyCLI::DB.del(:shopify_exchange_token)
+    #
+    def del(*args)
+      db.transaction { args.each { |key| db.delete(key) } }
+    end
+
+    # Drops all keys from the database.
+    #
+    # #### Usage
+    #
+    #   ShopifyCLI::DB.clear
+    #
+    def clear
+      del(*keys)
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/environment.rb

@@ -0,0 +1,198 @@
+require "semantic/semantic"
+
+module ShopifyCLI
+  # The environment module provides an interface to get information from
+  # the environment in which the CLI runs
+  module Environment
+    TRUTHY_ENV_VARIABLE_VALUES = ["1", "true", "TRUE", "yes", "YES"]
+    SPIN_OVERRIDE_ENV_NAMES = [
+      Constants::EnvironmentVariables::SPIN_WORKSPACE,
+      Constants::EnvironmentVariables::SPIN_NAMESPACE,
+      Constants::EnvironmentVariables::SPIN_HOST,
+    ]
+    # https://github.com/Shopify/themekit-access/blob/4c3c917d78443160dcf24376a8b5ac6b9bef0bcd/app/models/password_token.rb#L8
+    THEME_ACCESS_PASSWORD_PREFIX = "shptka_"
+
+    def self.ruby_version(context: Context.new)
+      output, status = context.capture2e("ruby", "--version")
+      raise ShopifyCLI::Abort, context.message("core.errors.missing_ruby") unless status.success?
+      version = output.match(/ruby (\d+\.\d+\.\d+)/)[1]
+      ::Semantic::Version.new(version)
+    end
+
+    def self.node_version(context: Context.new)
+      output, status = context.capture2e("node", "--version")
+      raise ShopifyCLI::Abort, context.message("core.errors.missing_node") unless status.success?
+      version = output.match(/v(\d+\.\d+\.\d+)/)[1]
+      ::Semantic::Version.new(version)
+    end
+
+    def self.npm_version(context: Context.new)
+      output, status = context.capture2e("npm", "--version")
+      raise ShopifyCLI::Abort, context.message("core.errors.missing_npm") unless status.success?
+      version = output.match(/(\d+\.\d+\.\d+)/)[1]
+      ::Semantic::Version.new(version)
+    end
+
+    def self.rails_version(context: Context.new)
+      output, status = context.capture2e("rails", "--version")
+      context.abort(context.message("core.app.create.rails.error.install_failure", "rails")) unless status.success?
+      version = output.match(/Rails (\d+\.\d+\.\d+)/)[1]
+      ::Semantic::Version.new(version)
+    end
+
+    def self.interactive=(interactive)
+      @interactive = interactive
+    end
+
+    def self.interactive?(env_variables: ENV)
+      if env_variables.key?(Constants::EnvironmentVariables::TTY)
+        env_variable_truthy?(
+          Constants::EnvironmentVariables::TTY,
+          env_variables: env_variables
+        )
+      else
+        @interactive ||= STDIN.tty?
+      end
+    end
+
+    def self.development?(env_variables: ENV)
+      env_variable_truthy?(
+        Constants::EnvironmentVariables::DEVELOPMENT,
+        env_variables: env_variables
+      )
+    end
+
+    def self.use_local_partners_instance?(env_variables: ENV)
+      env_variable_truthy?(
+        Constants::EnvironmentVariables::LOCAL_PARTNERS,
+        env_variables: env_variables
+      )
+    end
+
+    def self.print_stacktrace?(env_variables: ENV)
+      env_variable_truthy?(
+        Constants::EnvironmentVariables::STACKTRACE,
+        env_variables: env_variables
+      ) || development?(env_variables: env_variables)
+    end
+
+    def self.test?(env_variables: ENV)
+      env_variable_truthy?(
+        Constants::EnvironmentVariables::TEST,
+        env_variables: env_variables
+      )
+    end
+
+    def self.acceptance_test?(env_variables: ENV)
+      env_variable_truthy?(
+        Constants::EnvironmentVariables::ACCEPTANCE_TEST,
+        env_variables: env_variables
+      )
+    end
+
+    def self.print_backtrace?(env_variables: ENV)
+      env_variable_truthy?(
+        Constants::EnvironmentVariables::BACKTRACE,
+        env_variables: env_variables
+      )
+    end
+
+    def self.partners_domain(env_variables: ENV)
+      if use_local_partners_instance?(env_variables: env_variables)
+        "partners.myshopify.io"
+      elsif use_spin?(env_variables: env_variables)
+        "partners.#{spin_url(env_variables: env_variables)}"
+      else
+        "partners.shopify.com"
+      end
+    end
+
+    def self.spin_url_override(env_variables: ENV)
+      tokens = SPIN_OVERRIDE_ENV_NAMES.map do |name|
+        env_variables[name]
+      end
+
+      return if tokens.all?(&:nil?)
+
+      if tokens.any?(&:nil?)
+        raise "To manually target a spin instance, you must set #{SPIN_OVERRIDE_ENV_NAMES}"
+      else
+        tokens.join(".")
+      end
+    end
+
+    def self.use_spin?(env_variables: ENV)
+      env_variable_truthy?(
+        Constants::EnvironmentVariables::SPIN,
+        env_variables: env_variables
+      ) || env_variable_truthy?(
+        Constants::EnvironmentVariables::SPIN_PARTNERS,
+        env_variables: env_variables
+      )
+    end
+
+    def self.spin_url(env_variables: ENV)
+      override = spin_url_override(env_variables: env_variables)
+      return override unless override.nil?
+
+      spin_response = if env_variables.key?(
+        Constants::EnvironmentVariables::SPIN_INSTANCE
+      )
+        spin_show
+      else
+        spin_show(latest: true)
+      end
+
+      begin
+        instance = JSON.parse(spin_response)
+        raise "Missing key 'fqdn' from spin show. Actual response: #{instance}" unless instance.include?("fqdn")
+        instance["fqdn"]
+      rescue => e
+        raise "Failed to infer spin environment from spin show response #{spin_response}: #{e}"
+      end
+    end
+
+    def self.spin_show(latest: false)
+      latest ? %x(spin show --latest --json) : %x(spin show --json)
+    end
+
+    def self.send_monorail_events?(env_variables: ENV)
+      env_variable_truthy?(
+        Constants::EnvironmentVariables::MONORAIL_REAL_EVENTS,
+        env_variables: env_variables
+      ) && !run_as_subprocess?(env_variables: env_variables)
+    end
+
+    def self.auth_token(env_variables: ENV)
+      env_variables[Constants::EnvironmentVariables::AUTH_TOKEN]
+    end
+
+    def self.admin_auth_token(env_variables: ENV)
+      env_variables[Constants::EnvironmentVariables::ADMIN_AUTH_TOKEN]
+    end
+
+    def self.storefront_renderer_auth_token(env_variables: ENV)
+      env_variables[Constants::EnvironmentVariables::STOREFRONT_RENDERER_AUTH_TOKEN]
+    end
+
+    def self.store(env_variables: ENV)
+      env_variables[Constants::EnvironmentVariables::STORE]
+    end
+
+    def self.env_variable_truthy?(variable_name, env_variables: ENV)
+      TRUTHY_ENV_VARIABLE_VALUES.include?(env_variables[variable_name.to_s])
+    end
+
+    def self.run_as_subprocess?(env_variables: ENV)
+      env_variable_truthy?(
+        Constants::EnvironmentVariables::RUN_AS_SUBPROCESS,
+        env_variables: env_variables
+      )
+    end
+
+    def self.theme_access_password?
+      admin_auth_token&.start_with?(THEME_ACCESS_PASSWORD_PREFIX)
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/exception_reporter.rb

@@ -0,0 +1,79 @@
+module ShopifyCLI
+  module ExceptionReporter
+    def self.report_error_silently(error)
+      return unless ReportingConfigurationController.reporting_enabled?
+      report_to_bugsnag(error: error)
+    end
+
+    def self.report(error, _logs = nil, _api_key = nil, custom_metadata = {})
+      context = ShopifyCLI::Context.new
+      unless ShopifyCLI::Environment.development?
+        context.puts(context.message("core.error_reporting.unhandled_error.message"))
+        context.puts(context.message("core.error_reporting.unhandled_error.issue_message",
+          ShopifyCLI::GitHub::IssueURLGenerator.error_url(error)))
+      end
+
+      # Stack trace hint
+      unless ShopifyCLI::Environment.print_stacktrace?
+        context.puts(context.message("core.error_reporting.unhandled_error.stacktrace_message",
+          "#{ShopifyCLI::Constants::EnvironmentVariables::STACKTRACE}=1"))
+      end
+
+      context.puts("\n")
+
+      return unless reportable_error?(error)
+
+      return unless report?(context: context)
+      report_to_bugsnag(error: error, custom_metadata: custom_metadata)
+    end
+
+    def self.report_to_bugsnag(error:, custom_metadata: {})
+      ENV["BUGSNAG_DISABLE_AUTOCONFIGURE"] = "1"
+      require "bugsnag"
+
+      Bugsnag.configure do |config|
+        config.logger.level = ::Logger::ERROR
+        config.api_key = ShopifyCLI::Constants::Bugsnag::API_KEY
+        config.app_type = "shopify"
+        config.project_root = File.expand_path("../../..", __FILE__)
+        config.app_version = ShopifyCLI::VERSION
+        config.auto_capture_sessions = false
+      end
+
+      metadata = { rubyPlatform: RUBY_PLATFORM }
+      metadata.merge!(custom_metadata)
+
+      Bugsnag.notify(error) do |event|
+        event.add_metadata(:device, metadata)
+      end
+    rescue
+      nil
+    end
+
+    def self.report?(context:)
+      return true if ReportingConfigurationController.reporting_prompted? &&
+        ReportingConfigurationController.check_or_prompt_report_automatically(source: :uncaught_error)
+
+      report_error = report_error?(context: context)
+
+      unless ReportingConfigurationController.reporting_prompted?
+        ReportingConfigurationController.check_or_prompt_report_automatically(source: :uncaught_error)
+      end
+      report_error
+    end
+
+    def self.report_error?(context:)
+      return false if Environment.development?
+
+      CLI::UI::Prompt.ask(context.message("core.error_reporting.report_error.question")) do |handler|
+        handler.option(context.message("core.error_reporting.report_error.yes")) { |_| true }
+        handler.option(context.message("core.error_reporting.report_error.no")) { |_| false }
+      end
+    end
+
+    def self.reportable_error?(error)
+      is_abort = error.is_a?(ShopifyCLI::Abort) || error.is_a?(ShopifyCLI::AbortSilent)
+      !is_abort
+    end
+  end
+end