uffizzi-cli 0.11.5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a81fa2bb6f00491f6c59e4c10ea3ce067da1b75b26ff8543e1a08558893058c0
-  data.tar.gz: fec82e0d04c499515f0221740a1a40b51bd5593a35223c0a7723648f20b25a5e
+  metadata.gz: ac2d58dae4db13ed788532732a92f9d4a317780cb4b80ef07d185f899d10749d
+  data.tar.gz: a1b4b37db41936eabb930febe701186027a80d0684ca371ed442168caecea779
 SHA512:
-  metadata.gz: 82610a6fe745521646e7d7e7c5e0f65a39263ea53987f1e431d0a0d0b69033d015a67bcd48b07e30c5d044f2167c752f307525438ca232044e90c5b60eb0f602
-  data.tar.gz: 67d5b6c3947e01e72c3ec678b6b14a1ccc6b78583d34f46274cdfa1f7692c9632b98728f43bf1ab5e0b3e984313db98e536c5231ddb9d2a07cc8156b8334ca2e
+  metadata.gz: c2420a93b4b17a5efb2de11ed5a998070da7eb2f8f22a2d09bf2598b4eb88841f428f0a87cf7de7c5b49e289f12f2d85413aa96600ca3726b71b5ec962e6b68c
+  data.tar.gz: 2dff8bd8e614d8ffaad6a2b42f528844c5a6d1232c2327bcb756c8ae6d4b014e3b310965f01fd86dc2d6eb40cb9aaab10755ef707a0dc808538620581b1f09cb

data/config/uffizzi.rb

@@ -19,6 +19,7 @@ module Uffizzi
       google: 'UffizziCore::Credential::Google',
       amazon: 'UffizziCore::Credential::Amazon',
       github_registry: 'UffizziCore::Credential::GithubContainerRegistry',
+      docker_registry: 'UffizziCore::Credential::DockerRegistry',
     }
     config.default_server = 'app.uffizzi.com'
   end

data/lib/uffizzi/cli/connect.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'uffizzi'
+require 'uffizzi/helpers/connect_helper'
 
 module Uffizzi
   class Cli::Connect < Thor
@@ -9,7 +10,8 @@ module Uffizzi
     desc 'list-credentials', 'List existing credentials for an account'
     def list_credentials
       server = ConfigFile.read_option(:server)
-      response = fetch_credentials(server)
+      account_id = ConfigFile.read_option(:account_id)
+      response = fetch_credentials(server, account_id)
       if ResponseHelper.ok?(response)
         handle_list_credentials_success(response)
       else
@@ -21,42 +23,77 @@ module Uffizzi
     method_option :skip_raise_existence_error, type: :boolean, default: false,
                                                desc: 'Skip raising an error within check the credential'
     method_option :update_credential_if_exists, type: :boolean, default: false
+    method_option :username, type: :string, aliases: :u
+    method_option :password, type: :string, aliases: :p
     def docker_hub
       type = Uffizzi.configuration.credential_types[:dockerhub]
       credential_exists = credential_exists?(type)
       handle_existing_credential_options('docker-hub') if credential_exists
 
-      username = ENV['DOCKERHUB_USERNAME'] || Uffizzi.ui.ask('Username:')
-      password = ENV['DOCKERHUB_PASSWORD'] || Uffizzi.ui.ask('Password:', echo: false)
+      username, password = Uffizzi::ConnectHelper.get_docker_hub_data(options)
 
       params = {
         username: username,
         password: password,
         type: type,
       }
+      server = ConfigFile.read_option(:server)
+      account_id = ConfigFile.read_option(:account_id)
+
+      response = if credential_exists
+        update_credential(server, account_id, params, type)
+      else
+        create_credential(server, account_id, params)
+      end
+
+      handle_result_for('Docker Hub', response)
+    end
+
+    desc 'docker-registry', 'Connect to any registry implementing the Docker Registry HTTP API protocol'
+    method_option :skip_raise_existence_error, type: :boolean, default: false,
+                                               desc: 'Skip raising an error within check the credential'
+    method_option :update_credential_if_exists, type: :boolean, default: false
+    method_option :registry, type: :string, aliases: :r
+    method_option :username, type: :string, aliases: :u
+    method_option :password, type: :string, aliases: :p
+    def docker_registry
+      type = Uffizzi.configuration.credential_types[:docker_registry]
+      credential_exists = credential_exists?(type)
+      handle_existing_credential_options('docker-registry') if credential_exists
+
+      registry_url, username, password = Uffizzi::ConnectHelper.get_docker_registry_data(options)
 
