shopify-cli 0.9.0

data/lib/shopify-cli/oauth.rb

@@ -0,0 +1,192 @@
+require 'base64'
+require 'digest'
+require 'json'
+require 'net/http'
+require 'securerandom'
+require 'openssl'
+require 'shopify_cli'
+require 'uri'
+require 'webrick'
+
+module ShopifyCli
+  class OAuth
+    include SmartProperties
+
+    autoload :Servlet, 'shopify-cli/oauth/servlet'
+
+    class Error < StandardError; end
+    LocalRequest = Struct.new(:method, :path, :query, :protocol)
+
+    DEFAULT_PORT = 3456
+    REDIRECT_HOST = "http://127.0.0.1:#{DEFAULT_PORT}"
+
+    property! :ctx
+    property! :service, accepts: String
+    property! :client_id, accepts: String
+    property! :scopes
+    property :store, default: ShopifyCli::DB.new
+    property :secret, accepts: String
+    property :request_exchange, accepts: String
+    property :options, default: {}, accepts: Hash
+    property :auth_path, default: "/authorize", accepts: ->(path) { path.is_a?(String) && path.start_with?("/") }
+    property :token_path, default: "/token", accepts: ->(path) { path.is_a?(String) && path.start_with?("/") }
+    property :state_token, accepts: String, default: SecureRandom.hex(30)
+    property :code_verifier, accepts: String, default: SecureRandom.hex(30)
+
+    attr_accessor :response_query
+
+    def authenticate(url)
+      return if refresh_exchange_token(url)
+      return if refresh_access_token(url)
+      initiate_authentication(url)
+      request_access_token(url, code: receive_access_code)
+      request_exchange_token(url) if should_exchange
+    end
+
+    def code_challenge
+      @code_challenge ||= Base64.urlsafe_encode64(
+        OpenSSL::Digest::SHA256.digest(code_verifier),
+        padding: false,
+      )
+    end
+
+    def server
+      @server ||= begin
+        server = WEBrick::HTTPServer.new(
+          Port: DEFAULT_PORT,
+          Logger: WEBrick::Log.new(File.open(File::NULL, 'w')),
+          AccessLog: [],
+        )
+        server.mount('/', Servlet, self, state_token)
+        server
+      end
+    end
+
+    private
+
+    def initiate_authentication(url)
+      @server_thread = Thread.new { server.start }
+      params = {
+        client_id: client_id,
+        scope: scopes,
+        redirect_uri: REDIRECT_HOST,
+        state: state_token,
+        response_type: :code,
+      }
+      params.merge!(challange_params) if secret.nil?
+      uri = URI.parse("#{url}#{auth_path}")
+      uri.query = URI.encode_www_form(params.merge(options))
+      output_authentication_info(uri)
+    end
+
+    def output_authentication_info(uri)
+      login_location = ctx.message(service == 'admin' ? 'core.oauth.location.admin' : 'core.oauth.location.partner')
+      ctx.puts(ctx.message('core.oauth.authentication_required', login_location))
+      ctx.open_url!(uri)
+    end
+
+    def receive_access_code
+      @access_code ||= begin
+        @server_thread.join(240)
+        raise Error, ctx.message('core.oauth.error.timeout') if response_query.nil?
+        raise Error, response_query['error_description'] unless response_query['error'].nil?
+        response_query['code']
+      end
+    end
+
+    def request_access_token(url, code:)
+      resp = post_token_request(
+        "#{url}#{token_path}",
+        {
+          grant_type: :authorization_code,
+          code: code,
+          redirect_uri: REDIRECT_HOST,
+          client_id: client_id,
+        }.merge(confirmation_param)
+      )
+      store.set(
+        "#{service}_access_token".to_sym => resp['access_token'],
+        "#{service}_refresh_token".to_sym => resp['refresh_token'],
+      )
+    end
+
+    def refresh_access_token(url)
+      return false if !store.exists?("#{service}_access_token".to_sym) ||
+        !store.exists?("#{service}_refresh_token".to_sym)
+      refresh_token(url)
+      request_exchange_token(url) if should_exchange
+      true
+    rescue
+      store.del("#{service}_access_token".to_sym, "#{service}_refresh_token".to_sym)
+      false
+    end
+
+    def refresh_token(url)
+      resp = post_token_request(
+        "#{url}#{token_path}",
+        grant_type: :refresh_token,
+        access_token: store.get("#{service}_access_token".to_sym),
+        refresh_token: store.get("#{service}_refresh_token".to_sym),
+        client_id: client_id,
+      )
+      store.set(
+        "#{service}_access_token".to_sym => resp['access_token'],
+        "#{service}_refresh_token".to_sym => resp['refresh_token'],
+      )
+    end
+
+    def refresh_exchange_token(url)
+      return false if !should_exchange || !store.exists?("#{service}_exchange_token".to_sym)
+      request_exchange_token(url)
+      true
+    rescue
+      store.del("#{service}_exchange_token".to_sym)
+      false
+    end
+
+    def request_exchange_token(url)
+      resp = post_token_request(
+        "#{url}#{token_path}",
+        grant_type: "urn:ietf:params:oauth:grant-type:token-exchange",
+        requested_token_type: "urn:ietf:params:oauth:token-type:access_token",
+        subject_token_type: "urn:ietf:params:oauth:token-type:access_token",
+        client_id: client_id,
+        audience: request_exchange,
+        scope: scopes,
+        subject_token: store.get("#{service}_access_token".to_sym),
+      )
+      store.set("#{service}_exchange_token".to_sym => resp['access_token'])
+    end
+
+    def post_token_request(url, params)
+      uri = URI.parse(url)
+      https = Net::HTTP.new(uri.host, uri.port)
+      https.use_ssl = true
+      request = Net::HTTP::Post.new(uri.path)
+      request['User-Agent'] = "Shopify App CLI #{::ShopifyCli::VERSION}"
+      request.body = URI.encode_www_form(params)
+      res = https.request(request)
+      raise Error, JSON.parse(res.body)['error_description'] unless res.is_a?(Net::HTTPSuccess)
+      JSON.parse(res.body)
+    end
+
+    def challange_params
+      {
+        code_challenge: code_challenge,
+        code_challenge_method: 'S256',
+      }
+    end
+
+    def confirmation_param
+      if secret.nil?
+        { code_verifier: code_verifier }
+      else
+        { client_secret: secret }
+      end
+    end
+
+    def should_exchange
+      !request_exchange.nil? && !request_exchange.empty?
+    end
+  end
+end

