fluid_cli 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d274a741ad9269d0d48c3ab12241f61b2ded2fcc2cbca333ddb99cb5d0cd106a
+  data.tar.gz: 3c8d4d513e15143633e3d12b9223a6697d5172a8aa9362d9a82462fa5cf98534
+SHA512:
+  metadata.gz: 02151415ea46eebd33d6acbb23adea014e5f262002a7d6d9664e48f8322f6e3ce988f6acf907037ced608ffc0a83905f66c38980570621563f6533d90981bdc6
+  data.tar.gz: 5ab472aed0268946d4dab19b7997dd80c5f4c88deb87a7916977f4d642499a398ef5b12a1ca8a7131ab71a578edaff410ba3f0cd06485d6072eafa25fcefd4b7

data/README.md

@@ -0,0 +1 @@
+# fluid_cli

data/dev.yml

@@ -0,0 +1,5 @@
+up:
+  - ruby: 3.2.2
+  - bundler
+
+build: bin/update-deps

data/exe/fluid

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby --disable-gems
+
+Encoding.default_external = Encoding::UTF_8
+Encoding.default_internal = Encoding::UTF_8
+
+unshift_path = ->(path) {
+  p = File.expand_path("../../#{path}", __FILE__)
+  $LOAD_PATH.unshift(p) unless $LOAD_PATH.include?(p)
+}
+unshift_path.call('vendor/deps/cli-ui/lib')
+unshift_path.call('vendor/deps/cli-kit/lib')
+unshift_path.call('vendor/deps/debug/lib')
+unshift_path.call('vendor/deps/webrick/lib')
+unshift_path.call('vendor/deps/base64/lib')
+# unshift_path.call('vendor/deps/listen/lib')
+# unshift_path.call('vendor/deps/observer/lib')
+unshift_path.call('lib')
+
+require 'bundler/setup'
+require 'fluid_cli'
+
+exit(FluidCLI::ErrorHandler.call do
+  FluidCLI::EntryPoint.call(ARGV.dup)
+end)

data/lib/fluid_cli/api.rb