+      params = {
+        registry_url: prepare_registry_url(registry_url),
+        username: username,
+        password: password,
+        type: type,
+      }
       server = ConfigFile.read_option(:server)
-      response = create_or_update_credential(server, params, create: !credential_exists)
+      account_id = ConfigFile.read_option(:account_id)
 
-      if successful?(response)
-        print_success_message('Docker Hub')
+      response = if credential_exists
+        update_credential(server, account_id, params, type)
       else
-        ResponseHelper.handle_failed_response(response)
+        create_credential(server, account_id, params)
       end
+
+      handle_result_for('Docker Registry', response)
     end
 
     desc 'acr', 'Connect to Azure Container Registry (azurecr.io)'
     method_option :skip_raise_existence_error, type: :boolean, default: false,
                                                desc: 'Skip raising an error within check the credential'
     method_option :update_credential_if_exists, type: :boolean, default: false
+    method_option :registry, type: :string, aliases: :r
+    method_option :username, type: :string, aliases: :u
+    method_option :password, type: :string, aliases: :p
     def acr
       type = Uffizzi.configuration.credential_types[:azure]
       credential_exists = credential_exists?(type)
       handle_existing_credential_options('acr') if credential_exists
 
-      registry_url = ENV['ACR_REGISTRY_URL'] || Uffizzi.ui.ask('Registry Domain:')
-      username = ENV['ACR_USERNAME'] || Uffizzi.ui.ask('Docker ID:')
-      password = ENV['ACR_PASSWORD'] || Uffizzi.ui.ask('Password/Access Token:', echo: false)
+      registry_url, username, password = Uffizzi::ConnectHelper.get_acr_data(options)
 
       params = {
         username: username,
@@ -64,45 +101,48 @@ module Uffizzi
         registry_url: prepare_registry_url(registry_url),
         type: type,
       }
-
       server = ConfigFile.read_option(:server)
-      response = create_or_update_credential(server, params, create: !credential_exists)
+      account_id = ConfigFile.read_option(:account_id)
 
-      if successful?(response)
-        print_success_message('ACR')
+      response = if credential_exists
+        update_credential(server, account_id, params, type)
       else
-        ResponseHelper.handle_failed_response(response)
+        create_credential(server, account_id, params)
       end
+
+      handle_result_for('ACR', response)
     end
 
     desc 'ecr', 'Connect to Amazon Elastic Container Registry'
     method_option :skip_raise_existence_error, type: :boolean, default: false,
                                                desc: 'Skip raising an error within check the credential'
     method_option :update_credential_if_exists, type: :boolean, default: false
+    method_option :registry, type: :string, aliases: :r
+    method_option :id, type: :string
+    method_option :secret, type: :string, aliases: :s
     def ecr
       type = Uffizzi.configuration.credential_types[:amazon]
       credential_exists = credential_exists?(type)
       handle_existing_credential_options('ecr') if credential_exists
 
-      registry_url = ENV['AWS_REGISTRY_URL'] || Uffizzi.ui.ask('Registry Domain:')
-      access_key = ENV['AWS_ACCESS_KEY_ID'] || Uffizzi.ui.ask('Access key ID:')
-      secret_access_key = ENV['AWS_SECRET_ACCESS_KEY'] || Uffizzi.ui.ask('Secret access key:', echo: false)
+      registry_url, access_key_id, secret_access_key = Uffizzi::ConnectHelper.get_ecr_data(options)
 
       params = {
-        username: access_key,
+        username: access_key_id,
         password: secret_access_key,
         registry_url: prepare_registry_url(registry_url),
         type: type,
       }
-
       server = ConfigFile.read_option(:server)
-      response = create_or_update_credential(server, params, create: !credential_exists)
+      account_id = ConfigFile.read_option(:account_id)
 
-      if successful?(response)
-        print_success_message('ECR')
+      response = if credential_exists
+        update_credential(server, account_id, params, type)
       else
-        ResponseHelper.handle_failed_response(response)
+        create_credential(server, account_id, params)
       end
+
+      handle_result_for('ECR', response)
     end
 
     desc 'gcr', 'Connect to Google Container Registry (gcr.io)'
@@ -120,15 +160,16 @@ module Uffizzi
         password: credential_content,
         type: type,
       }
-
       server = ConfigFile.read_option(:server)
