@shopify/cli-kit 3.69.4 → 3.70.0

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

@@ -1,75 +0,0 @@
-# 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

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

@@ -1,64 +0,0 @@
-# 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, delete: true)
-          @ctx = ctx
-          @theme = theme
-          @syncer = syncer
-          @ignore_filter = ignore_filter
-          @delete = delete
-          @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
-
-          return unless @delete
-
-          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

@@ -1,140 +0,0 @@
-# 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

@@ -1,332 +0,0 @@
-# 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, :notify, :nodelete
-
-      class << self
-        def start(
-          ctx,
-          root,
-          host: "127.0.0.1",
-          theme: nil,
-          port: 9292,
-          poll: false,
-          editor_sync: false,
-          overwrite_json: false,
-          open_browser: false,
-          stable: false,
-          mode: ReloadMode.default,
-          includes: nil,
-          ignores: nil,
-          notify: nil,
-          nodelete: false,
-          &block
-        )
-          instance.setup(
-            ctx,
-            root,
-            host,
-            theme,
-            port,
-            poll,
-            editor_sync,
-            overwrite_json,
-            open_browser,
-            stable,
-            mode,
-            includes,
-            ignores,
-            notify,
-            nodelete,
-            &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,
-        overwrite_json,
-        open_browser,
-        stable,
-        mode,
-        includes,
-        ignores,
-        notify,
-        nodelete,
-        &block
-      )
-        @ctx = ctx
-        @root = root
-        @host = host
-        @theme_identifier = theme_identifier
-        @port = port
-        @poll = poll
-        @editor_sync = editor_sync
-        @overwrite_json = overwrite_json
-        @open_browser = open_browser
-        @stable = stable
-        @mode = mode
-        @includes = includes
-        @ignores = ignores
-        @notify = notify
-        @block = block
-        @nodelete = nodelete
-      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(ctx, @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
-        ctx.print_task(syncing_theme_message)
-        syncer.start_threads
-
-        if block
-          block.call(syncer)
-        else
-          syncer.upload_theme!(delay_low_priority_files: true, delete: !nodelete)
-        end
-
-        ctx.open_browser_url!(address) if @open_browser
-      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 || @overwrite_json,
-          stable: stable,
-          notify: notify
-        )
-      end
-
-      def watcher
-        @watcher ||= Watcher.new(
-          ctx,
-          theme: theme,
-          ignore_filter: ignore_filter,
-          syncer: syncer,
-          poll: poll,
-          delete: !nodelete
-        )
-      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

@@ -1,101 +0,0 @@
-# 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