@shopify/cli-kit 3.39.0 → 3.40.0

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

@@ -0,0 +1,102 @@
+require "shopify_cli"
+
+module ShopifyCLI
+  ##
+  # ShopifyCLI::PHPDeps ensures that all PHP dependencies are installed for projects.
+  #
+  class PHPDeps
+    include SmartProperties
+
+    property! :ctx, accepts: ShopifyCLI::Context
+
+    ##
+    # Proxy to instance method ShopifyCLI::PHPDeps.new.install.
+    #
+    # #### Parameters
+    # - `ctx`: running context from your command
+    # - `verbose`: whether to run the installation tools in verbose mode
+    #
+    # #### Example
+    #
+    #   ShopifyCLI::PHPDeps.install(ctx)
+    #
+    def self.install(ctx, verbose = false)
+      new(ctx: ctx).install(verbose)
+    end
+
+    ##
+    # Installs all of a project's PHP dependencies using Composer.
+    #
+    # #### Parameters
+    # - `verbose`: whether to run the installation tools in verbose mode
+    #
+    # #### Example
+    #
+    #   # context is the running context for the command
+    #   ShopifyCLI::PHPDeps.new(context).install(true)
+    #
+    def install(verbose = false)
+      title = ctx.message("core.php_deps.installing")
+      success = ctx.message("core.php_deps.installed")
+      failure = ctx.message("core.php_deps.error.install_error")
+
+      CLI::UI::Frame.open(title, success_text: success, failure_text: failure) do
+        composer(verbose)
+      end
+    end
+
+    private
+
+    def composer(verbose = false)
+      cmd = %w(composer install)
+      cmd << "--quiet" unless verbose
+
+      run_install_command(cmd)
+    end
+
+    def run_install_command(cmd)
+      deps = parse_dependencies
+      errors = nil
+
+      spinner_title = ctx.message("core.php_deps.installing")
+      success = CLI::UI::Spinner.spin(spinner_title, auto_debrief: false) do |spinner|
+        _out, errors, status = CLI::Kit::System.capture3(*cmd, env: @ctx.env, chdir: ctx.root)
+        update_spinner_title_and_status(spinner, status, deps)
+      end
+
+      errors.lines.each { |e| ctx.puts e } unless success || errors.nil?
+
+      ctx.abort(ctx.message("core.php_deps.error.install", "Composer")) unless success
+      success
+    end
+
+    def update_spinner_title_and_status(spinner, status, deps)
+      if status.success?
+        spinner.update_title(ctx.message("core.php_deps.installed_count", deps.size))
+      else
+        spinner.update_title(ctx.message("core.php_deps.error.install_spinner_error", deps.size))
+        CLI::UI::Spinner::TASK_FAILED
+      end
+    end
+
+    def parse_dependencies
+      composer_json = File.join(ctx.root, "composer.json")
+      pkg =
+        begin
+          JSON.parse(File.read(composer_json))
+        rescue Errno::ENOENT, Errno::ENOTDIR
+          ctx.abort(ctx.message("core.php_deps.error.missing_package", composer_json))
+        end
+
+      %w(require require-dev).map do |key|
+        pkg.fetch(key, []).keys
+      end.flatten
+    rescue JSON::ParserError
+      ctx.puts(
+        ctx.message("core.php_deps.error.invalid_package", File.read(File.join(path, "composer.json"))),
+        error: true
+      )
+      raise ShopifyCLI::AbortSilent
+    end
+  end
+end

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