-      response = create_or_update_credential(server, params, create: !credential_exists)
+      account_id = ConfigFile.read_option(:account_id)
 
-      if successful?(response)
-        print_success_message('GCR')
+      response = if credential_exists
+        update_credential(server, account_id, params, type)
       else
-        ResponseHelper.handle_failed_response(response)
+        create_credential(server, account_id, params)
       end
+
+      handle_result_for('GCR', response)
     end
 
     desc 'ghcr', 'Connect to GitHub Container Registry (ghcr.io)'
@@ -142,32 +183,37 @@ module Uffizzi
       credential_exists = credential_exists?(type)
       handle_existing_credential_options('ghcr') if credential_exists
 
-      username = options[:username] || ENV['GITHUB_USERNAME'] || Uffizzi.ui.ask('Github Username:')
-      password = options[:token] || ENV['GITHUB_ACCESS_TOKEN'] || Uffizzi.ui.ask('Access Token:', echo: false)
+      username, password = Uffizzi::ConnectHelper.get_ghcr_data(options)
 
       params = {
         username: username,
         password: password,
         type: type,
       }
-
       server = ConfigFile.read_option(:server)
-      response = create_or_update_credential(server, params, create: !credential_exists)
+      account_id = ConfigFile.read_option(:account_id)
 
-      if successful?(response)
-        print_success_message('GHCR')
+      response = if credential_exists
+        update_credential(server, account_id, params, type)
       else
-        ResponseHelper.handle_failed_response(response)
+        create_credential(server, account_id, params)
       end
+
+      handle_result_for('GHCR', response)
     end
 
     map 'list-credentials' => 'list_credentials'
     map 'docker-hub' => 'docker_hub'
+    map 'docker-registry' => 'docker_registry'
 
     private
 
-    def successful?(response)
-      ResponseHelper.created?(response) || ResponseHelper.ok?(response)
+    def handle_result_for(credential_type, response)
+      if ResponseHelper.created?(response) || ResponseHelper.ok?(response)
+        print_success_message(credential_type)
+      else
+        ResponseHelper.handle_failed_response(response)
+      end
     end
 
     def prepare_registry_url(registry_url)
@@ -176,14 +222,21 @@ module Uffizzi
       "https://#{registry_url}"
     end
 
-    def print_success_message(credential_type_slug)
-      Uffizzi.ui.say("Successfully connected to #{credential_type_slug}.")
+    def print_success_message(credential_type)
+      Uffizzi.ui.say("Successfully connected to #{credential_type}.")
     end
 
     def credential_exists?(type)
       server = ConfigFile.read_option(:server)
-      response = check_credential(server, type)
-      !ResponseHelper.ok?(response)
+      account_id = ConfigFile.read_option(:account_id)
+      response = check_credential(server, account_id, type)
+      return false if ResponseHelper.ok?(response)
+      return true if ResponseHelper.unprocessable_entity?(response)
+
+      if ResponseHelper.forbidden?(response)
+        Uffizzi.ui.say('Unauthorized. Skipping credentials action.')
+        exit(true)
+      end
     end
 
     def handle_existing_credential_options(credential_type_slug)
@@ -202,10 +255,6 @@ module Uffizzi
       end
     end
 
-    def create_or_update_credential(server, params, create: true)
-      create ? create_credential(server, params) : update_credential(server, params, params[:type])
-    end
-
     def handle_list_credentials_success(response)
       credentials = response[:body][:credentials]
       credentials.each do |credential|

data/lib/uffizzi/cli/disconnect.rb

@@ -10,6 +10,8 @@ module Uffizzi
       connection_type = case credential_type
                         when 'docker-hub'
                           Uffizzi.configuration.credential_types[:dockerhub]
+                        when 'docker-registry'
+                          Uffizzi.configuration.credential_types[:docker_registry]
                         when 'acr'
                           Uffizzi.configuration.credential_types[:azure]
                         when 'ecr'
@@ -22,10 +24,10 @@ module Uffizzi
                           raise Uffizzi::Error.new('Unsupported credential type.')
       end
 
-      response = delete_credential(ConfigFile.read_option(:server), connection_type)
+      response = delete_credential(ConfigFile.read_option(:server), ConfigFile.read_option(:account_id), connection_type)
 
       if ResponseHelper.no_content?(response)
