@shopify/cli-kit 3.38.0 → 3.40.0

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    class DevServer
+      class HotReload
+        def initialize(ctx, app, broadcast_hooks: [], script_injector: nil, watcher:, mode:)
+          @ctx = ctx
+          @app = app
+          @mode = mode
+          @broadcast_hooks = broadcast_hooks
+          @script_injector = script_injector
+          @streams = SSE::Streams.new
+          @watcher = watcher
+          @watcher.add_observer(self, :notify_streams_of_file_change)
+        end
+
+        def call(env)
+          if env["PATH_INFO"] == "/hot-reload"
+            create_stream
+          else
+            status, headers, body = @app.call(env)
+
+            body = inject_hot_reload_javascript(body) if request_is_html?(headers)
+
+            [status, headers, body]
+          end
+        end
+
+        def close
+          @streams.close
+        end
+
+        def notify_streams_of_file_change(modified, added, removed)
+          @broadcast_hooks.each do |hook|
+            hook.call(modified, added, removed, streams: @streams)
+          end
+        end
+
+        private
+
+        def request_is_html?(headers)
+          headers["content-type"]&.start_with?("text/html")
+        end
+
+        def inject_hot_reload_javascript(body)
+          @script_injector&.inject(body: body, dir: __dir__, mode: @mode)
+        end
+
+        def create_stream
+          stream = @streams.new
+
+          @ctx.debug("[HotReload] Connected to SSE stream")
+
+          [
+            200,
+            {
+              "Content-Type" => "text/event-stream",
+              "Cache-Control" => "no-cache",
+              "webrick.chunked" => true,
+            },
+            stream,
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    class DevServer
+      class LocalAssets
+        THEME_REGEX = %r{//cdn\.shopify\.com/s/.+?/(assets/.+?\.(?:css|js))}
+
+        class FileBody
+          def initialize(path)
+            @path = path
+          end
+
+          # Naive implementation. Only used in unit tests.
+          def each
+            yield @path.read
+          end
+
+          # Rack will stream a body that responds to `to_path`
+          def to_path
+            @path.to_path
+          end
+        end
+
+        def initialize(ctx, app, target)
+          @ctx = ctx
+          @app = app
+          @target = target
+        end
+
+        def call(env)
+          if env["PATH_INFO"].start_with?("/assets")
+            # Serve from disk
+            serve_file(env["PATH_INFO"])
+          else
+            # Proxy the request, and replace the URLs in the response
+            status, headers, body = @app.call(env)
+            body = replace_asset_urls(body)
+            [status, headers, body]
+          end
+        end
+
+        private
+
+        def replace_asset_urls(body)
+          replaced_body = body.join.gsub(THEME_REGEX) do |match|
+            path = Regexp.last_match[1]
+            if @target.static_asset_paths.include?(path)
+              "/#{path}"
+            else
+              match
+            end
+          end
+
+          [replaced_body]
+        end
+
+        def serve_fail(status, body)
+          [
+            status,
+            {
+              "Content-Type" => "text/plain",
+              "Content-Length" => body.size.to_s,
+            },
+            [body],
+          ]
+        end
+
+        def serve_file(path_info)
+          path = @target.root.join(path_info[1..-1])
+          if path.file? && path.readable? && @target.static_asset_file?(path)
+            [
+              200,
+              {
+                "Content-Type" => MimeType.by_filename(path).to_s,
+                "Content-Length" => path.size.to_s,
+              },
+              FileBody.new(path),
+            ]
+          else
+            serve_fail(404, "Not found")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "time"
+require "cgi"
+require "net/http"
+
+require_relative "header_hash"
+require_relative "proxy_param_builder"
+
+module ShopifyCLI
+  module Theme
+    class DevServer
+      HOP_BY_HOP_HEADERS = [
+        "connection",
+        "keep-alive",
+        "proxy-authenticate",
+        "proxy-authorization",
+        "te",
+        "trailer",
+        "transfer-encoding",
+        "upgrade",
+        "content-security-policy",
+        "content-length",
+      ]
+
+      class Proxy
+        SESSION_COOKIE_NAME = "_secure_session_id"
+        SESSION_COOKIE_REGEXP = /#{SESSION_COOKIE_NAME}=(\h+)/
+        SESSION_COOKIE_MAX_AGE = 60 * 60 * 23 # 1 day - leeway of 1h
+
+        def initialize(ctx, theme, param_builder)
+          @ctx = ctx
+          @theme = theme
+          @param_builder = param_builder
+
+          @core_endpoints = Set.new
+          @secure_session_id = nil
+          @last_session_cookie_refresh = nil
+        end
+
+        def call(env)
+          headers = extract_http_request_headers(env)
+          headers["Host"] = shop
+          headers["Cookie"] = add_session_cookie(headers["Cookie"])
+          headers["Accept-Encoding"] = "none"
+          headers["User-Agent"] = "Shopify CLI"
+          query = URI.decode_www_form(env["QUERY_STRING"])
+          replace_templates = build_replacement_param(env)
+          response = if replace_templates.any?
+            # Pass to SFR the recently modified templates in `replace_templates` or
+            # `replace_extension_templates` body param
+            headers["Authorization"] = "Bearer #{bearer_token}"
+            form_data = URI.decode_www_form(env["rack.input"].read).to_h
+            request(
+              "POST", env["PATH_INFO"],
+              headers: headers,
+              query: query,
+              form_data: form_data.merge(replace_templates).merge(_method: env["REQUEST_METHOD"])
+            )
+          else
+            request(
+              env["REQUEST_METHOD"], env["PATH_INFO"],
+              headers: headers,
+              query: query,
+              body_stream: (env["rack.input"] if has_body?(headers))
+            )
+          end
+
+          headers = get_response_headers(response, env)
+
+          unless headers["x-storefront-renderer-rendered"]
+            @core_endpoints << env["PATH_INFO"]
+          end
+
+          body = patch_body(env, response.body)
+          body = [body] unless body.respond_to?(:each)
+          [response.code, headers, body]
+        end
+
+        private
+
+        def patch_body(env, body)
+          return [""] unless body
+
+          body.gsub(%r{(data-.+=(["']))(http:|https:)?//#{shop}(.*)(\2)}) do |_|
+            match = Regexp.last_match
+            "#{match[1]}http://#{host(env)}#{match[4]}#{match[5]}"
+          end
+        end
+
+        def host(env)
+          env["HTTP_HOST"]
+        end
+
+        def has_body?(headers)
+          headers["Content-Length"] || headers["Transfer-Encoding"]
+        end
+
+        def bearer_token
+          Environment.storefront_renderer_auth_token ||
+            ShopifyCLI::DB.get(:storefront_renderer_production_exchange_token) ||
+            raise(KeyError, "storefront_renderer_production_exchange_token missing")
+        end
+
+        def extract_http_request_headers(env)
+          headers = HeaderHash.new
+
+          env.each do |name, value|
+            next if value.nil?
+
+            if /^HTTP_[A-Z0-9_]+$/.match?(name) || name == "CONTENT_TYPE" || name == "CONTENT_LENGTH"
+              headers[reconstruct_header_name(name)] = value
+            end
+          end
+
+          x_forwarded_for = (headers["X-Forwarded-For"].to_s.split(/, +/) << env["REMOTE_ADDR"]).join(", ")
+          headers["X-Forwarded-For"] = x_forwarded_for
+
+          headers
+        end
+
+        def normalize_headers(headers)
+          mapped = headers.map do |k, v|
+            [k, v.is_a?(Array) ? v.join("\n") : v]
+          end
+          HeaderHash.new(Hash[mapped])
+        end
+
+        def reconstruct_header_name(name)
+          name.sub(/^HTTP_/, "").gsub("_", "-")
+        end
+
+        def add_session_cookie(cookie_header)
+          cookie_header = if cookie_header
+            cookie_header.dup
+          else
+            +""
+          end
+
+          expected_session_cookie = "#{SESSION_COOKIE_NAME}=#{secure_session_id}"
+
+          unless cookie_header.include?(expected_session_cookie)
+            if cookie_header.include?(SESSION_COOKIE_NAME)
+              cookie_header.sub!(SESSION_COOKIE_REGEXP, expected_session_cookie)
+            else
+              cookie_header << "; " unless cookie_header.empty?
+              cookie_header << expected_session_cookie
+            end
+          end
+
+          cookie_header
+        end
+
+        def secure_session_id_expired?
+          return true unless @secure_session_id && @last_session_cookie_refresh
+
+          Time.now - @last_session_cookie_refresh >= SESSION_COOKIE_MAX_AGE
+        end
+
+        def extract_secure_session_id_from_response_headers(headers)
+          return unless headers["set-cookie"]
+
+          headers["set-cookie"][SESSION_COOKIE_REGEXP, 1]
+        end
+
+        def secure_session_id
+          if secure_session_id_expired?
+            @ctx.debug("Refreshing preview _secure_session_id cookie")
+            response = request("HEAD", "/", query: [[:preview_theme_id, theme_id]])
+            @secure_session_id = extract_secure_session_id_from_response_headers(response)
+            @last_session_cookie_refresh = Time.now
+          end
+
+          @secure_session_id
+        end
+
+        def get_response_headers(response, env)
+          response_headers = normalize_headers(
+            response.respond_to?(:headers) ? response.headers : response.to_hash,
+          )
+          # According to https://tools.ietf.org/html/draft-ietf-httpbis-p1-messaging-14#section-7.1.3.1Acc
+          # should remove hop-by-hop header fields
+          # (Taken from Rack::Proxy)
+          response_headers.reject! { |k| HOP_BY_HOP_HEADERS.include?(k.downcase) }
+
+          if response_headers["location"]&.include?("myshopify.com")
+            response_headers["location"].gsub!(%r{(https://#{shop})}, "http://#{host(env)}")
+          end
+
+          new_session_id = extract_secure_session_id_from_response_headers(response_headers)
+          if new_session_id
+            @ctx.debug("New _secure_session_id cookie from response")
+            @secure_session_id = new_session_id
+            @last_session_cookie_refresh = Time.now
+          end
+
+          response_headers
+        end
+
+        def request(method, path, headers: nil, query: [], form_data: nil, body_stream: nil)
+          uri = URI.join("https://#{shop}", path)
+
+          if Environment.theme_access_password?
+            headers = headers ? headers.slice("ACCEPT", "CONTENT-TYPE", "CONTENT-LENGTH", "Cookie") : {}
+            headers.merge!({
+              "X-Shopify-Access-Token" => Environment.admin_auth_token,
+              "X-Shopify-Shop" => shop,
+            })
+            uri = URI.join("https://#{ThemeAccessAPI::BASE_URL}", "cli/sfr#{path}")
+          end
+
+          uri.query = URI.encode_www_form(query + [[:_fd, 0], [:pb, 0]])
+
+          @ctx.debug("Proxying #{method} #{uri}")
+
+          Net::HTTP.start(uri.host, 443, use_ssl: true) do |http|
+            req_class = Net::HTTP.const_get(method.capitalize)
+            req = req_class.new(uri)
+            req.initialize_http_header(headers) if headers
+            req.set_form_data(form_data) if form_data
+            req.body_stream = body_stream if body_stream
+            response = http.request(req)
+            @ctx.debug("`-> #{response.code} request_id: #{response["x-request-id"]}")
+            response
+          end
+        end
+
+        def shop
+          @shop ||= @theme.shop
+        end
+
+        def theme_id
+          @theme_id ||= @theme.id
+        end
+
+        def build_replacement_param(env)
+          @param_builder
+            .with_core_endpoints(@core_endpoints)
+            .with_rack_env(env)
+            .build
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module ShopifyCLI
+  module Theme
+    class DevServer
+      class ProxyParamBuilder
+        def build
+          # Core doesn't support replace_templates
+          return {} if core?(current_path)
+
+          (syncer_templates + request_templates)
+            .select { |file| file.liquid? || file.json? }
+            .uniq(&:relative_path)
+            .map { |file| as_param(file) }
+            .to_h
+        end
+
+        def with_core_endpoints(core_endpoints)
+          @core_endpoints = core_endpoints
+          self
+        end
+
+        def with_syncer(syncer)
+          @syncer = syncer
+          self
+        end
+
+        def with_rack_env(rack_env)
+          @rack_env = rack_env
+          self
+        end
+
+        def with_theme(theme)
+          @theme = theme
+          self
+        end
+
+        private
+
+        def as_param(file)
+          ["replace_templates[#{file.relative_path}]", file.read]
+        end
+
+        def syncer_templates
+          @syncer&.pending_updates || []
+        end
+
+        def request_templates
+          cookie_sections
+            .map { |section| @theme[section] unless @theme.nil? }
+            .compact
+        end
+
+        def cookie_sections
+          CGI::Cookie.parse(cookie)["hot_reload_files"].join.split(",") || []
+        end
+
+        def core?(path)
+          core_endpoints.include?(path)
+        end
+
+        def current_path
+          rack_env["PATH_INFO"]
+        end
+
+        def cookie
+          rack_env["HTTP_COOKIE"]
+        end
+
+        def core_endpoints
+          @core_endpoints || []
+        end
+
+        def rack_env
+          @rack_env || {}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    class DevServer
+      class ReloadMode
+        MODES = [:"hot-reload", :"full-page", :off]
+
+        class << self
+          def default
+            :"hot-reload"
+          end
+
+          def get!(mode)
+            MODES.find { |m| m == mode.to_sym } || raise_error(mode)
+          end
+
+          private
+
+          def raise_error(invalid_mode)
+            error_message = ShopifyCLI::Context.message("theme.serve.reload_mode_is_not_valid", invalid_mode)
+            help_message = ShopifyCLI::Context.message("theme.serve.try_a_valid_reload_mode", valid_modes)
+
+            ShopifyCLI::Context.abort(error_message, help_message)
+          end
+
+          def valid_modes
+            MODES.map { |v| "`#{v}`" }.join(", ")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "shopify_cli/thread_pool/job"
+
+module ShopifyCLI
+  module Theme
+    class DevServer
+      class RemoteWatcher
+        class JsonFilesUpdateJob < ShopifyCLI::ThreadPool::Job
+          def initialize(theme, syncer, interval)
+            super(interval)
+
+            @theme = theme
+            @syncer = syncer
+          end
+
+          def perform!
+            @syncer.fetch_checksums!
+            @syncer.enqueue_get(json_files)
+          end
+
+          private
+
+          def json_files
+            @theme
+              .json_files
+              .reject { |file| @syncer.pending_updates.include?(file) }
+              .reject { |file| @syncer.broken_file?(file) }
+              .reject { |file| @syncer.ignore_file?(file) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "shopify_cli/thread_pool"
+
+require_relative "remote_watcher/json_files_update_job"
+
+module ShopifyCLI
+  module Theme
+    class DevServer
+      class RemoteWatcher
+        SYNC_INTERVAL = 3 # seconds
+
+        class << self
+          def to(theme:, syncer:)
+            new(theme, syncer)
+          end
+        end
+
+        def start
+          thread_pool.schedule(recurring_job)
+        end
+
+        def stop
+          thread_pool.shutdown
+        end
+
+        private
+
+        def initialize(theme, syncer)
+          @theme = theme
+          @syncer = syncer
+        end
+
+        def thread_pool
+          @thread_pool ||= ShopifyCLI::ThreadPool.new(pool_size: 1)
+        end
+
+        def recurring_job
+          JsonFilesUpdateJob.new(@theme, @syncer, SYNC_INTERVAL)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+require "thread"
+
+module ShopifyCLI
+  module Theme
+    class DevServer
+      # Server-Sent events implementation for Rack.
+      # Based on https://gist.github.com/raggi/ff7971991297e5c8a1ce
+      class SSE
+        class Event < Struct.new(:data)
+          def to_s
+            "data: #{data}\n" \
+            "\n\n"
+          end
+        end
+
+        class Stream
+          def initialize(streams)
+            @streams = streams
+            @queue = Queue.new
+          end
+
+          def <<(event)
+            raise TypeError, "expected SSE::Event" unless event.is_a?(Event)
+            @queue << event
+          end
+
+          def each
+            while (event = @queue.pop)
+              yield event.to_s
+            end
+          end
+
+          def close
+            @streams.remove(self)
+            @queue << nil
+          end
+        end
+
+        class Streams
+          def initialize
+            @list = []
+          end
+
+          def size
+            @list.size
+          end
+
+          def new
+            stream = Stream.new(self)
+            @list << stream
+            stream
+          end
+
+          def remove(stream)
+            raise TypeError, "expected SSE::Stream" unless stream.is_a?(Stream)
+            @list.delete(stream)
+          end
+
+          def broadcast(data)
+            raise TypeError, "expected String" unless data.is_a?(String)
+            @list.each do |stream|
+              stream << Event.new(data)
+            end
+          end
+
+          def close
+            @list.each(&:close)
+            @list.clear
+          end
+        end
+      end
+    end
+  end
+end