data/lib/shopify-cli/oauth/servlet.rb

@@ -0,0 +1,61 @@
+module ShopifyCli
+  class OAuth
+    class Servlet < WEBrick::HTTPServlet::AbstractServlet
+      TEMPLATE = %{<!DOCTYPE html>
+        <html>
+        <head>
+          <title>%{title}</title>
+        </head>
+        <body>
+          <h1 style="color: #%{color};">%{message}</h1>
+          %{autoclose}
+        </body>
+        </html>
+      }
+      AUTOCLOSE_TEMPLATE = %{
+        <script>
+          setTimeout(function() { window.close(); }, 3000)
+        </script>
+      }
+
+      def initialize(server, oauth, token)
+        super
+        @server = server
+        @oauth = oauth
+        @state_token = token
+      end
+
+      def do_GET(req, res) # rubocop:disable Naming/MethodName
+        if !req.query['error'].nil?
+          respond_with(
+            res,
+            400,
+            Context.message('core.oauth.servlet.invalid_request_response', req.query['error_description'])
+          )
+        elsif req.query['state'] != @state_token
+          response_message = Context.message('core.oauth.servlet.invalid_state_response')
+          req.query.merge!('error' => 'invalid_state', 'error_description' => response_message)
+          respond_with(res, 403, response_message)
+        else
+          respond_with(res, 200, Context.message('core.oauth.servlet.success_response'))
+        end
+        @oauth.response_query = req.query
+        @server.shutdown
+      end
+
+      def respond_with(response, status, message)
+        successful = status == 200
+        locals = {
+          status: status,
+          message: message,
+          color: successful ? 'black' : 'red',
+          title:
+            Context.message(successful ? 'core.oauth.servlet.authenticated' : 'core.oauth.servlet.not_authenticated'),
+          autoclose: successful ? AUTOCLOSE_TEMPLATE : '',
+        }
+        response.status = status
+        response.body = format(TEMPLATE, locals)
+      end
+    end
+  end
+end

data/lib/shopify-cli/options.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require 'shopify_cli'
+require 'optparse'
+
+module ShopifyCli
+  class Options
+    include SmartProperties
+
+    attr_reader :flags, :subcommand, :help
+
+    def initialize
+      @flags = {}
+      @help = false
+    end
+
+    def parse(options_block, args)
+      @args = args
+      if options_block.respond_to?(:call) && args
+        parse_flags(options_block)
+      else
+        parser.permute!(@args)
+      end
+      @args
+    end
+
+    def parse_flags(block)
+      block.call(parser, @flags)
+      parser.permute!(@args)
+    end
+
+    def parser
+      @parser ||= begin
+        opt = OptionParser.new
+        opt.on('--help', '-h', Context.message('core.options.help_text')) do |v|
+          @help = v
+        end
+      end
+    end
+  end
+end