-        Uffizzi.ui.say("Successfully disconnected #{connection_name(credential_type)} connection")
+        Uffizzi.ui.say("Successfully disconnected from #{connection_name(credential_type)}.")
       else
         ResponseHelper.handle_failed_response(response)
       end
@@ -36,6 +38,7 @@ module Uffizzi
     def connection_name(credential_type)
       {
         'docker-hub' => 'DockerHub',
+        'docker-registry' => 'Docker Registry',
         'acr' => 'ACR',
         'ecr' => 'ECR',
         'gcr' => 'GCR',

data/lib/uffizzi/cli/login.rb

@@ -34,17 +34,17 @@ module Uffizzi
 
     def set_server
       config_server = ConfigFile.exists? ? read_option_from_config(:server) : nil
-      server_address = @options[:server] || config_server || Uffizzi.ui.ask('Server: ')
+      server_address = (@options[:server] || config_server || Uffizzi.ui.ask('Server:')).sub(/\/+$/, '')
       server_address.start_with?('http:', 'https:') ? server_address : "https://#{server_address}"
     end
 
     def set_username
       config_username = ConfigFile.exists? ? read_option_from_config(:username) : nil
-      @options[:username] || config_username || Uffizzi.ui.ask('Username: ')
+      @options[:username] || config_username || Uffizzi.ui.ask('Username:')
     end
 
     def set_password
-      ENV['UFFIZZI_PASSWORD'] || Uffizzi.ui.ask('Password: ', echo: false)
+      ENV['UFFIZZI_PASSWORD'] || Uffizzi.ui.ask('Password:', echo: false)
     end
 
     def read_option_from_config(option)
@@ -61,6 +61,7 @@ module Uffizzi
     end
 
     def handle_succeed_response(response, server, username)
+      # TODO Choose a personal account
       account = response[:body][:user][:accounts].first
       return Uffizzi.ui.say('No account related to this email') unless account_valid?(account)
 
@@ -95,9 +96,11 @@ module Uffizzi
       end
       all_choices = choices + [{ name: 'Create a new project', value: nil }]
       answer = Uffizzi.prompt.select(question, all_choices)
-      return ConfigFile.write_option(:project, answer) if answer
+      return create_new_project(server) unless answer
 
-      create_new_project(server)
+      account_id = projects.detect { |project| project[:slug] == answer }[:account_id]
+      ConfigFile.write_option(:project, answer)
+      ConfigFile.write_option(:account_id, account_id)
     end
 
     def create_new_project(server)
@@ -116,7 +119,8 @@ module Uffizzi
         },
       }
 
-      response = create_project(server, params)
+      account_id = ConfigFile.read_option(:account_id)
+      response = create_project(server, account_id, params)
 
       if ResponseHelper.created?(response)
         handle_create_project_succeess(response)
@@ -139,6 +143,7 @@ module Uffizzi
       project = response[:body][:project]
 
       ConfigFile.write_option(:project, project[:slug])
+      ConfigFile.write_option(:account_id, project[:account_id])
 
       Uffizzi.ui.say("Project #{project[:name]} was successfully created")
     end

data/lib/uffizzi/cli/login_by_identity_token.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'uffizzi'
+require 'uffizzi/response_helper'
+require 'uffizzi/clients/api/api_client'
+
+module Uffizzi
+  class Cli::LoginByIdentityToken
+    include ApiClient
+
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      token = @options[:token]
+      server = @options[:server]
+      params = prepare_request_params(token)
+      response = create_ci_session(server, params)
+
+      if ResponseHelper.created?(response)
+        handle_succeed_response(response, server)
+      else
+        ResponseHelper.handle_failed_response(response)
+      end
+    end
+
+    private
+
+    def prepare_request_params(token)
+      {
+        user: {
+          token: token,
+        },
+      }
+    end
+
+    def handle_succeed_response(response, server)
+      ConfigFile.write_option(:server, server)
+      ConfigFile.write_option(:cookie, response[:headers])
+      ConfigFile.write_option(:account_id, response[:body][:account_id])
+      ConfigFile.write_option(:project, response[:body][:project_slug])
+
+      Uffizzi.ui.say('Successful Login by Identity Token')
+    end
+  end
+end

data/lib/uffizzi/cli/preview.rb

@@ -12,19 +12,24 @@ module Uffizzi
     desc 'service', 'Show the preview services info'
     require_relative 'preview/service'
     subcommand 'service', Uffizzi::Cli::Preview::Service
+
     desc 'list', 'List all previews'