@@ -0,0 +1,135 @@
+require "fluid_cli"
+require "securerandom"
+
+module FluidCLI
+  class API
+  
+    class APIRequestError < StandardError
+      attr_reader :response
+
+      def initialize(message = nil, response: nil)
+        super(message)
+        @response = response
+      end
+    end
+
+    class APIRequestNotFoundError < APIRequestError; end
+    class APIRequestClientError < APIRequestError; end
+    class APIRequestUnauthorizedError < APIRequestClientError; end
+    class APIRequestForbiddenError < APIRequestClientError; end
+    class APIRequestUnexpectedError < APIRequestError; end
+    class APIRequestRetriableError < APIRequestError; end
+    class APIRequestTimeoutError < APIRequestRetriableError; end
+    class APIRequestServerError < APIRequestRetriableError; end
+    class APIRequestThrottledError < APIRequestRetriableError; end
+
+    def initialize(ctx)
+      @ctx = ctx
+    end
+
+    def get(path:, **args, &block)
+      rest_request(method: "GET", path: path, **args, &block)
+    end
+
+    def put(path:, **args, &block)
+      rest_request(method: "PUT", path: path, **args, &block)
+    end
+
+    def post(path:, **args, &block)
+      rest_request(method: "POST", path: path, **args, &block)
+    end
+
+    def delete(path:, **args, &block)
+      rest_request(method: "DELETE", path: path, **args, &block)
+    end
+
+    def multipart_put(path:, **args, &block)
+      rest_request(method: "MULTIPART_PUT", path: path, **args, &block)
+    end
+
+    def rest_request(path:, query: nil, body: nil, method: "GET", token: nil)
+      CLI::Kit::Util.begin do
+        url = URI::HTTPS.build(
+          host: FluidCLI::API_HOST,
+          path: "/api/#{path}",
+          query: query,
+        )
+        resp = request(url: url.to_s, body: body, headers: auth_headers, method: method)
+        resp
+
+      end.retry_after(API::APIRequestUnauthorizedError) do
+        FluidCLI::IdentityAuth.new(ctx: @ctx).reauthenticate unless path == "/me"
+      end
+    end
+
+    def get_company_or_abort
+      env_store = FluidCLI::Environment.company
+      return env_store unless env_store.nil?
+
+      if FluidCLI::DB.exists?(:company)
+        FluidCLI::DB.get(:company)
+      else
+        resp = FluidCLI::IdentityAuth.new(ctx: @ctx).attempt_reauthenticate
+        @ctx.abort(
+          "No company found. Please login again"
+        ) unless resp 
+      end
+    end
+
+    private
+
+    def request(url:, body: nil, headers: {}, method: "POST")
+      CLI::Kit::Util.begin do
+        uri = URI.parse(url)
+        unless uri.is_a?(URI::HTTP)
+          @ctx.abort("Invalid URL: #{url}")
+        end
+
+        
+        # we delay this require so as to avoid a performance hit on starting the CLI
+        require "fluid_cli/http_request"
+        @ctx.debug("#{method} #{uri} with X-Request-Id: #{headers["X-Request-Id"]}")
+        response = if method == "POST"
+          HttpRequest.post(uri, body, headers)
+        elsif method == "PUT"
+          HttpRequest.put(uri, body, headers)
+        elsif method == "GET"
+          HttpRequest.get(uri, body, headers)
+        elsif method == "DELETE"
+          HttpRequest.delete(uri, body, headers)
+        elsif method == "MULTIPART_PUT"
+          HttpRequest.multipart_put(uri, body, headers)
+        end
+
+             
+        case response.code.to_i
+        when 200..399
+          [response.code.to_i, JSON.parse(response.body), response]
+        when 401
+          raise APIRequestUnauthorizedError.new("#{response.code}\n#{response.body}", response: response)
+        when 403
+          raise APIRequestForbiddenError.new("#{response.code}\n#{response.body}", response: response)
+        when 404
+          raise APIRequestNotFoundError.new("#{response.code}\n#{response.body}", response: response)
+        when 429
+          raise APIRequestThrottledError.new("#{response.code}\n#{response.body}", response: response)
+        when 400..499
+          raise APIRequestClientError.new("#{response.code}\n#{response.body}", response: response)
+        when 500..599
+          raise APIRequestServerError.new("#{response.code}\n#{response.body}", response: response)
+        else
+          raise APIRequestUnexpectedError.new("#{response.code}\n#{response.body}", response: response)
+        end
+      rescue Errno::ETIMEDOUT, Timeout::Error
+        @ctx.debug("timeout in #{method} #{uri} with X-Request-Id: #{headers["X-Request-Id"]}")
+        raise APIRequestTimeoutError, "Timeout"
+      end.retry_after(APIRequestRetriableError, retries: 3) do |e|
+        sleep(1) if e.is_a?(APIRequestThrottledError)
+      end
+    end
+
+    def auth_headers
+      { "Authorization" => "Bearer #{FluidCLI::Environment.auth_token || FluidCLI::DB.get(:jwt)}" }
+    end
+  end
+end

data/lib/fluid_cli/assets/post_auth_page/index.html.erb

@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Fluid CLI</title>
+    <style><%= locals[:css] %></style>
+    <link rel="icon" href="https://cdn.fluid.app/favicon-32x32.png" type="image/png">
+  </head>
+
+  <% if successful %>
+    <body class="body-success">
+      <div class="app-success">
+        <div class="container">
+          <h1><%= locals[:message] %></h1>
+          <p>You can close this tab and return to your terminal.</p>
+        </div>
+      </div>
+    </body>
+  <% else %>
+    <body class="body-error">
+      <div class="app-error">
+        <div class="container">
+          <h1>Something went wrong!</h1>
+          <p><%= locals[:message] %></p>
+          <br>
+          <br>
+          <p>Return to your terminal and try running the previous command again.</p>
+        </div>
+      </div>
+    </body>
+  <% end %>
+</html>

data/lib/fluid_cli/assets/post_auth_page/style.css

