@shopify/cli-kit 3.39.0 → 3.40.0

package/assets/cli-ruby/lib/shopify_cli/theme/dev_server/watcher.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+require "shopify_cli/file_system_listener"
+require "forwardable"
+
+module ShopifyCLI
+  module Theme
+    class DevServer
+      # Watches for file changes and publish events to the theme
+      class Watcher
+        extend Forwardable
+
+        def_delegators :@listener, :add_observer, :changed, :notify_observers
+
+        def initialize(ctx, theme:, syncer:, ignore_filter: nil, poll: false)
+          @ctx = ctx
+          @theme = theme
+          @syncer = syncer
+          @ignore_filter = ignore_filter
+          @listener = FileSystemListener.new(root: @theme.root, force_poll: poll,
+            ignore_regex: @ignore_filter&.regexes)
+
+          add_observer(self, :upload_files_when_changed)
+        end
+
+        def start
+          @listener.start
+        end
+
+        def stop
+          @listener.stop
+        end
+
+        def upload_files_when_changed(modified, added, removed)
+          modified_theme_files = filter_theme_files(modified + added)
+          if modified_theme_files.any?
+            @syncer.enqueue_updates(modified_theme_files)
+          end
+
+          removed_theme_files = filter_remote_files(removed)
+          if removed_theme_files.any?
+            @syncer.enqueue_deletes(removed_theme_files)
+          end
+        end
+
+        def filter_theme_files(files)
+          files
+            .select { |file| @theme.theme_file?(file) }
+            .map { |file| @theme[file] }
+            .reject { |file| @syncer.ignore_file?(file) }
+        end
+
+        def filter_remote_files(files)
+          files
+            .select { |file| @syncer.remote_file?(file) }
+            .map { |file| @theme[file] }
+            .reject { |file| @syncer.ignore_file?(file) }
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/dev_server/web_server.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "webrick"
+require "stringio"
+
+module ShopifyCLI
+  module Theme
+    class DevServer
+      # WEBrick will sometimes cause a fatal deadlock error on shutdown.
+      # The error happens because `Thread#join` is called without a timeout argument.
+      # We monkey-patch WEBrick to call `Thread#join(timeout)` before the existing
+      # `Thread#join`.
+      module WEBrickGenericServerThreadJoinWithTimeout
+        # Hook into a method called right before the threads are shutdown.
+        def cleanup_listener
+          # Force a Thread#join with a timeout to prevent any deadlock error on stop
+          Thread.list.each do |thread|
+            next unless thread[:WEBrickThread]
+            thread.join(2)
+            # Prevent the `join` call without a timeout inside WEBrick.
+            thread[:WEBrickThread] = false
+          end
+          super
+        end
+      end
+
+      # Base on Rack::Handler::WEBrick
+      class WebServer < ::WEBrick::HTTPServlet::AbstractServlet
+        def self.run(app, **options)
+          environment  = ENV["RACK_ENV"] || "development"
+          default_host = environment == "development" ? "localhost" : nil
+
+          if !options[:BindAddress] || options[:Host]
+            options[:BindAddress] = options.delete(:Host) || default_host
+          end
+          options[:Port] ||= 8080
+          if options[:SSLEnable]
+            require "webrick/https"
+          end
+
+          @server = ::WEBrick::HTTPServer.new(options)
+          @server.extend(WEBrickGenericServerThreadJoinWithTimeout)
+          @server.mount("/", WebServer, app)
+          yield @server if block_given?
+          @server.start
+        end
+
+        def self.valid_options
+          environment  = ENV["RACK_ENV"] || "development"
+          default_host = environment == "development" ? "localhost" : "0.0.0.0"
+
+          {
+            "Host=HOST" => "Hostname to listen on (default: #{default_host})",
+            "Port=PORT" => "Port to listen on (default: 8080)",
+          }
+        end
+
+        def self.shutdown
+          if @server
+            @server.shutdown
+            @server = nil
+          end
+        end
+
+        def initialize(server, app)
+          super(server)
+          @app = app
+        end
+
+        def service(req, res)
+          # res.rack = true
+          env = req.meta_vars
+          env.delete_if { |_k, v| v.nil? }
+
+          rack_input = StringIO.new(req.body.to_s)
+          rack_input.set_encoding(Encoding::BINARY)
+
+          env.update(
+            "rack.version"      => [1, 3],
+            "rack.input"        => rack_input,
+            "rack.errors"       => $stderr,
+            "rack.multithread"  => true,
+            "rack.multiprocess" => false,
+            "rack.run_once"     => false,
+            "rack.url_scheme"   => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http",
+            "rack.hijack?"      => true,
+            "rack.hijack"       => lambda { raise NotImplementedError, "only partial hijack is supported." },
+            "rack.hijack_io"    => nil
+          )
+
+          env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+          env["QUERY_STRING"] ||= ""
+          unless env["PATH_INFO"] == ""
+            path = req.request_uri.path
+            n = env["SCRIPT_NAME"].length
+            env["PATH_INFO"] = path[n, path.length - n]
+          end
+          env["REQUEST_PATH"] ||= [env["SCRIPT_NAME"], env["PATH_INFO"]].join
+
+          status, headers, body = @app.call(env)
+
+          res.status = status.to_i
+          io_lambda = nil
+          headers.each do |k, vs|
+            if k == "rack.hijack"
+              io_lambda = vs
+            elsif k == "webrick.chunked"
+              res.chunked = true
+            elsif k.downcase == "set-cookie"
+              res.cookies.concat(vs.split("\n"))
+            else
+              # Since WEBrick won't accept repeated headers,
+              # merge the values per RFC 1945 section 4.2.
+              res[k] = vs.split("\n").join(", ")
+            end
+          end
+
+          if io_lambda
+            rd, wr = IO.pipe
+            res.body = rd
+            res.chunked = true
+            io_lambda.call(wr)
+            body.close if body.respond_to?(:close)
+          elsif body.respond_to?(:to_path)
+            res.body = ::File.open(body.to_path, "rb")
+            body.close if body.respond_to?(:close)
+          else
+            res.body = lambda do |out|
+              out.set_encoding(Encoding::BINARY) if out.respond_to?(:set_encoding)
+              body.each do |part|
+                out.write(part)
+              end
+              body.close if body.respond_to?(:close)
+            end
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/dev_server.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "singleton"
+
+require_relative "dev_server/cdn_fonts"
+require_relative "dev_server/certificate_manager"
+require_relative "dev_server/errors"
+require_relative "dev_server/header_hash"
+require_relative "dev_server/hot_reload"
+require_relative "dev_server/hot_reload/script_injector"
+require_relative "dev_server/local_assets"
+require_relative "dev_server/proxy_param_builder"
+require_relative "dev_server/proxy"
+require_relative "dev_server/reload_mode"
+require_relative "dev_server/remote_watcher"
+require_relative "dev_server/sse"
+require_relative "dev_server/watcher"
+require_relative "dev_server/web_server"
+require_relative "dev_server/hooks/file_change_hook"
+
+require_relative "development_theme"
+require_relative "ignore_filter"
+require_relative "include_filter"
+require_relative "syncer"
+
+module ShopifyCLI
+  module Theme
+    class DevServer
+      include Singleton
+
+      attr_reader :app, :stopped, :ctx, :root, :host, :theme_identifier, :port, :poll, :editor_sync, :stable, :mode,
+        :block, :includes, :ignores
+
+      class << self
+        def start(
+          ctx,
+          root,
+          host: "127.0.0.1",
+          theme: nil,
+          port: 9292,
+          poll: false,
+          editor_sync: false,
+          stable: false,
+          mode: ReloadMode.default,
+          includes: nil,
+          ignores: nil,
+          &block
+        )
+          instance.setup(
+            ctx,
+            root,
+            host,
+            theme,
+            port,
+            poll,
+            editor_sync,
+            stable,
+            mode,
+            includes,
+            ignores,
+            &block
+          )
+          instance.start
+        end
+
+        def stop
+          instance.stop
+        end
+      end
+
+      # rubocop:disable Metrics/ParameterLists
+      def setup(
+        ctx,
+        root,
+        host,
+        theme_identifier,
+        port,
+        poll,
+        editor_sync,
+        stable,
+        mode,
+        includes,
+        ignores,
+        &block
+      )
+        @ctx = ctx
+        @root = root
+        @host = host
+        @theme_identifier = theme_identifier
+        @port = port
+        @poll = poll
+        @editor_sync = editor_sync
+        @stable = stable
+        @mode = mode
+        @includes = includes
+        @ignores = ignores
+        @block = block
+      end
+
+      def start
+        sync_theme
+
+        # Handle process stop
+        trap("INT") { stop("SIGINT") }
+        trap("TERM") { stop("SIGTERM") }
+
+        # Setup the middleware stack. Mimics Rack::Builder / config.ru, but in reverse order
+        @app = middleware_stack
+
+        # Start development server
+        setup_server
+        start_server
+        teardown_server
+
+      rescue ShopifyCLI::API::APIRequestForbiddenError,
+             ShopifyCLI::API::APIRequestUnauthorizedError
+        ctx.abort(ensure_user_message)
+      rescue Errno::EADDRINUSE
+        ctx.abort(port_error_message, port_error_help_message)
+      rescue Errno::EADDRNOTAVAIL
+        ctx.abort(binding_error_message)
+      end
+
+      def stop(signal = nil)
+        ctx.debug(stop_signal(signal)) unless signal.nil?
+
+        @stopped = true
+
+        ctx.puts(stopping_message)
+        app.close
+        WebServer.shutdown
+      end
+
+      private
+
+      def setup_server
+        watcher.start
+        remote_watcher.start if editor_sync
+      end
+
+      def teardown_server
+        # Use instance variables, so we don't build components
+        # at the teardown phase.
+        @remote_watcher&.stop if editor_sync
+        @watcher&.stop
+        @syncer&.shutdown
+      end
+
+      def start_server
+        WebServer.run(
+          app,
+          BindAddress: host,
+          Port: port,
+          Logger: logger,
+          AccessLog: [],
+        )
+      end
+
+      def middleware_stack
+        @app = Proxy.new(ctx, theme, param_builder)
+        @app = CdnFonts.new(@app, theme: theme)
+        @app = LocalAssets.new(ctx, @app, theme)
+        @app = HotReload.new(ctx, @app, broadcast_hooks: broadcast_hooks, watcher: watcher, mode: mode,
+          script_injector: script_injector)
+      end
+
+      def sync_theme
+        CLI::UI::Frame.open(viewing_theme_message) do
+          ctx.print_task(syncing_theme_message)
+          syncer.start_threads
+
+          if block
+            block.call(syncer)
+          else
+            syncer.upload_theme!(delay_low_priority_files: true)
+          end
+
+          return if stopped
+
+          ctx.puts(serving_theme_message)
+          ctx.open_url!(address)
+          ctx.puts(preview_message)
+        end
+      end
+
+      def theme
+        @theme ||= if theme_identifier
+          theme = ShopifyCLI::Theme::Theme.find_by_identifier(ctx, root: root, identifier: theme_identifier)
+          theme || ctx.abort(not_found_error_message)
+        else
+          DevelopmentTheme.find_or_create!(ctx, root: root)
+        end
+      end
+
+      def syncer
+        @syncer ||= Syncer.new(
+          ctx,
+          theme: theme,
+          include_filter: include_filter,
+          ignore_filter: ignore_filter,
+          overwrite_json: !editor_sync,
+          stable: stable
+        )
+      end
+
+      def watcher
+        @watcher ||= Watcher.new(
+          ctx,
+          theme: theme,
+          ignore_filter: ignore_filter,
+          syncer: syncer,
+          poll: poll
+        )
+      end
+
+      def remote_watcher
+        @remote_watcher ||= RemoteWatcher.to(
+          theme: theme,
+          syncer: syncer
+        )
+      end
+
+      def param_builder
+        @param_builder ||= ProxyParamBuilder
+          .new
+          .with_theme(theme)
+          .with_syncer(syncer)
+      end
+
+      def ignore_filter
+        @ignore_filter ||= IgnoreFilter.from_path(root).tap do |filter|
+          filter.add_patterns(ignores) if ignores
+        end
+      end
+
+      def include_filter
+        @include_filter ||= ShopifyCLI::Theme::IncludeFilter.new(root, includes)
+      end
+
+      def logger
+        @logger ||= if ctx.debug?
+          WEBrick::Log.new(nil, WEBrick::BasicLog::INFO)
+        else
+          WEBrick::Log.new(nil, WEBrick::BasicLog::FATAL)
+        end
+      end
+
+      # Hooks
+
+      def broadcast_hooks
+        file_handler = Hooks::FileChangeHook.new(ctx, theme: theme, include_filter: include_filter,
+          ignore_filter: ignore_filter)
+        [file_handler]
+      end
+
+      def script_injector
+        HotReload::ScriptInjector.new(ctx, theme: theme)
+      end
+
+      def address
+        @address ||= "http://#{host}:#{port}"
+      end
+
+      # Messages
+
+      def ensure_user_message
+        shop = ShopifyCLI::AdminAPI.get_shop_or_abort(ctx)
+        ctx.message("theme.serve.ensure_user", shop)
+      end
+
+      def port_error_message
+        ctx.message("theme.serve.address_already_in_use", address)
+      end
+
+      def port_error_help_message
+        ctx.message("theme.serve.try_port_option")
+      end
+
+      def binding_error_message
+        ctx.message("theme.serve.binding_error", ShopifyCLI::TOOL_NAME)
+      end
+
+      def viewing_theme_message
+        ctx.message("theme.serve.viewing_theme")
+      end
+
+      def syncing_theme_message
+        ctx.message("theme.serve.syncing_theme", theme.id, theme.shop)
+      end
+
+      def serving_theme_message
+        ctx.message("theme.serve.serving", theme.root)
+      end
+
+      def stopping_message
+        ctx.message("theme.serve.stopping")
+      end
+
+      def stop_signal(signal)
+        ctx.message("theme.serve.stop_signal", signal)
+      end
+
+      def not_found_error_message
+        ctx.message("theme.serve.theme_not_found", theme_identifier)
+      end
+
+      def preview_message
+        preview_suffix = editor_sync ? "" : ctx.message("theme.serve.download_changes")
+
+        ctx.message(
+          "theme.serve.customize_or_preview",
+          preview_suffix,
+          theme.editor_url,
+          theme.preview_url
+        )
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/development_theme.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+require_relative "theme"
+
+require "socket"
+require "securerandom"
+
+module ShopifyCLI
+  module Theme
+    API_NAME_LIMIT = 50
+
+    class DevelopmentTheme < Theme
+      def id
+        ShopifyCLI::DB.get(:development_theme_id)
+      end
+
+      def name
+        existing_name = ShopifyCLI::DB.get(:development_theme_name)
+        # Up to version 2.3.0 (included) generated names stored locally
+        # could have more than 50 characters and the API rejected them.
+        # This code ensures we update the name for those users to ensure
+        # the name stays under the limit.
+        if existing_name.nil? || existing_name.length > API_NAME_LIMIT
+          generate_theme_name
+        else
+          existing_name
+        end
+      end
+
+      def role
+        "development"
+      end
+
+      def ensure_exists!
+        if exists?
+          @ctx.debug("Using temporary development theme: ##{id} #{name}")
+        else
+          create
+          @ctx.debug("Created temporary development theme: #{@id}")
+          ShopifyCLI::DB.set(development_theme_id: @id)
+        end
+
+        self
+      end
+
+      def exists?
+        return false unless id
+
+        api_client.get(
+          path: "themes/#{id}.json"
+        )
+      rescue ShopifyCLI::API::APIRequestNotFoundError
+        false
+      end
+
+      def delete
+        super if exists?
+        ShopifyCLI::DB.del(:development_theme_id) if ShopifyCLI::DB.exists?(:development_theme_id)
+        ShopifyCLI::DB.del(:development_theme_name) if ShopifyCLI::DB.exists?(:development_theme_name)
+      end
+
+      def self.delete(ctx)
+        new(ctx).delete
+      end
+
+      def self.find(ctx, root: nil)
+        dev_theme = new(ctx, root: root)
+        dev_theme.exists? ? dev_theme : nil
+      end
+
+      def self.find_or_create!(ctx, root: nil)
+        new(ctx, root: root).ensure_exists!
+      end
+
+      private
+
+      def generate_theme_name
+        hostname = Socket.gethostname.split(".").shift
+        hash = SecureRandom.hex(3)
+
+        theme_name = "Development ()"
+        hostname_character_limit = API_NAME_LIMIT - theme_name.length - hash.length - 1
+        identifier = encode_identifier("#{hash}-#{hostname[0, hostname_character_limit]}")
+        theme_name = "Development (#{identifier})"
+
+        ShopifyCLI::DB.set(development_theme_name: theme_name)
+
+        theme_name
+      end
+
+      ##
+      # In some cases, the identifier string encoding may be obfuscated by the hostname,
+      # which may be an ASCII string.
+      #
+      # This method ensures the result identifier is a UTF-8 valid string.
+      #
+      def encode_identifier(identifier)
+        identifier.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "-")
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/extension/app_extension.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require "forwardable"
+require "shopify_cli/theme/root"
+
+module ShopifyCLI
+  module Theme
+    module Extension
+      class AppExtension
+        extend Forwardable
+
+        attr_reader :app_id, :location, :registration_id
+        def_delegators :@root_obj,
+          :root,
+          :static_asset_files,
+          :liquid_files,
+          :json_files,
+          :glob,
+          :static_asset_file?,
+          :static_asset_paths,
+          :[],
+          :file?
+
+        def initialize(ctx, root:, app_id: nil, location: nil, registration_id: nil)
+          @app_id = app_id
+          @location = location
+          @registration_id = registration_id
+          @root_obj = Root.new(ctx, root: root)
+        end
+
+        def extension_files
+          (glob(["**/*.liquid", "**/*.json"]) + static_asset_files).uniq
+        end
+
+        def extension_file?(file)
+          extension_files.include?(self[file])
+        end
+      end
+    end
+  end
+end