+    method_option :filter, required: false, type: :string, aliases: '-f'
+    method_option :output, required: false, type: :string, aliases: '-o', enum: ['json']
     def list
       run('list')
     end
 
     desc 'create [COMPOSE_FILE]', 'Create a preview'
     method_option :output, required: false, type: :string, aliases: '-o', enum: ['json', 'github-action']
+    method_option :"set-labels", required: false, type: :string, aliases: '-s'
     def create(file_path = nil)
       run('create', file_path: file_path)
     end
 
     desc 'uffizzi preview update [DEPLOYMENT_ID] [COMPOSE_FILE]', 'Update a preview'
     method_option :output, required: false, type: :string, aliases: '-o', enum: ['json', 'github-action']
+    method_option :"set-labels", required: false, type: :string, aliases: '-s'
     def update(deployment_name, file_path)
       run('update', deployment_name: deployment_name, file_path: file_path)
     end
@@ -47,10 +52,7 @@ module Uffizzi
     private
 
     def run(command, file_path: nil, deployment_name: nil)
-      unless options[:output].nil?
-        Uffizzi.ui.output_format = options[:output]
-        Uffizzi.ui.disable_stdout
-      end
+      Uffizzi.ui.output_format = options[:output]
       raise Uffizzi::Error.new('You are not logged in.') unless Uffizzi::AuthHelper.signed_in?
       raise Uffizzi::Error.new('This command needs project to be set in config file') unless CommandService.project_set?(options)
 
@@ -58,11 +60,11 @@ module Uffizzi
 
       case command
       when 'list'
-        handle_list_command(project_slug)
+        handle_list_command(project_slug, options[:filter])
       when 'create'
-        handle_create_command(file_path, project_slug)
+        handle_create_command(file_path, project_slug, options[:"set-labels"])
       when 'update'
-        handle_update_command(deployment_name, file_path, project_slug)
+        handle_update_command(deployment_name, file_path, project_slug, options[:"set-labels"])
       when 'delete'
         handle_delete_command(deployment_name, project_slug)
       when 'describe'
@@ -72,8 +74,9 @@ module Uffizzi
       end
     end
 
-    def handle_list_command(project_slug)
-      response = fetch_deployments(ConfigFile.read_option(:server), project_slug)
+    def handle_list_command(project_slug, filter)
+      parsed_filter = filter.nil? ? {} : build_filter_params(filter)
+      response = fetch_deployments(ConfigFile.read_option(:server), project_slug, parsed_filter)
 
       if ResponseHelper.ok?(response)
         handle_succeed_list_response(response)
@@ -82,8 +85,10 @@ module Uffizzi
       end
     end
 
-    def handle_create_command(file_path, project_slug)
-      params = file_path.nil? ? {} : prepare_params(file_path)
+    def handle_create_command(file_path, project_slug, labels)
+      Uffizzi.ui.disable_stdout unless options[:output].nil?
+      params = prepare_params(file_path, labels)
+
       response = create_deployment(ConfigFile.read_option(:server), project_slug, params)
 
       if !ResponseHelper.created?(response)
@@ -101,12 +106,13 @@ module Uffizzi
       handle_preview_interruption(deployment_id, ConfigFile.read_option(:server), project_slug)
     end
 
-    def handle_update_command(deployment_name, file_path, project_slug)
+    def handle_update_command(deployment_name, file_path, project_slug, labels)
+      Uffizzi.ui.disable_stdout unless options[:output].nil?
       deployment_id = PreviewService.read_deployment_id(deployment_name)
 
       raise Uffizzi::Error.new("Preview should be specified in 'deployment-PREVIEW_ID' format") if deployment_id.nil?
 
-      params = prepare_params(file_path)
+      params = prepare_params(file_path, labels)
       response = update_deployment(ConfigFile.read_option(:server), project_slug, deployment_id, params)
 
       if !ResponseHelper.ok?(response)
@@ -175,7 +181,11 @@ module Uffizzi
       raise Uffizzi::Error.new('The project has no active deployments') if deployments.empty?
 
       deployments.each do |deployment|
-        Uffizzi.ui.say("deployment-#{deployment[:id]}")
+        if Uffizzi.ui.output_format.nil?
+          Uffizzi.ui.say("deployment-#{deployment[:id]}")
+        else
+          Uffizzi.ui.pretty_say(deployment)
+        end
       end
     end
 
@@ -205,26 +215,10 @@ module Uffizzi
       end
     end
 
