@shopify/cli-kit 3.39.0 → 3.40.1

package/assets/cli-ruby/lib/project_types/extension/commands/register.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Extension
+  class Command
+    class Register < ExtensionCommand
+      prerequisite_task ensure_project_type: :extension
+
+      def call(_args, _command_name)
+        CLI::UI::Frame.open(@ctx.message("register.frame_title")) do
+          @ctx.abort(@ctx.message("register.already_registered")) if project.registered?
+
+          should_continue = confirm_registration
+          registration = should_continue ? register_extension : abort_not_registered
+
+          update_project_files(registration)
+
+          @ctx.puts(@ctx.message("register.success", project.title))
+          @ctx.puts(@ctx.message("register.success_info"))
+        end
+      end
+
+      def self.help
+        ShopifyCLI::Context.new.message("register.help", ShopifyCLI::TOOL_NAME)
+      end
+
+      private
+
+      def confirm_registration
+        @ctx.puts(@ctx.message("register.confirm_info", specification_handler.name))
+        CLI::UI::Prompt.confirm(@ctx.message("register.confirm_question"))
+      end
+
+      def register_extension
+        @ctx.puts(@ctx.message("register.waiting_text"))
+
+        Tasks::CreateExtension.call(
+          context: @ctx,
+          api_key: app.api_key,
+          type: specification_handler.graphql_identifier,
+          title: project.title,
+          config: {},
+          extension_context: specification_handler.extension_context(@ctx)
+        )
+      end
+
+      def update_project_files(registration)
+        ExtensionProject.write_env_file(
+          context: @ctx,
+          api_key: app.api_key,
+          api_secret: app.secret,
+          registration_id: registration.id,
+          registration_uuid: registration.uuid,
+          title: project.title
+        )
+      end
+
+      def app
+        @app ||= project.app
+      end
+
+      def abort_not_registered
+        @ctx.puts(@ctx.message("register.confirm_abort"))
+        raise ShopifyCLI::AbortSilent
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/commands/serve.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Extension
+  class Command
+    class Serve < ExtensionCommand
+      prerequisite_task ensure_project_type: :extension
+
+      recommend_default_ruby_range
+
+      DEFAULT_PORT = 39351
+
+      options do |parser, flags|
+        parser.on("-t", "--[no-]tunnel", "Establish an ngrok tunnel") { |tunnel| flags[:tunnel] = tunnel }
+        parser.on("--resourceUrl=RESOURCE_URL", "Provide a resource URL") do |resource_url|
+          flags[:resource_url] = resource_url
+        end
+        parser.on("-p", "--port=PORT", "Specify the port to use") do |port|
+          flags[:port] = port.to_i
+        end
+        parser.on("-T", "--theme=NAME_OR_ID", "Theme ID or name of the theme app extension host theme.") do |theme|
+          flags[:theme] = theme
+        end
+        parser.on("--api-key=API_KEY", "Connect your extension and app by inserting your app's API key") do |api_key|
+          flags[:api_key] = api_key.gsub('"', "")
+        end
+        parser.on("--api-secret=API_SECRET", "The API secret of the app the script is registered with.") do |api_secret|
+          flags[:api_secret] = api_secret.gsub('"', "")
+        end
+        parser.on("--extension-id=EXTENSION_ID", "The id of the extension's registration.") do |registration_id|
+          flags[:registration_id] = registration_id.gsub('"', "")
+        end
+        parser.on("--extension-title=EXTENSION_TITLE", "The title of the extension") do |extension_title|
+          flags[:extension_title] = extension_title.gsub('"', "")
+        end
+        parser.on("--extension-type=EXTENSION_TYPE", "The type of the extension") do |extension_type|
+          flags[:extension_type] = extension_type.gsub('"', "")
+        end
+      end
+
+      class RuntimeConfiguration
+        include SmartProperties
+
+        property :tunnel_url, accepts: String, default: nil
+        property :resource_url, accepts: String, default: nil
+        property! :tunnel_requested, accepts: [true, false], reader: :tunnel_requested?, default: true
+        property :port, accepts: (1...(2**16))
+        property :theme, accepts: String, default: nil
+        property :api_key, accepts: String, default: nil
+        property :api_secret, accepts: String, default: nil
+        property :registration_id, accepts: String, default: nil
+        property :extension_title, accepts: String, default: nil
+        property :extension_type, accepts: String, default: nil
+      end
+
+      def call(args, _command_name)
+        @ctx.root = args.first || @ctx.root
+
+        config = RuntimeConfiguration.new(
+          tunnel_requested: tunnel_requested?,
+          resource_url: options.flags[:resource_url],
+          port: options.flags[:port],
+          theme: options.flags[:theme],
+          api_key: options.flags[:api_key],
+          api_secret: options.flags[:api_secret],
+          registration_id: options.flags[:registration_id],
+          extension_title: options.flags[:extension_title],
+          extension_type: options.flags[:extension_type],
+        )
+
+        ShopifyCLI::Result
+          .success(config)
+          .then(&method(:find_available_port))
+          .then(&method(:start_tunnel_if_required))
+          .then(&method(:serve))
+          .unwrap { |error| raise error }
+      end
+
+      def self.help
+        ShopifyCLI::Context.new.message("serve.help", ShopifyCLI::TOOL_NAME)
+      end
+
+      private
+
+      def project
+        return super unless options.flags[:extension_type]
+
+        @project ||= Extension::Loaders::Project.load(
+          context: options.flags[:context],
+          directory: @ctx.root,
+          api_key: options.flags[:api_key],
+          api_secret: options.flags[:api_secret],
+          registration_id: options.flags[:registration_id],
+          env: {
+            ExtensionProjectKeys::TITLE_KEY => options.flags[:extension_title],
+            ExtensionProjectKeys::REGISTRATION_ID_KEY => options.flags[:registration_id],
+            ExtensionProjectKeys::SPECIFICATION_IDENTIFIER_KEY => options.flags[:extension_type],
+          }
+        )
+      end
+
+      def tunnel_requested?
+        tunnel = options.flags[:tunnel]
+        tunnel.nil? || !!tunnel
+      end
+
+      def find_available_port(runtime_configuration)
+        return runtime_configuration unless runtime_configuration.port.nil?
+        return runtime_configuration unless specification_handler.choose_port?(@ctx)
+
+        chosen_port = Tasks::ChooseNextAvailablePort
+          .call(from: DEFAULT_PORT)
+          .unwrap { |_error| @ctx.abort(@ctx.message("serve.no_available_ports_found")) }
+        runtime_configuration.tap { |c| c.port = chosen_port }
+      end
+
+      def start_tunnel_if_required(runtime_configuration)
+        return runtime_configuration unless specification_handler.establish_tunnel?(@ctx)
+        return runtime_configuration unless runtime_configuration.tunnel_requested?
+
+        return start_tunnel(runtime_configuration) if can_start_tunnel?(runtime_configuration)
+        @ctx.abort(@ctx.message("serve.tunnel_already_running"))
+      end
+
+      def can_start_tunnel?(runtime_configuration)
+        return true if ShopifyCLI::Tunnel.urls.empty?
+        ShopifyCLI::Tunnel.running_on?(runtime_configuration.port)
+      end
+
+      def start_tunnel(runtime_configuration)
+        tunnel_url = ShopifyCLI::Tunnel.start(@ctx, port: runtime_configuration.port)
+        runtime_configuration.tap { |c| c.tunnel_url = tunnel_url }
+      end
+
+      def serve(runtime_configuration)
+        specification_handler.serve(
+          context: @ctx,
+          tunnel_url: runtime_configuration.tunnel_url,
+          port: runtime_configuration.port,
+          theme: runtime_configuration.theme,
+          api_key: runtime_configuration.api_key,
+          api_secret: runtime_configuration.api_secret,
+          registration_id: runtime_configuration.registration_id,
+          resource_url: runtime_configuration.resource_url,
+          project: project,
+        )
+        runtime_configuration
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/commands/tunnel.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+require "shopify_cli"
+
+module Extension
+  class Command
+    class Tunnel < ExtensionCommand
+      prerequisite_task ensure_project_type: :extension
+
+      options do |parser, flags|
+        parser.on("--port=PORT") { |port| flags[:port] = port }
+      end
+
+      AUTH_SUBCOMMAND = "auth"
+      START_SUBCOMMAND = "start"
+      STOP_SUBCOMMAND = "stop"
+      STATUS_SUBCOMMAND = "status"
+      DEFAULT_PORT = 39351
+
+      def call(args, _name)
+        subcommand = args.shift
+
+        case subcommand
+        when AUTH_SUBCOMMAND then authorize(args)
+        when START_SUBCOMMAND then ShopifyCLI::Tunnel.start(@ctx, port: port)
+        when STOP_SUBCOMMAND then ShopifyCLI::Tunnel.stop(@ctx)
+        when STATUS_SUBCOMMAND then status
+        else @ctx.puts(self.class.help)
+        end
+      end
+
+      def self.help
+        ShopifyCLI::Context.message("tunnel.help", ShopifyCLI::TOOL_NAME)
+      end
+
+      def self.extended_help
+        ShopifyCLI::Context.message("tunnel.extended_help", ShopifyCLI::TOOL_NAME, DEFAULT_PORT)
+      end
+
+      private
+
+      def status
+        tunnel_urls = ShopifyCLI::Tunnel.urls
+        tunnel_url = tunnel_urls.find { |url| url.start_with?("https://") }
+        tunnel_url = tunnel_urls.first if tunnel_url.nil?
+
+        if tunnel_url.nil?
+          @ctx.puts(@ctx.message("tunnel.no_tunnel_running"))
+        else
+          @ctx.puts(@ctx.message("tunnel.tunnel_running_at", tunnel_url))
+        end
+      end
+
+      def port
+        return DEFAULT_PORT unless options.flags.key?(:port)
+
+        port = options.flags[:port].to_i
+        @ctx.abort(@ctx.message("tunnel.invalid_port", options.flags[:port])) unless port > 0
+        port
+      end
+
+      def authorize(args)
+        token = args.shift
+
+        if token.nil?
+          @ctx.puts(@ctx.message("tunnel.missing_token"))
+          @ctx.puts("#{self.class.help}\n#{self.class.extended_help}")
+        else
+          ShopifyCLI::Tunnel.auth(@ctx, token)
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Extension
+  module Errors
+    class ExtensionError < StandardError; end
+    class InvalidFilenameError < ExtensionError; end
+    class BundleTooLargeError < ExtensionError; end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/extension_project.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+require "shopify_cli"
+require "shopify_cli/environment"
+require "securerandom"
+
+module Extension
+  class ExtensionProject < ShopifyCLI::Project
+    class << self
+      def write_cli_file(context:, type:)
+        ShopifyCLI::Project.write(
+          context,
+          project_type: :extension,
+          organization_id: nil,
+          "#{ExtensionProjectKeys::SPECIFICATION_IDENTIFIER_KEY}": type
+        )
+      end
+
+      def update_env_file(context:, **updates)
+        current_config = {
+          title: current.title,
+          shop: current.env.shop,
+          api_key: current.app.api_key,
+          api_secret: current.app.secret,
+          registration_id: current.registration_id,
+          registration_uuid: current.registration_uuid,
+          resource_url: current.resource_url,
+        }
+
+        write_env_file(
+          context: context,
+          **current_config,
+          **updates
+        )
+      end
+
+      def write_env_file(
+        context:,
+        title:,
+        api_key: "",
+        api_secret: "",
+        registration_id: nil,
+        registration_uuid: nil,
+        resource_url: nil,
+        shop: nil
+      )
+        ShopifyCLI::Resources::EnvFile.new(
+          api_key: api_key,
+          secret: api_secret,
+          shop: shop,
+          extra: {
+            ExtensionProjectKeys::TITLE_KEY => title,
+            ExtensionProjectKeys::REGISTRATION_ID_KEY => registration_id,
+            ExtensionProjectKeys::REGISTRATION_UUID_KEY => registration_uuid || generate_temporary_uuid,
+            ExtensionProjectKeys::RESOURCE_URL_KEY => resource_url,
+          }.compact
+        ).write(context)
+
+        reload
+      end
+
+      def reload
+        current.reload unless project_empty?
+      end
+
+      private
+
+      def project_empty?
+        directory(Dir.pwd).nil?
+      end
+    end
+
+    def app
+      validate_env_present
+      Models::App.new(api_key: env["api_key"], secret: env["secret"])
+    end
+
+    def registered?
+      registration_id?
+    end
+
+    def title
+      get_extra_field(ExtensionProjectKeys::TITLE_KEY)
+    end
+
+    def specification_identifier
+      key = ExtensionProjectKeys::SPECIFICATION_IDENTIFIER_KEY
+
+      if ShopifyCLI::Environment.run_as_subprocess?
+        get_extra_field(key)
+      else
+        config[key]
+      end
+    end
+
+    def registration_id?
+      extra_property_present?(ExtensionProjectKeys::REGISTRATION_ID_KEY) &&
+        integer?(get_extra_field(ExtensionProjectKeys::REGISTRATION_ID_KEY)) &&
+        registration_id > 0
+    end
+
+    def registration_id
+      get_extra_field(ExtensionProjectKeys::REGISTRATION_ID_KEY).to_i
+    end
+
+    def registration_uuid
+      get_extra_field(ExtensionProjectKeys::REGISTRATION_UUID_KEY)
+    end
+
+    def resource_url
+      get_extra_field(ExtensionProjectKeys::RESOURCE_URL_KEY)
+    end
+
+    def reload
+      @env = nil
+    end
+
+    def self.generate_temporary_uuid
+      "dev-#{SecureRandom.uuid}"
+    end
+
+    private
+
+    def get_extra_field(key)
+      unless env
+        Kernel.puts("Run the command inside the correct extension directory.")
+        exit
+      end
+
+      extra = env[:extra] || {}
+      extra[key]
+    end
+
+    def extra_property_present?(key)
+      env[:extra].key?(key) && !get_extra_field(key).nil?
+    end
+
+    def property_present?(key)
+      validate_env_present
+      !env[key].nil? && !env[key].strip.empty?
+    end
+
+    def validate_env_present
+      return if env
+      raise ShopifyCLI::Abort, "Missing .env file. Run `shopify extension connect` to generate an .env file."
+    end
+
+    def integer?(value)
+      value.to_i.to_s == value.to_s
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/extension_project_keys.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+require "shopify_cli"
+
+module Extension
+  module ExtensionProjectKeys
+    REGISTRATION_ID_KEY = "EXTENSION_ID"
+    REGISTRATION_UUID_KEY = "EXTENSION_UUID"
+    SPECIFICATION_IDENTIFIER_KEY = "EXTENSION_TYPE"
+    TITLE_KEY = "EXTENSION_TITLE"
+    RESOURCE_URL_KEY = "EXTENSION_RESOURCE_URL"
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/features/argo.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require "base64"
+require "shopify_cli"
+require "semantic/semantic"
+
+module Extension
+  module Features
+    class Argo
+      include SmartProperties
+
+      property! :git_template, converts: :to_str
+      property! :renderer_package_name, converts: :to_str
+
+      SCRIPT_PATH = %w(build main.js).freeze
+
+      YARN_INSTALL_COMMAND = %w(install).freeze
+      YARN_INSTALL_PARAMETERS = %w(--silent).freeze
+      YARN_RUN_COMMAND = %w(run).freeze
+      YARN_RUN_SCRIPT_NAME = %w(build).freeze
+      private_constant :YARN_INSTALL_COMMAND, :YARN_INSTALL_PARAMETERS, :YARN_RUN_COMMAND, :YARN_RUN_SCRIPT_NAME
+
+      def create(directory_name, identifier, context)
+        Features::ArgoSetup.new(git_template: git_template).call(directory_name, identifier, context)
+      end
+
+      def config(context, include_renderer_version: true)
+        filepath = File.join(context.root, SCRIPT_PATH)
+        context.abort(context.message("features.argo.missing_file_error")) unless File.exist?(filepath)
+
+        renderer_version = nil
+        if include_renderer_version
+          renderer_version = renderer_package(context).version
+        end
+
+        begin
+          {
+            renderer_version: renderer_version,
+            serialized_script: Base64.strict_encode64(File.read(filepath).chomp),
+          }
+        rescue StandardError
+          context.abort(context.message("features.argo.script_prepare_error"))
+        end
+      end
+
+      def renderer_package(context)
+        Tasks::FindPackageFromJson.call(renderer_package_name, context: context)
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/features/argo_config.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Extension
+  module Features
+    class ArgoConfig
+      CONFIG_FILE_NAME = "extension.config.yml"
+
+      class << self
+        def parse_yaml(context, permitted_keys = [])
+          file_name = File.join(context.root, CONFIG_FILE_NAME)
+
+          return {} unless File.size?(file_name)
+
+          begin
+            config = YAML.load_file(file_name)
+
+            # `YAML.load_file` returns nil if the file is not empty
+            # but does not contain any parsable yml data, e.g. only comments
+            # We consider this valid
+            return {} if config.nil?
+
+            unless config.is_a?(Hash)
+              raise ShopifyCLI::Abort, ShopifyCLI::Context.message("core.yaml.error.not_hash", CONFIG_FILE_NAME)
+            end
+
+            config.transform_keys!(&:to_sym)
+            assert_valid_config(config, permitted_keys) unless permitted_keys.empty?
+
+            config
+          rescue Psych::SyntaxError => e
+            raise(
+              ShopifyCLI::Abort,
+              ShopifyCLI::Context.message("core.yaml.error.invalid", CONFIG_FILE_NAME, e.message)
+            )
+          end
+        end
+
+        private
+
+        def assert_valid_config(config, permitted_keys)
+          unpermitted_keys = config.keys.select do |k|
+            !permitted_keys.include?(k)
+          end
+
+          unless unpermitted_keys.empty?
+            raise(
+              ShopifyCLI::Abort,
+              ShopifyCLI::Context.message(
+                "features.argo.config.unpermitted_keys",
+                CONFIG_FILE_NAME,
+                unpermitted_keys.map { |k| "\n- #{k}" }.join
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/features/argo_dependencies.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Extension
+  module Features
+    class ArgoDependencies
+      def self.node_installed(min_major:, min_minor: nil)
+        -> (context) do
+          out, status = CLI::Kit::System.capture2("node", "-v")
+          context.abort(context.message("features.argo.dependencies.node.node_not_installed")) unless status.success?
+
+          min_version = "v" + min_major .to_s + "." + (min_minor.nil? ? "x" : min_minor.to_s) + ".x"
+          version = out.strip
+          parsed_version = version.match(/v(?<major>\d+).(?<minor>\d+).(?<patch>\d+)/)
+
+          unless min_major.nil? || parsed_version[:major].to_i >= min_major
+            context.abort(context.message("features.argo.dependencies.node.version_too_low", version, min_version))
+          end
+
+          return if parsed_version[:major].to_i > min_major
+
+          unless min_minor.nil? || parsed_version[:minor].to_i >= min_minor
+            context.abort(context.message("features.argo.dependencies.node.version_too_low", version, min_version))
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/features/argo_runtime.rb

@@ -0,0 +1,15 @@
+module Extension
+  module Features
+    class ArgoRuntime
+      RUNTIMES = [
+        Runtimes::Admin.new,
+        Runtimes::CheckoutPostPurchase.new,
+        Runtimes::CheckoutUiExtension.new,
+      ]
+
+      def self.find(cli_package:, identifier:)
+        RUNTIMES.find { |runtime| runtime.active_runtime?(cli_package, identifier) }
+      end
+    end
+  end
+end