@@ -0,0 +1,228 @@
+require "fileutils"
+
+module ShopifyCLI
+  ##
+  # ProcessSupervision wraps a running process spawned by `exec` and keeps track
+  # if its `pid` and keeps a log file for it as well
+  class ProcessSupervision
+    # a string or a symbol to identify this process by
+    attr_reader :identifier
+    # process ID for the running process
+    attr_accessor :pid
+    # starttime of the process
+    attr_reader :time
+    # filepath to the pidfile for this process
+    attr_reader :pid_path
+    # filepath to the logfile for this process
+    attr_reader :log_path
+
+    class << self
+      def run_dir
+        # is the directory where the pid and logfile are kept
+        File.join(ShopifyCLI.cache_dir, "sv")
+      end
+
+      ##
+      # Will find and create a new instance of ProcessSupervision for a running process
+      # if it is currently running. It will return nil if the process is not running.
+      #
+      # #### Parameters
+      #
+      # * `identifier` - a string or a symbol that a process was started with
+      #
+      # #### Returns
+      #
+      # * `process` - ProcessSupervision instance if the process is running this
+      #   will be nil if the process is not running.
+      #
+      def for_ident(identifier)
+        pid, time = File.read(File.join(ShopifyCLI::ProcessSupervision.run_dir, "#{identifier}.pid")).split(":")
+        new(identifier, pid: Integer(pid), time: time)
+      rescue Errno::ENOENT
+        nil
+      end
+
+      ##
+      # will fork and spawn a new process that is separate from the current process.
+      # This process will keep running beyond the command running so be careful!
+      #
+      # #### Parameters
+      #
+      # * `identifier` - a string or symbol to identify the new process by.
+      # * `args` - a command to run, either a string or array of strings
+      # * `force_spawn` - whether we want the child process to be a spawn and not a fork, so it is terminated along with
+      #                   the parent
+      #
+      # #### Returns
+      #
+      # * `process` - ProcessSupervision instance if the process is running, this
+      #   will be nil if the process did not start.
+      #
+      def start(identifier, args, force_spawn: false)
+        return for_ident(identifier) if running?(identifier)
+
+        # Some systems don't support forking process without extra gems, so we resort to spawning a new child process -
+        # that means that it dies along with the original process if it is interrupted. If possible, we fork the process
+        # so that it doesn't have to be restarted on every run.
+        if Process.respond_to?(:fork) && !force_spawn
+          fork do
+            pid_file = new(identifier, pid: Process.pid)
+            pid_file.write
+            STDOUT.reopen(pid_file.log_path, "w")
+            STDERR.reopen(pid_file.log_path, "w")
+            STDIN.reopen("/dev/null", "r")
+            Process.setsid
+            exec(*args)
+          end
+        else
+          pid_file = new(identifier)
+
+          # Make sure the file exists and is empty, otherwise Windows fails
+          File.open(pid_file.log_path, "w") {}
+          pid = Process.spawn(
+            *args,
+            out: pid_file.log_path,
+            err: pid_file.log_path,
+            in: Context.new.windows? ? "nul" : "/dev/null",
+          )
+          pid_file.pid = pid
+          pid_file.write
+
+          Process.detach(pid)
+        end
+
+        sleep(0.1)
+        for_ident(identifier)
+      end
+
+      ##
+      # will attempt to shutdown a running process
+      #
+      # #### Parameters
+      #
+      # * `identifier` - a string or symbol to identify the new process by.
+      #
+      # #### Returns
+      #
+      # * `stopped` - [true, false]
+      #
+      def stop(identifier)
+        process = for_ident(identifier)
+        return false unless process
+        process.stop
+      end
+
+      ##
+      # will help identify if your process is still running in the background.
+      #
+      # #### Parameters
+      #
+      # * `identifier` - a string or symbol to identify the new process by.
+      #
+      # #### Returns
+      #
+      # * `running` - [true, false]
+      #
+      def running?(identifier)
+        process = for_ident(identifier)
+        return false unless process
+        process.alive?
+      end
+    end
+
+    def initialize(identifier, pid: nil, time: Time.now.strftime("%s")) # :nodoc:
+      @identifier = identifier
+      @pid = pid
+      @time = time
+      FileUtils.mkdir_p(ShopifyCLI::ProcessSupervision.run_dir)
+      @pid_path = File.join(ShopifyCLI::ProcessSupervision.run_dir, "#{identifier}.pid")
+      @log_path = File.join(ShopifyCLI::ProcessSupervision.run_dir, "#{identifier}.log")
+    end
+
+    ##
+    # will attempt to shutdown a running process
+    #
+    # #### Parameters
+    #
+    # * `ctx` - the context of this command
+    #
+    # #### Returns
+    #
+    # * `stopped` - [true, false]
+    #
+    def stop
+      kill_proc
+      unlink
+      true
+    rescue
+      false
+    end
+
+    ##
+    # will help identify if your process is still running in the background.
+    #
+    # #### Returns
+    #
+    # * `alive` - [true, false]
+    #
+    def alive?
+      stat(pid)
+    end
+
+    ##
+    # persists the pidfile
+    #
+    def write
+      FileUtils.mkdir_p(File.dirname(pid_path))
+      File.write(pid_path, "#{pid}:#{time}")
+    end
+
+    private
+
+    def unlink
+      File.unlink(pid_path)
+      File.unlink(log_path)
+      nil
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def kill_proc
+      if Context.new.windows?
+        kill(pid)
+      else
+        kill(-pid) # process group
+      end
+    rescue Errno::ESRCH
+      begin
+        kill(pid)
+      rescue Errno::ESRCH # The process group does not exist, try the pid itself
+        # Race condition, process died in the middle
+      end
+    end
+
+    def kill(id)
+      ctx = Context.new
+
+      # Windows does not handle SIGTERM, go straight to SIGKILL
+      unless ctx.windows?
+        Process.kill("TERM", id)
+        50.times do
+          sleep(0.1)
+          break unless stat(id)
+        end
+      end
+      Process.kill("KILL", id) if stat(id)
+      sleep(0.1) if ctx.windows? # Give Windows a second to actually close the process
+    end
+
+    def stat(id)
+      Process.kill(0, id) # signal 0 checks if pid is alive
+      true
+    rescue Errno::EPERM
+      true
+    rescue Errno::ESRCH
+      false
+    end
+  end
+end

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

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+require "shopify_cli"
+
+module ShopifyCLI
+  ##
+  # ShopifyCLI::Project captures the current project that the user is working on.
+  # This class can be used to fetch and save project environment as well as the
+  # project config `.shopify-cli.yml`.
+  #
+  class Project
+    include SmartProperties
+
+    class << self
+      ##
+      # will get an instance of the project that the user is currently operating
+      # on. This is used for access to project resources.
+      #
+      # #### Parameters
+      #
+      # * `force_reload` - whether to force a reload of the project files
+      #
+      # #### Returns
+      #
+      # * `project` - a Project instance if the user is currently in the project.
+      #
+      # #### Raises
+      #
+      # * `ShopifyCLI::Abort` - If the cli is not currently in a project directory
+      #   then this will be raised with a message implying that the user is not in
+      #   a project directory.
+      #
+      # #### Example
+      #
+      #   project = ShopifyCLI::Project.current
+      #
+      def current(force_reload: false)
+        clear if force_reload
+        at(Dir.pwd)
+      end
+
+      ##
+      # will return true if the command line is currently within a project
+      #
+      # #### Returns
+      #
+      # * `has_current?` - boolean, true if there is a current project
+      #
+      def has_current?
+        !directory(Dir.pwd).nil?
+      end
+
+      ##
+      # will fetch the project type of the current project. This is mostly used
+      # for internal project type loading, you should not normally need this.
+      #
+      # #### Returns
+      #
+      # * `type` - a symbol of the name of the project type identifier. i.e. [rails, node]
+      #   This will be nil if the user is not in a current project.
+      #
+      # #### Example
+      #
+      #   type = ShopifyCLI::Project.current_project_type
+      #
+      def current_project_type
+        return unless has_current?
+        current.config["project_type"].to_sym
+      end
+
+      ##
+      # writes out the `.shopify-cli.yml` file. You should use this when creating
+      # a project type so that the rest of your project type commands will load
+      # in this project, in the future.
+      #
+      # #### Parameters
+      #
+      # * `ctx` - the current running context of your command
+      # * `project_type` - a string or symbol of your project type name
+      # * `organization_id` - the id of the partner organization that the app is owned by. Used for metrics
+      # * `identifiers` - an optional hash of other app identifiers
+      #
+      # #### Example
+      #
+      #   ShopifyCLI::Project.write(
+      #     @ctx,
+      #     project_type: "node",
+      #     organization_id: form_data.organization_id,
+      #   )
+      #
+      def write(ctx, project_type:, organization_id:, **identifiers)
+        require "yaml" # takes 20ms, so deferred as late as possible.
+        content = Hash[{ project_type: project_type, organization_id: organization_id.to_i }
+          .merge(identifiers)
+          .collect { |k, v| [k.to_s, v] }]
+        content["shopify_organization"] = true if Shopifolk.acting_as_shopify_organization?
+
+        ctx.write(".shopify-cli.yml", YAML.dump(content))
+        clear
+      end
+
+      def project_name
+        File.basename(current.directory)
+      end
+
+      def clear
+        @at = nil
+        @dir = nil
+      end
+
+      def at(dir)
+        proj_dir = directory(dir)
+        if !proj_dir && !ShopifyCLI::Environment.run_as_subprocess?
+          raise(ShopifyCLI::Abort, Context.message("core.project.error.not_in_project"))
+        end
+        @at ||= Hash.new { |h, k| h[k] = new(directory: k) }
+        @at[proj_dir]
+      end
+
+      private
+
+      def directory(dir)
+        @dir ||= Hash.new { |h, k| h[k] = Utilities.directory(".shopify-cli.yml", k) }
+        @dir[dir]
+      end
+    end
+
+    property :directory # :nodoc:
+    property :env # :nodoc:
+
+    ##
+    # will read, parse and return the envfile for the project
+    #
+    # #### Returns
+    #
+    # * `env` - An instance of a ShopifyCLI::Resources::EnvFile
+    #
+    # #### Example
+    #
+    #   ShopifyCLI::Project.current.env
+    #
+    def env
+      @env ||= begin
+                 Resources::EnvFile.read(directory)
+               rescue Errno::ENOENT
+                 nil
+               end
+    end
+
+    ##
+    # will read, parse and return the .shopify-cli.yml for the project
+    #
+    # #### Returns
+    #
+    # * `config` - A hash of configuration
+    #
+    # #### Raises
+    #
+    # * `ShopifyCLI::Abort` - If the yml is invalid or poorly formatted
+    # * `ShopifyCLI::Abort` - If the yml file does not exist
+    #
+    # #### Example
+    #
+    #   ShopifyCLI::Project.current.config
+    #
+    def config
+      @config ||= begin
+        config = load_yaml_file(".shopify-cli.yml")
+        unless config.is_a?(Hash)
+          raise ShopifyCLI::Abort, Context.message("core.yaml.error.not_hash", ".shopify-cli.yml")
+        end
+
+        # The app_type key was deprecated in favour of project_type, so replace it
+        if config.key?("app_type")
+          config["project_type"] = config["app_type"]
+          config.delete("app_type")
+        end
+
+        config
+      end
+    end
+
+    private
+
+    def load_yaml_file(relative_path)
+      f = File.join(directory, relative_path)
+      require "yaml" # takes 20ms, so deferred as late as possible.
+      begin
+        YAML.load_file(f)
+      rescue Psych::SyntaxError => e
+        raise(ShopifyCLI::Abort, Context.message("core.yaml.error.invalid", relative_path, e.message))
+      # rescue Errno::EACCES => e
+      # TODO
+      #   Dev::Helpers::EaccesHandler.diagnose_and_raise(f, e, mode: :read)
+      rescue Errno::ENOENT
+        raise ShopifyCLI::Abort, Context.message("core.yaml.error.not_found", f)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module ShopifyCLI
+  class ProjectCommand < Command
+    def call(*)
+      @ctx.puts(self.class.help)
+    end
+
+    def self.help
+      project_type = name.split("::")[0].downcase
+      ShopifyCLI::Context.message(
+        "#{project_type}.help",
+        ShopifyCLI::TOOL_NAME,
+        subcommand_registry.command_names.join(" | ")
+      )
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module ShopifyCLI
+  class ProjectType
+    extend Feature::Set
+
+    class << self
+      attr_accessor :project_type,
+        :project_name,
+        :project_load_shallow
+
+      def repository
+        @repository ||= []
+      end
+      alias_method :all_loaded, :repository
+
+      def inherited(klass)
+        super
+        repository << klass
+        klass.project_type = @current_type
+        klass.project_load_shallow = @shallow_load
+      end
+
+      def load_type(current_type, shallow = false)
+        filepath = File.join(ShopifyCLI::ROOT, "lib", "project_types", current_type.to_s, "cli.rb")
+        return unless File.exist?(filepath)
+        @shallow_load = shallow
+        @current_type = current_type
+        load(filepath)
+        @current_type = nil
+        @shallow_load = false
+        for_app_type(current_type)
+      end
+
+      def load_all
+        Dir.glob(File.join(ShopifyCLI::ROOT, "lib", "project_types", "*", "cli.rb")).map do |filepath|
+          load_type(filepath.split(File::Separator)[-2].to_sym, true)
+        end
+      end
+
+      def for_app_type(type)
+        repository.find { |k| k.project_type.to_s == type.to_s }
+      end
+
+      def project_filepath(path)
+        File.join(ShopifyCLI::PROJECT_TYPES_DIR, project_type.to_s, path)
+      end
+
+      def title(name)
+        @project_name = name
+      end
+
+      def register_task(task, name)
+        return if project_load_shallow
+        ShopifyCLI::Tasks.register(task, name)
+      end
+
+      def register_messages(messages)
+        # Make sure we don't attempt to register a file more than once as that will fail
+        @registered_message_files ||= {}
+        return if @registered_message_files.key?(@project_type)
+        @registered_message_files[@project_type] = true
+
+        Context.load_messages(messages)
+      end
+    end
+  end
+end