-    def prepare_params(file_path)
-      begin
-        compose_file_data = EnvVariablesService.substitute_env_variables(File.read(file_path))
-      rescue Errno::ENOENT => e
-        raise Uffizzi::Error.new(e.message)
-      end
-
-      compose_file_dir = File.dirname(file_path)
-      dependencies = ComposeFileService.parse(compose_file_data, compose_file_dir)
-      absolute_path = File.absolute_path(file_path)
-      compose_file_params = {
-        path: absolute_path,
-        content: Base64.encode64(compose_file_data),
-        source: absolute_path,
-      }
-
-      {
-        compose_file: compose_file_params,
-        dependencies: dependencies,
-      }
+    def prepare_params(file_path, labels)
+      compose_file_params = file_path.nil? ? {} : build_compose_file_params(file_path)
+      metadata_params = labels.nil? ? {} : build_metadata_params(labels)
+      compose_file_params.merge(metadata_params)
     end
 
     def handle_preview_interruption(deployment_id, server, project_slug)
@@ -251,10 +245,77 @@ module Uffizzi
     end
 
     def build_deployment_data(deployment)
+      url_server = ConfigFile.read_option(:server)
+
       {
         id: "deployment-#{deployment[:id]}",
         url: "https://#{deployment[:preview_url]}",
+        containers_uri: "#{url_server}/projects/#{deployment[:project_id]}/deployments/#{deployment[:id]}/containers",
       }
     end
+
+    def build_compose_file_params(file_path)
+      begin
+        compose_file_data = EnvVariablesService.substitute_env_variables(File.read(file_path))
+      rescue Errno::ENOENT => e
+        raise Uffizzi::Error.new(e.message)
+      end
+
+      compose_file_dir = File.dirname(file_path)
+      dependencies = ComposeFileService.parse(compose_file_data, compose_file_dir)
+      absolute_path = File.absolute_path(file_path)
+      compose_file_params = {
+        path: absolute_path,
+        content: Base64.encode64(compose_file_data),
+        source: absolute_path,
+      }
+
+      {
+        compose_file: compose_file_params,
+        dependencies: dependencies,
+      }
+    end
+
+    def build_metadata_params(labels)
+      {
+        metadata: {
+          'labels' => parse_params(labels, 'Labels'),
+        },
+      }
+    end
+
+    def build_filter_params(filter_params)
+      {
+        'labels' => parse_params(filter_params, 'Filtering parameters'),
+      }
+    end
+
+    def parse_params(params, params_type)
+      validate_params(params, params_type)
+      params.split(' ').reduce({}) do |acc, param|
+        stringified_keys, value = param.split('=', 2)
+        keys = stringified_keys.split('.', -1)
+        inner_pair = { keys.pop => value }
+        prepared_param = keys.reverse.reduce(inner_pair) { |res, key| { key => res } }
+        merge_params(acc, prepared_param)
+      end
+    end
+
+    def validate_params(params, params_type)
+      params.split(' ').each do |param|
+        stringified_keys, value = param.split('=', 2)
+        raise Uffizzi::Error.new("#{params_type} were set in incorrect format.") if value.nil? || stringified_keys.nil? || value.empty?
+
+        keys = stringified_keys.split('.', -1)
+        raise Uffizzi::Error.new("#{params_type} were set in incorrect format.") if keys.empty? || keys.any?(&:empty?)
+      end
+    end
+
+    def merge_params(result, param)
+      key = param.keys.first
+      return result.merge(param) unless result.has_key?(key)
+
+      { key => result[key].merge(merge_params(result[key], param[key])) }
+    end
   end
 end

data/lib/uffizzi/cli/project.rb

@@ -102,12 +102,13 @@ module Uffizzi
       raise Uffizzi::Error.new('Slug must not content spaces or special characters') unless slug.match?(/^[a-zA-Z0-9\-_]+\Z/i)
 
       server = ConfigFile.read_option(:server)
+      account_id = ConfigFile.read_option(:account_id)
       params = {
         name: name,
         description: options[:description],
         slug: slug,
       }
-      response = create_project(server, params)
+      response = create_project(server, account_id, params)
 
       if ResponseHelper.created?(response)
         handle_create_success_response(response)
@@ -165,6 +166,7 @@ module Uffizzi
 
     def set_default_project(project)
       ConfigFile.write_option(:project, project[:slug])
+      ConfigFile.write_option(:account_id, project[:account_id])
     end
   end
 end