data/lib/shopify-cli/packager.rb

@@ -0,0 +1,116 @@
+module ShopifyCli
+  class Packager
+    PACKAGING_DIR = File.join(ShopifyCli::ROOT, 'packaging')
+    BUILDS_DIR = File.join(PACKAGING_DIR, 'builds', ShopifyCli::VERSION)
+
+    def initialize
+      FileUtils.mkdir_p(BUILDS_DIR)
+    end
+
+    def build_gem
+      build_path = gem_path
+      puts "\nBuilding gem"
+
+      puts "Outputting gem to:\n  #{build_path}\n\n"
+      raise "Failed to build gem" unless system(
+        'gem',
+        'build',
+        '-o',
+        build_path,
+        File.join(ShopifyCli::ROOT, 'shopify-cli.gemspec')
+      )
+    end
+
+    def build_debian
+      ensure_program_installed('dpkg-deb')
+
+      root_dir = File.join(PACKAGING_DIR, 'debian')
+      debian_dir = File.join(root_dir, 'shopify-cli', 'DEBIAN')
+      FileUtils.mkdir_p(debian_dir)
+
+      puts "\nBuilding Debian package"
+
+      puts "Generating metadata files..."
+      Dir.glob("#{debian_dir}/*").each { |file| File.delete(file) }
+
+      metadata_files = %w(control preinst prerm)
+      metadata_files.each do |file|
+        file_path = File.join(debian_dir, file)
+
+        file_contents = File.read(File.join(root_dir, "#{file}.base"))
+        file_contents = file_contents.gsub('SHOPIFY_CLI_VERSION', ShopifyCli::VERSION)
+        File.open(file_path, 'w', 0775) { |f| f.write(file_contents) }
+      end
+
+      puts "Building package..."
+      Dir.chdir(root_dir)
+      raise "Failed to build package" unless system('dpkg-deb', '-b', 'shopify-cli')
+
+      output_path = File.join(root_dir, 'shopify-cli.deb')
+      final_path = File.join(BUILDS_DIR, "shopify-cli-#{ShopifyCli::VERSION}.deb")
+
+      puts "Moving generated package: \n  From: #{output_path}\n  To: #{final_path}\n\n"
+      FileUtils.mv(output_path, final_path)
+    end
+
+    def build_rpm
+      ensure_program_installed('rpmbuild')
+
+      root_dir = File.join(PACKAGING_DIR, 'rpm')
+      rpm_build_dir = File.join(root_dir, 'build')
+      FileUtils.mkdir_p(rpm_build_dir)
+
+      spec_path = File.join(root_dir, 'shopify-cli.spec')
+      puts "\nBuilding RPM package"
+
+      puts "Generating spec file..."
+      File.delete(spec_path) if File.exist?(spec_path)
+
+      spec_contents = File.read(File.join(root_dir, 'shopify-cli.spec.base'))
+      spec_contents = spec_contents.gsub('SHOPIFY_CLI_VERSION', ShopifyCli::VERSION)
+      File.write(spec_path, spec_contents)
+
+      puts "Building package..."
+      Dir.chdir(root_dir)
+      system('rpmbuild', '-bb', File.basename(spec_path))
+
+      output_dir = File.join(root_dir, 'build', 'noarch')
+
+      puts "Moving generated packages: \n  From: #{output_dir}\n  To: #{BUILDS_DIR}\n\n"
+      FileUtils.mv(Dir.glob("#{output_dir}/*.rpm"), BUILDS_DIR)
+    end
+
+    def build_homebrew
+      root_dir = File.join(PACKAGING_DIR, 'homebrew')
+
+      build_path = File.join(BUILDS_DIR, "shopify-cli.rb")
+      puts "\nBuilding Homebrew package"
+
+      puts "Generating formula..."
+      File.delete(build_path) if File.exist?(build_path)
+
+      spec_contents = File.read(File.join(root_dir, 'shopify-cli.base.rb'))
+      spec_contents = spec_contents.gsub('SHOPIFY_CLI_VERSION', ShopifyCli::VERSION)
+
+      checksum = %x`shasum -a 256 #{gem_path}`
+      gem_checksum = checksum.split(' ')[0]
+
+      puts "Got sha256 sum for gem: #{gem_checksum}"
+      spec_contents = spec_contents.gsub('SHOPIFY_CLI_GEM_CHECKSUM', gem_checksum)
+
+      puts "Writing generated formula\n  To: #{build_path}\n\n"
+      File.write(build_path, spec_contents)
+    end
+
+    private
+
+    def ensure_program_installed(program)
+      raise "Could not find program #{program} which is required to build the package" unless
+        system(program, '--version', out: File::NULL, err: File::NULL)
+    end
+
+    def gem_path
+      File.join(BUILDS_DIR, "shopify-cli.gem")
+    end
+  end
+end