@@ -0,0 +1,58 @@
+html {
+  font-family: -apple-system, BlinkMacSystemFont, San Francisco, Segoe UI, Roboto, Helvetica Neue, sans-serif;
+  text-size-adjust: 100%;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+body {
+  font-size: 26px;
+  line-height: normal;
+  margin: 0;
+  padding: 0;
+}
+
+button, input, optgroup, select, textarea {
+  font-family: inherit;
+}
+
+h1 {
+  font-weight: 600;
+  font-size: 1em;
+}
+
+p {
+  font-weight: 400;
+}
+
+.body-success {
+  color: #F6F6F7;
+}
+
+.body-error {
+  color: #202223;
+}
+
+.app-success {
+  width: 100vw;
+  height: 100vh;
+  background-color: #054A49;
+  display: flex;
+}
+
+.app-error {
+  width: 100vw;
+  height: 100vh;
+  background-color: #F6F6F7;
+  display: flex;
+}
+
+.container {
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  width: 100%;
+  height: 100%;
+  padding-left: 7.5em;
+}

data/lib/fluid_cli/command.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+require "fluid_cli"
+
+module FluidCLI
+  class Command < CLI::Kit::BaseCommand
+    attr_writer :ctx
+    attr_accessor :options
+
+    class << self
+      attr_writer :ctx
+
+      def call(args, command_name, *)
+        subcommand, resolved_name = subcommand_registry.lookup_command(args.first)
+        if subcommand
+          subcommand.ctx = @ctx
+          subcommand.call(args.drop(1), resolved_name, command_name)
+        else
+          cmd = new(@ctx)
+          cmd.options.parse(@_options, args)
+          cmd.call(args, command_name)
+        end
+      end
+
+      def options(&block)
+        existing_options = @_options
+        # We prevent new options calls to override existing blocks by nesting them.
+        @_options = ->(parser, flags) {
+          existing_options&.call(parser, flags)
+          block.call(parser, flags)
+        }
+      end
+
+      def subcommand(const, cmd, path = nil)
+        autoload(const, path) if path
+        subcommand_registry.add(->() { const_get(const) }, cmd.to_s)
+      end
+
+      def subcommand_registry
+        @subcommand_registry ||= CLI::Kit::CommandRegistry.new(
+          default: nil)
+      end
+
+      def call_help(*cmds)
+        help = Commands::Help.new(@ctx)
+        help.call(cmds, nil)
+      end
+    end
+
+    def initialize(ctx = nil)
+      super()
+      @ctx = ctx || FluidCLI::Context.new
+      self.options = Options.new
+    end
+  end
+end

data/lib/fluid_cli/commands/help.rb

@@ -0,0 +1,21 @@
+require 'fluid_cli'
+
+module FluidCLI
+  module Commands
+    class Help < FluidCLI::Command
+      def call(args, _name)
+        puts CLI::UI.fmt("{{bold:Available commands}}")
+        puts ""
+
+        FluidCLI::Commands::Registry.resolved_commands.each do |name, klass|
+          next if name == 'help'
+          puts CLI::UI.fmt("{{command:#{FluidCLI::TOOL_NAME} #{name}}}")
+          if help = klass.help
+            puts CLI::UI.fmt(help)
+          end
+          puts ""
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/commands/login.rb

@@ -0,0 +1,30 @@
+require "fluid_cli"
+
+module FluidCLI
+  module Commands
+    class Login < FluidCLI::Command
+      PROTOCOL_REGEX = /^https?\:\/\//
+      PERMANENT_DOMAIN_SUFFIX = /\.myshopify\.(com|io)$/
+
+      options do |parser, flags|
+        parser.on("-c", "--company=COMPANY") { |url| flags[:company] = url }
+      end
+
+      def call(*)
+        company_identifier = (options.flags[:company] || @ctx.getenv("FLUID_COMPANY" || nil))
+        IdentityAuth.new(ctx: @ctx).authenticate(spinner: true)
+        company = FluidCLI::CompanySwitcher.new(
+          ctx: @ctx,
+          company: company_identifier,
+          switched_after_login: true
+        ).switch
+        Whoami.call([], "whoami")
+      end
+
+      def self.help
+        "Log in to your Fluid account"
+      end
+    end
+  end
+end
+

data/lib/fluid_cli/commands/logout.rb

@@ -0,0 +1,38 @@
+require "fluid_cli"
+require "fluid_cli/theme/development_theme"
+
+module FluidCLI
+  module Commands
+    class Logout < FluidCLI::Command
+      def call(*)
+        try_delete_development_theme
+
+        FluidCLI::IdentityAuth.delete_tokens_and_keys
+        FluidCLI::DB.del(:company) if has_company?
+        @ctx.puts("Logged out successfully.")
+      end
+
+      def self.help
+        "Logs out the current user."
+      end
+
+      private
+
+      def has_company?
+        FluidCLI::DB.exists?(:company)
+      end
+
+      def try_delete_development_theme
+        return unless has_company?
+
+        FluidCLI::Theme::DevelopmentTheme.delete(@ctx)
+      rescue FluidCLI::API::APIRequestError, CLI::Kit::Abort, CLI::Kit::AbortSilent => e
+        @ctx.debug("[Logout Error]: #{e.message}")
+      end
+
+      def has_company?
+        FluidCLI::DB.exists?(:company)
+      end
+    end
+  end
+end

data/lib/fluid_cli/commands/switch.rb

@@ -0,0 +1,23 @@
+require "fluid_cli"
+
+module FluidCLI
+  module Commands
+    class Switch < FluidCLI::Command
+      options do |parser, flags|
+        parser.on("-c", "--company=COMPANY") { |url| flags[:company] = url }
+      end
+
+      def call(*)
+        company = FluidCLI::CompanySwitcher.new(
+          ctx: @ctx,
+          company: options.flags[:company]
+        ).switch
+        @ctx.puts("Switched to company '#{company['name']}' successfully.")
+      end
+
+      def self.help
+        "Switches the current company context."
+      end
+    end
+  end
+end

data/lib/fluid_cli/commands/theme/common/company_helper.rb

@@ -0,0 +1,15 @@
+require 'fluid_cli'
+
+module FluidCLI
+  module Commands
+    class Theme
+      module Common
+        module CompanyHelper
+          def company
+            FluidCLI::API.new(@ctx).get_company_or_abort
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/commands/theme/common/root_helper.rb

@@ -0,0 +1,95 @@
+require 'fluid_cli'
+
+module FluidCLI
+  module Commands
+    class Theme
+      module Common
+        module RootHelper
+          REQUIRED_FOLDERS = %w(config layouts sections product shop_page).freeze
+
+          def root_value(options, name)
+            argv = default_argv(options)
+            command_index = argv.index(name.to_s)
+
+            return "." if command_index.nil?
+
+            next_index = command_index + 1
+            option_by_key = options_map(options)
+
+            while next_index < argv.size
+              element = argv[next_index]
+              key, value = key_value_tuple(element)
+              option = option_by_key[key]
+
+              return element if option.nil?
+
+              # Skip the option argument
+              next_index += 1 if !option.arg.nil? && !value
+
+              # PATTERN arguments take precedence over the `root`
+              if option.arg =~ /PATTERN/ && !value
+                next_index += 1 while option_argument?(argv, next_index, option_by_key)
+                next
+              end
+
+              next_index += 1
+            end
+
+            "."
+          end
+
+          def valid_theme_directory?(root)
+            REQUIRED_FOLDERS.all? { |required_folder| Dir.exist?(File.join(root, required_folder)) } ||
+              current_directory_confirmed?
+          end
+
+          def exist_and_not_empty?(root)
+            Dir.exist?(root) && !Dir[File.join(root, "*")].empty?
+          end
+
+          private
+
+          def current_directory_confirmed?
+            return true if options.flags[:force]
+
+            @ctx.warn("Warning: The specified directory does not appear to be a valid theme directory.")
+
+
+            return true if !FluidCLI::Environment.interactive?
+
+            CLI::UI::Prompt.confirm("Do you want to continue?", default: false)
+          end
+
+          def default_argv(options)
+            options.parser.default_argv.compact
+          end
+
+          def options_map(options)
+            map = {}
+            options_list(options).each do |option|
+              map[option.short.first] = option
+              map[option.long.first] = option
+            end
+            map
+          end
+
+          def options_list(options)
+            options.parser.top.list
+          end
+
+          def option_argument?(argv, next_index, option_by_key)
+            return false unless next_index < argv.size
+
+            element = argv[next_index]
+            key, _value = key_value_tuple(element)
+            option_by_key[key].nil?
+          end
+
+          def key_value_tuple(element)
+            element.split("=")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/commands/theme/dev.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+require "fluid_cli/theme/dev_server"
+require "fluid_cli/commands/theme/common/root_helper"
+# require "fluid_cli/theme/conversions/include_glob"
+# require "fluid_cli/theme/conversions/ignore_glob"
+module FluidCLI
+  module Commands
+    class Theme
+      class Dev < FluidCLI::Command
+        include Common::RootHelper
+
+        # recommend_default_ruby_range
+
+        DEFAULT_HTTP_HOST = "127.0.0.1"
+
+        options do |parser, flags|
+          # Conversions::IncludeGlob.register(parser)
+          # Conversions::IgnoreGlob.register(parser)
+
+          parser.on("--host=HOST") { |host| flags[:host] = host.to_s }
+          parser.on("--port=PORT") { |port| flags[:port] = port.to_i }
+          parser.on("--poll") { flags[:poll] = true }
+          parser.on("--live-reload=MODE") { |mode| flags[:mode] = as_reload_mode(mode) }
+          parser.on("-t", "--theme=NAME_OR_ID") { |theme| flags[:theme] = theme }
+          parser.on("-f", "--force") { flags[:force] = true }
+          parser.on("--overwrite-json") { flags[:overwrite_json] = true }
+        end
+
+        def call(_args, name)
+          valid_authentication_method!
+
+          root = root_value(options, name)
+          return unless valid_theme_directory?(root)
+
+          flags = options.flags.dup
+          host = flags[:host] || DEFAULT_HTTP_HOST
+
+          FluidCLI::Theme::DevServer.start(@ctx, root, host: host, **flags) do |syncer|
+            FluidCLI::Theme::UI::SyncProgressBar.new(syncer).progress(:upload_theme!, delay_low_priority_files: true)
+          end
+        end
+
+        def self.as_reload_mode(mode)
+          FluidCLI::Theme::DevServer::ReloadMode.get!(mode)
+        end
+
+        def self.help
+          FluidCLI::Context.message("theme.serve.help", FluidCLI::TOOL_NAME)
+        end
+
+        private
+
+        def valid_authentication_method!
+          if FluidCLI::Environment.auth_token.nil? && FluidCLI::DB.get(:jwt).nil?
+            FluidCLI::Context.abort("Auth token is missing", "Please login using 'fluid_cli login' command.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/commands/theme/help.rb

@@ -0,0 +1,21 @@
+require 'fluid_cli'
+
+module FluidCLI
+  module Commands
+    class Theme
+      class Help
+        def call(_args, _name)
+          puts 'neato'
+
+          if rand < 0.05
+            raise(CLI::Kit::Abort, "you got unlucky!")
+          end
+        end
+
+        def self.help
+          "A dummy command.\nUsage: {{command:#{FluidCLI::TOOL_NAME} example}}"
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/commands/theme/init.rb

@@ -0,0 +1,46 @@
+require 'fluid_cli'
+
+module FluidCLI
+  module Commands
+    class Theme
+      class Init < FluidCLI::Command
+        options do |parser, flags|
+          parser.on("-u", "--clone-url URL") { |url| flags[:clone_url] = url }
+        end
+
+        DEFAULT_CLONE_URL = "git@github.com:fluid-commerce/base-theme.git"
+
+        def call(args, _name)
+          name = args.first || ask_name
+          clone_url = options.flags[:clone_url] || DEFAULT_CLONE_URL
+          puts "Cloning theme from #{clone_url} into #{name}..."
+
+          clone(clone_url, name)
+        end
+
+        def self.help
+          "Initialize a new theme by cloning the base theme."
+        end
+
+        private
+
+        def ask_name
+          CLI::UI::Prompt.ask("Theme name")
+        end
+
+        def clone(url, name)
+          FluidCLI::Git.clone(url, name)
+
+          @ctx.root = File.join(@ctx.root, name)
+
+          begin
+            @ctx.rm_r(".git")
+            @ctx.rm_r(".github")
+          rescue Errno::ENOENT => e
+            @ctx.debug(e)
+          end
+        end
+      end
+    end
+  end
+end