data/lib/shopify-cli/partners_api.rb

@@ -0,0 +1,114 @@
+require 'shopify_cli'
+
+module ShopifyCli
+  ##
+  # ShopifyCli::PartnersAPI provides easy access to the partners dashboard CLI
+  # schema.
+  #
+  class PartnersAPI < API
+    autoload :Organizations, 'shopify-cli/partners_api/organizations'
+
+    # Defines the environment variable that this API looks for to operate on local
+    # services. If you set this environment variable in your shell then the partners
+    # api will operation on your local instance
+    #
+    # #### Example
+    #
+    #  SHOPIFY_APP_CLI_LOCAL_PARTNERS=1 shopify create
+    #
+    LOCAL_DEBUG = 'SHOPIFY_APP_CLI_LOCAL_PARTNERS'
+
+    class << self
+      ##
+      # issues a graphql query or mutation to the Shopify Partners Dashboard CLI Schema.
+      # It loads a graphql query from a file so that you do not need to use large
+      # unwieldy query strings. It also handles authentication for you as well.
+      #
+      # #### Parameters
+      # - `ctx`: running context from your command
+      # - `query_name`: name of the query you want to use, loaded from the `lib/graphql` directory.
+      # - `**variable`: a hash of variables to be supplied to the query ro mutation
+      #
+      # #### Raises
+      #
+      # * http 404 will raise a ShopifyCli::API::APIRequestNotFoundError
+      # * http 400..499 will raise a ShopifyCli::API::APIRequestClientError
+      # * http 500..599 will raise a ShopifyCli::API::APIRequestServerError
+      # * All other codes will raise ShopifyCli::API::APIRequestUnexpectedError
+      #
+      # #### Returns
+      #
+      # * `resp` - graphql response data hash. This can be a different shape for every query.
+      #
+      # #### Example
+      #
+      #   ShopifyCli::PartnersAPI.query(@ctx, 'all_organizations')
+      #
+      def query(ctx, query_name, **variables)
+        authenticated_req(ctx) do
+          api_client(ctx).query(query_name, variables: variables)
+        end
+      end
+
+      private
+
+      def authenticated_req(ctx)
+        yield
+      rescue API::APIRequestUnauthorizedError
+        authenticate(ctx)
+        retry
+      rescue API::APIRequestNotFoundError
+        ctx.puts(ctx.message('core.partners_api.error.account_not_found', ShopifyCli::TOOL_NAME))
+      end
+
+      def api_client(ctx)
+        new(
+          ctx: ctx,
+          token: access_token(ctx),
+          url: "#{endpoint}/api/cli/graphql",
+        )
+      end
+
+      def access_token(ctx)
+        ShopifyCli::DB.get(:identity_exchange_token) do
+          authenticate(ctx)
+          ShopifyCli::DB.get(:identity_exchange_token)
+        end
+      end
+
+      def authenticate(ctx)
+        OAuth.new(
+          ctx: ctx,
+          service: 'identity',
+          client_id: cli_id,
+          scopes: 'openid https://api.shopify.com/auth/partners.app.cli.access',
+          request_exchange: partners_id,
+        ).authenticate("#{auth_endpoint}/oauth")
+      end
+
+      def partners_id
+        return '271e16d403dfa18082ffb3d197bd2b5f4479c3fc32736d69296829cbb28d41a6' if ENV[LOCAL_DEBUG].nil?
+        'df89d73339ac3c6c5f0a98d9ca93260763e384d51d6038da129889c308973978'
+      end
+
+      def cli_id
+        return 'fbdb2649-e327-4907-8f67-908d24cfd7e3' if ENV[LOCAL_DEBUG].nil?
+        'e5380e02-312a-7408-5718-e07017e9cf52'
+      end
+
+      def auth_endpoint
+        return 'https://accounts.shopify.com' if ENV[LOCAL_DEBUG].nil?
+        'https://identity.myshopify.io'
+      end
+
+      def endpoint
+        return 'https://partners.shopify.com' if ENV[LOCAL_DEBUG].nil?
+        'https://partners.myshopify.io/'
+      end
+    end
+
+    def auth_headers(token)
+      { Authorization: "Bearer #{token}" }
+    end
+  end
+end