uffizzi-cli 1.0.4 → 2.0.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5aa0242e35791e35a51a850316bb18a97f1651aa345c64ee05264cb6b7faa702
-  data.tar.gz: bc9a8c8176c2969edf8728be715a0d45c38dab6a3d0e6da37c8022e04d9e8e24
+  metadata.gz: ff745e60f88baf8b836d5e230df85de2db8956879c1f3e241cf43196ffe499e3
+  data.tar.gz: 5ee75e82560d8a08442ae8d14fda0cb9dabf94d5e4f9c5771a6f238976b74939
 SHA512:
-  metadata.gz: 993d29e07d6fe739cd3ab82383a948ed2d251f7b00662b02b87cd3a9b1b556ee2e1ed16f224f857ce0689ac64b84d02b74aa711f24f477d546d1f13c378938a1
-  data.tar.gz: d91befdb081561d8395800f672918518397a70734abc3ff1ec2b57faa0180063f808722afc14de85e056507972d97eb4ef774614d1dd72a54311f5f34629abf0
+  metadata.gz: 3a4b98fe851951079f4a106c4a34371ede1c9bc823375615edde4922f6e7a3712402c395f8f7e00fea588f51a1143c4c2b2058199475dac35808c1bcb2bc81cb
+  data.tar.gz: 9942d4da8f4e47060dd3e5f1c65810dfe972cbd05ccaca7750612f61e304aea1de8b587405e60f1210487a45a531fcfd52065b5d677089eea01a207dd4ba76a5

data/config/uffizzi.rb

@@ -22,5 +22,6 @@ module Uffizzi
       docker_registry: 'UffizziCore::Credential::DockerRegistry',
     }
     config.default_server = 'app.uffizzi.com'
+    config.default_kubeconfig_path = ENV['CLI_DEFAULT_KUBECONFIG_PATH'] || '~/.kube/config'
   end
 end

data/lib/uffizzi/auth_helper.rb

@@ -4,15 +4,23 @@ module Uffizzi
   module AuthHelper
     class << self
       def signed_in?
-        ConfigFile.exists? &&
-          ConfigFile.option_has_value?(:account_id) &&
-          ConfigFile.option_has_value?(:cookie) &&
-          ConfigFile.option_has_value?(:server)
+        config_data_exists? || Uffizzi::Token.exists?
       end
 
       def sign_out
         Uffizzi::ConfigFile.unset_option(:cookie)
-        Uffizzi::ConfigFile.unset_option(:account_id)
+        Uffizzi::ConfigFile.unset_option(:account)
+        Uffizzi::ConfigFile.unset_option(:project)
+        Uffizzi::Token.delete if Uffizzi::Token.exists?
+      end
+
+      private
+
+      def config_data_exists?
+        ConfigFile.exists? &&
+          ConfigFile.option_has_value?(:account) &&
+          ConfigFile.option_has_value?(:cookie) &&
+          ConfigFile.option_has_value?(:server)
       end
     end
   end

data/lib/uffizzi/cli/account.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'uffizzi'
+require 'uffizzi/auth_helper'
+require 'uffizzi/response_helper'
+require 'uffizzi/helpers/config_helper'
+
+module Uffizzi
+  class Cli::Account < Thor
+    include ApiClient
+
+    desc 'list', "List all user's accounts"
+    def list
+      run('list')
+    end
+
+    desc 'set-default ACCOUNT_NAME', 'set-default'
+    def set_default(account_name)
+      run('set-default', account_name)
+    end
+
+    map('set-default' => :set_default)
+    map('set' => :set_default)
+
+    private
+
+    def run(command, account_name = nil)
+      return Uffizzi.ui.say('You are not logged in.') unless Uffizzi::AuthHelper.signed_in?
+
+      case command
+      when 'list'
+        handle_list_command
+      when 'set-default'
+        handle_set_default_command(account_name)
+      end
+    end
+
+    def handle_list_command
+      server = ConfigFile.read_option(:server)
+      response = fetch_accounts(server)
+
+      if ResponseHelper.ok?(response)
+        handle_list_success_response(response)
+      else
+        ResponseHelper.handle_failed_response(response)
+      end
+    end
+
+    def handle_set_default_command(account_name)
+      response = fetch_account(ConfigFile.read_option(:server), account_name)
+
+      if ResponseHelper.ok?(response)
+        handle_succeed_set_default_response(response)
+      elsif ResponseHelper.not_found?(response)
+        Uffizzi.ui.say("Account with name #{account_name} does not exist")
+      else
+        ResponseHelper.handle_failed_response(response)
+      end
+    end
+
+    def handle_list_success_response(response)
+      accounts = response[:body][:accounts]
+      return Uffizzi.ui.say('No accounts found') if accounts.empty?
+
+      print_accounts(accounts)
+    end
+
+    def print_accounts(accounts)
+      accounts_list = accounts.reduce('') do |acc, account|
+        "#{acc}#{account[:name]}\n"
+      end
+      Uffizzi.ui.say(accounts_list)
+    end
+
+    def handle_succeed_set_default_response(response)
+      account = response[:body][:account]
+      account_id = account[:id]
+      account_name = account[:name]
+      ConfigFile.write_option(:account, Uffizzi::ConfigHelper.account_config(account_id, account_name))
+      Uffizzi.ui.say("The account with name '#{account_name}' was set as default.")
+
+      projects = account[:projects]
+
+      project = default_project(projects, account_id)
+      if project.nil?
+        ConfigFile.unset_option(:project)
+        message = "There is no project set. Run the 'uffizzi project set-default' command to set a project"
+        return Uffizzi.ui.say(message)
+      end
+
+      slug = project[:slug]
+      ConfigFile.write_option(:project, slug)
+      Uffizzi.ui.say("The project with slug '#{slug}' was set as default.")
+    end
+
+    def default_project(projects, account_id)
+      return projects.first if projects.count == 1
+      return create_default_project(account_id) if projects.count.zero?
+
+      nil
+    end
+
+    def create_default_project(account_id)
+      params = Uffizzi::ProjectHelper.generate_default_params
+      response = create_project(ConfigFile.read_option(:server), account_id, params)
+
+      if ResponseHelper.created?(response)
+        handle_project_create_success_response(response)
+      else
+        ResponseHelper.handle_failed_response(response)
+      end
+    end
+
+    def handle_project_create_success_response(response)
+      project = response[:body][:project]
+      ConfigFile.write_option(:project, project[:slug])
+      Uffizzi.ui.say("A default project '#{project[:name]}' was successfully created")
+
+      project
+    end
+  end
+end

data/lib/uffizzi/cli/cluster.rb

@@ -0,0 +1,363 @@
+# frozen_string_literal: true
+
+require 'psych'
+require 'faker'
+require 'uffizzi'
+require 'uffizzi/auth_helper'
+require 'uffizzi/helpers/config_helper'
+require 'uffizzi/services/preview_service'
+require 'uffizzi/services/command_service'
+require 'uffizzi/services/cluster_service'
+require 'uffizzi/services/kubeconfig_service'
+
+MANUAL = 'manual'
+
+module Uffizzi
+  class Cli::Cluster < Thor
+    class Error < StandardError; end
+    include ApiClient
+
+    desc 'list', 'List all clusters'
+    method_option :all, required: false, type: :boolean, aliases: '-a'
+    method_option :output, required: false, type: :string, aliases: '-o', enum: ['json', 'pretty-json']
+    def list
+      run('list')
+    end
+
+    desc 'create', 'Create a cluster'
+    method_option :name, type: :string, required: false, aliases: '-n'
+    method_option :kubeconfig, type: :string, required: false, aliases: '-k'
+    method_option :manifest, type: :string, required: false, aliases: '-m'
+    method_option :'update-current-context', type: :boolean, required: false
+    method_option :output, required: false, type: :string, aliases: '-o', enum: ['json', 'pretty-json']
+    method_option :'creation-source', required: false, type: :string
+    def create
+      run('create')
+    end
+
+    desc 'describe [NAME]', 'Describe a cluster'
+    method_option :output, required: false, type: :string, aliases: '-o', enum: ['json', 'pretty-json']
+    def describe(name)
+      run('describe', cluster_name: name)
+    end
+
+    desc 'delete [NAME]', 'Delete a cluster'
+    method_option :'delete-config', required: false, type: :boolean, aliases: '-dc'
+    def delete(name)
+      run('delete', cluster_name: name)
+    end
+
+    method_option :kubeconfig, type: :string, required: false, aliases: '-k'
+    method_option :print, type: :boolean, required: false, aliases: '-p'
+    method_option :quiet, type: :boolean, required: false, aliases: '-q'
+    desc 'update-kubeconfig', 'Udpate your kubeconfig'
+    def update_kubeconfig(name)
+      run('update-kubeconfig', cluster_name: name)
+    end
+
+    private
+
+    def run(command, command_args = {})
+      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)
+
+      project_slug = options[:project].nil? ? ConfigFile.read_option(:project) : options[:project]
+
+      case command
+      when 'list'
+        handle_list_command(project_slug)
+      when 'create'
+        handle_create_command(project_slug)
+      when 'describe'
+        handle_describe_command(project_slug, command_args)
+      when 'delete'
+        handle_delete_command(project_slug, command_args)
+      when 'update-kubeconfig'
+        handle_update_kubeconfig_command(project_slug, command_args)
+      end
+    end
+
+    def handle_list_command(project_slug)
+      is_all = options[:all]
+      response = if is_all
+        get_account_clusters(ConfigFile.read_option(:server), ConfigFile.read_option(:account, :id))
+      else
+        oidc_token = ConfigFile.read_option(:oidc_token)
+        get_project_clusters(ConfigFile.read_option(:server), project_slug, oidc_token: oidc_token)
+      end
+
+      if ResponseHelper.ok?(response)
+        handle_succeed_list_response(response)
+      else
+        ResponseHelper.handle_failed_response(response)
+      end
+    end
+
+    def handle_create_command(project_slug)
+      Uffizzi.ui.disable_stdout if Uffizzi.ui.output_format
+      cluster_name = options[:name] || ClusterService.generate_name
+      creation_source = options[:"creation-source"] || MANUAL
+
+      unless ClusterService.valid_name?(cluster_name)
+        Uffizzi.ui.say_error_and_exit("Cluster name: #{cluster_name} is not valid.")
+      end
+
+      manifest_file_path = options[:manifest]
+      params = cluster_creation_params(cluster_name, creation_source, manifest_file_path)
+      response = create_cluster(ConfigFile.read_option(:server), project_slug, params)
+
+      return ResponseHelper.handle_failed_response(response) unless ResponseHelper.created?(response)
+
+      spinner = TTY::Spinner.new("[:spinner] Creating cluster #{cluster_name}...", format: :dots)
+      spinner.auto_spin
+      cluster_data = ClusterService.wait_cluster_deploy(project_slug, cluster_name, ConfigFile.read_option(:oidc_token))
+
+      if ClusterService.failed?(cluster_data[:state])
+        spinner.error
+        Uffizzi.ui.say_error_and_exit("Cluster with name: #{cluster_name} failed to be created.")
+      end
+
+      spinner.success
+      handle_succeed_create_response(cluster_data)
+    rescue SystemExit, Interrupt, SocketError
+      handle_interrupt_creation(cluster_name, ConfigFile.read_option(:server), project_slug)
+    end
+
+    def handle_describe_command(project_slug, command_args)
+      cluster_data = fetch_cluster_data(project_slug, command_args[:cluster_name])
+
+      handle_succeed_describe(cluster_data)
+    end
+
+    def handle_delete_command(project_slug, command_args)
+      cluster_name = command_args[:cluster_name]
+      is_delete_kubeconfig = options[:'delete-config']
+
+      return handle_delete_cluster(project_slug, cluster_name) unless is_delete_kubeconfig
+
+      cluster_data = fetch_cluster_data(project_slug, cluster_name)
+      kubeconfig = parse_kubeconfig(cluster_data[:kubeconfig])
+
+      handle_delete_cluster(project_slug, cluster_name)
+      exclude_kubeconfig(cluster_data[:id], kubeconfig)
+    end
+
+    def exclude_kubeconfig(cluster_id, kubeconfig)
+      cluster_config = Uffizzi::ConfigHelper.cluster_config_by_id(cluster_id)
+      return if cluster_config.nil?
+
+      kubeconfig_path = cluster_config[:kubeconfig_path]
+      ConfigFile.write_option(:clusters, Uffizzi::ConfigHelper.clusters_config_without(cluster_id))
+
+      KubeconfigService.save_to_filepath(kubeconfig_path, kubeconfig) do |kubeconfig_by_path|
+        if kubeconfig_by_path.nil?
+          msg = "Warning: kubeconfig at path #{kubeconfig_path} does not exist"
+          return Uffizzi.ui.say(msg)
+        end
+
+        new_kubeconfig = KubeconfigService.exclude(kubeconfig_by_path, kubeconfig)
+        first_context = KubeconfigService.get_first_context(new_kubeconfig)
+        new_current_context = first_context.present? ? first_context['name'] : nil
+        KubeconfigService.update_current_context(new_kubeconfig, new_current_context)
+      end
+    end
+
+    def handle_delete_cluster(project_slug, cluster_name)
+      params = {
+        cluster_name: cluster_name,
+        oidc_token: ConfigFile.read_option(:oidc_token),
+      }
+      response = delete_cluster(ConfigFile.read_option(:server), project_slug, params)
+
+      if ResponseHelper.no_content?(response)
+        Uffizzi.ui.say("Cluster #{cluster_name} deleted")
+      else
+        ResponseHelper.handle_failed_response(response)
+      end
+    end
+
+    def handle_update_kubeconfig_command(project_slug, command_args)
+      kubeconfig_path = options[:kubeconfig] || KubeconfigService.default_path
+      cluster_data = fetch_cluster_data(project_slug, command_args[:cluster_name])
+
+      unless cluster_data[:kubeconfig].present?
+        say_error_update_kubeconfig(cluster_data)
+      end
+
+      parsed_kubeconfig = parse_kubeconfig(cluster_data[:kubeconfig])
+
+      return Uffizzi.ui.say(parsed_kubeconfig.to_yaml) if options[:print]
+
+      KubeconfigService.save_to_filepath(kubeconfig_path, parsed_kubeconfig) do |kubeconfig_by_path|
+        merged_kubeconfig = KubeconfigService.merge(kubeconfig_by_path, parsed_kubeconfig)
+        current_context = KubeconfigService.get_current_context(parsed_kubeconfig)
+        KubeconfigService.update_current_context(merged_kubeconfig, current_context)
+      end
+
+      update_clusters_config(cluster_data[:id], kubeconfig_path: kubeconfig_path)
+
+      return if options[:quiet]
+
+      Uffizzi.ui.say("Kubeconfig was updated by the path: #{kubeconfig_path}")
+    end
+
+    def say_error_update_kubeconfig(cluster_data)
+      if ClusterService.failed?(cluster_data[:state])
+        Uffizzi.ui.say_error_and_exit('Kubeconfig is empty because cluster failed to be created.')
+      end
+
+      if ClusterService.deploying?(cluster_data[:state])
+        Uffizzi.ui.say_error_and_exit('Kubeconfig is empty because cluster is deploying.')
+      end
+
+      if ClusterService.deployed?(cluster_data[:state])
+        raise Error.new("Cluster with data: #{cluster_data.to_json} is deployed but kubeconfig does not exist.")
+      end
+    end
+
+    def cluster_creation_params(name, creation_source, manifest_file_path)
+      manifest_content = load_manifest_file(manifest_file_path)
+      oidc_token = Uffizzi::ConfigFile.read_option(:oidc_token)
+
+      {
+        cluster: {
+          name: name,
+          manifest: manifest_content,
+          creation_source: creation_source,
+        },
+        token: oidc_token,
+      }
+    end
+
+    def load_manifest_file(file_path)
+      return nil if file_path.nil?
+
+      File.read(file_path)
+    rescue Errno::ENOENT => e
+      raise Uffizzi::Error.new(e.message)
+    end
+
+    def handle_interrupt_creation(cluster_name, server, project_slug)
+      deletion_response = delete_cluster(server, project_slug, cluster_name: cluster_name)
+      deletion_message = if ResponseHelper.no_content?(deletion_response)
+        "The cluster #{cluster_name} has been disabled."
+      else
+        "Couldn't disable the cluster #{cluster_name} - please disable manually."
+      end
+
+      raise Uffizzi::Error.new("The cluster creation was interrupted. #{deletion_message}")
+    end
+
+    def handle_succeed_list_response(response)
+      clusters = response[:body][:clusters] || []
+      raise Uffizzi::Error.new('The project has no active clusters') if clusters.empty?
+
+      clusters_data = if Uffizzi.ui.output_format.nil?
+        render_plain_cluster_list(clusters)
+      else
+        clusters.map { |c| c.slice(:name, :project) }
+      end
+
+      Uffizzi.ui.say(clusters_data)
+    end
+
+    def render_plain_cluster_list(clusters)
+      clusters.map do |cluster|
+        project_name = cluster.dig(:project, :name)
+
+        if project_name.present?
+          "- Cluster name: #{cluster[:name].strip} Project name: #{project_name.strip}"
+        else
+          "- #{cluster[:name]}"
+        end
+      end.join("\n")
+    end
+
+    def handle_succeed_describe(cluster_data)
+      prepared_cluster_data = {
+        name: cluster_data[:name],
+        status: cluster_data[:state],
+        created: Time.strptime(cluster_data[:created_at], '%Y-%m-%dT%H:%M:%S.%N').strftime('%a %b %d %H:%M:%S %Y'),
+        url: cluster_data[:host],
+      }
+
+      rendered_cluster_data = if Uffizzi.ui.output_format.nil?
+        prepared_cluster_data.map { |k, v| "- #{k.to_s.upcase}: #{v}" }.join("\n").strip
+      else
+        prepared_cluster_data
+      end
+
+      Uffizzi.ui.say(rendered_cluster_data)
+    end
+
+    def handle_succeed_create_response(cluster_data)
+      kubeconfig_path = options[:kubeconfig]
+      is_update_current_context = options[:'update-current-context']
+      parsed_kubeconfig = parse_kubeconfig(cluster_data[:kubeconfig])
+      rendered_cluster_data = render_cluster_data(cluster_data)
+
+      Uffizzi.ui.enable_stdout
+      Uffizzi.ui.say("Cluster with name: #{rendered_cluster_data[:name]} was created.")
+
+      unless is_update_current_context
+        Uffizzi.ui.say("To update the current context, run:\nuffizzi cluster update-kubeconfig #{cluster_data[:name]}")
+      end
+
+      Uffizzi.ui.say(rendered_cluster_data) if Uffizzi.ui.output_format
+
+      save_kubeconfig(parsed_kubeconfig, kubeconfig_path)
+      update_clusters_config(cluster_data[:id], kubeconfig_path: kubeconfig_path)
+      GithubService.write_to_github_env(rendered_cluster_data) if GithubService.github_actions_exists?
+    end
+
+    def save_kubeconfig(kubeconfig, kubeconfig_path)
+      kubeconfig_path = kubeconfig_path.nil? ? KubeconfigService.default_path : kubeconfig_path
+      is_update_current_context = options[:'update-current-context']
+
+      KubeconfigService.save_to_filepath(kubeconfig_path, kubeconfig) do |kubeconfig_by_path|
+        merged_kubeconfig = KubeconfigService.merge(kubeconfig_by_path, kubeconfig)
+
+        if is_update_current_context
+          current_context = KubeconfigService.get_current_context(kubeconfig)
+          KubeconfigService.update_current_context(merged_kubeconfig, current_context)
+        else
+          merged_kubeconfig
+        end
+      end
+    end
+
+    def update_clusters_config(id, params)
+      clusters_config = Uffizzi::ConfigHelper.update_clusters_config_by_id(id, params)
+      ConfigFile.write_option(:clusters, clusters_config)
+    end
+
+    def render_cluster_data(cluster_data)
+      kubeconfig = parse_kubeconfig(cluster_data[:kubeconfig])
+      raise Uffizzi::Error.new('The kubeconfig data is empty') unless kubeconfig
+
+      new_cluster_data = cluster_data.slice(:name)
+      new_cluster_data[:context_name] = kubeconfig['current-context']
+
+      new_cluster_data
+    end
+
+    def parse_kubeconfig(kubeconfig)
+      Psych.safe_load(Base64.decode64(kubeconfig))
+    end
+
+    def fetch_cluster_data(project_slug, cluster_name)
+      params = {
+        cluster_name: cluster_name,
+        oidc_token: ConfigFile.read_option(:oidc_token),
+      }
+      response = get_cluster(ConfigFile.read_option(:server), project_slug, params)
+
+      if ResponseHelper.ok?(response)
+        response.dig(:body, :cluster)
+      else
+        ResponseHelper.handle_failed_response(response)
+      end
+    end
+  end
+end

data/lib/uffizzi/cli/common.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
-require 'open3'
-
 module Uffizzi
   class Cli::Common
     class << self
       def show_manual(command_name)
-        manual_doc_path = File.join(Uffizzi.root, "man/#{command_name}")
+        manual_doc_path = File.join(Uffizzi.root, "man/#{command_name}.ronn")
 
-        Open3.pipeline("man #{manual_doc_path}")
+        Uffizzi.ui.say(File.read(manual_doc_path))
       end
     end
   end

data/lib/uffizzi/cli/config.rb

@@ -5,6 +5,7 @@ require 'uffizzi/clients/api/api_client'
 
 module Uffizzi
   class Cli::Config < Thor
+    ACCOUNT_PROPERTY = 'account'
     include ApiClient
 
     desc 'list', 'Lists all options and their values from the config file'
@@ -57,12 +58,10 @@ module Uffizzi
       Uffizzi.ui.say("Configure the default properties that will be used to authenticate with your \
                       \nUffizzi API service and manage previews.\n")
       server = Uffizzi.ui.ask('Server: ', default: Uffizzi.configuration.default_server.to_s)
-      username = Uffizzi.ui.ask('Username: ')
-      project = Uffizzi.ui.ask('Project: ', default: 'default')
+
       ConfigFile.delete
       ConfigFile.write_option(:server, server)
-      ConfigFile.write_option(:username, username)
-      ConfigFile.write_option(:project, project)
+
       Uffizzi.ui.say('To login, run: uffizzi login')
     end
 
@@ -78,6 +77,8 @@ module Uffizzi
     end
 
     def handle_set_command(property, value)
+      return handle_set_account(value) if property == ACCOUNT_PROPERTY
+
       ConfigFile.write_option(property.to_sym, value)
       Uffizzi.ui.say("Updated property [#{property}]")
     end

data/lib/uffizzi/cli/connect.rb

@@ -10,7 +10,7 @@ module Uffizzi
     desc 'list-credentials', 'List existing credentials for an account'
     def list_credentials
       server = ConfigFile.read_option(:server)
-      account_id = ConfigFile.read_option(:account_id)
+      account_id = ConfigFile.read_option(:account, :id)
       response = fetch_credentials(server, account_id)
       if ResponseHelper.ok?(response)
         handle_list_credentials_success(response)
@@ -36,9 +36,10 @@ module Uffizzi
         username: username,
         password: password,
         type: type,
+        token: ConfigFile.read_option(:oidc_token),
       }
       server = ConfigFile.read_option(:server)
-      account_id = ConfigFile.read_option(:account_id)
+      account_id = ConfigFile.read_option(:account, :id)
 
       response = if credential_exists
         update_credential(server, account_id, params, type)
@@ -68,9 +69,10 @@ module Uffizzi
         username: username,
         password: password,
         type: type,
+        token: ConfigFile.read_option(:oidc_token),
       }
       server = ConfigFile.read_option(:server)
-      account_id = ConfigFile.read_option(:account_id)
+      account_id = ConfigFile.read_option(:account, :id)
 
       response = if credential_exists
         update_credential(server, account_id, params, type)
@@ -100,9 +102,10 @@ module Uffizzi
         password: password,
         registry_url: prepare_registry_url(registry_url),
         type: type,
+        token: ConfigFile.read_option(:oidc_token),
       }
       server = ConfigFile.read_option(:server)
-      account_id = ConfigFile.read_option(:account_id)
+      account_id = ConfigFile.read_option(:account, :id)
 
       response = if credential_exists
         update_credential(server, account_id, params, type)
@@ -132,9 +135,10 @@ module Uffizzi
         password: secret_access_key,
         registry_url: prepare_registry_url(registry_url),
         type: type,
+        token: ConfigFile.read_option(:oidc_token),
       }
       server = ConfigFile.read_option(:server)
-      account_id = ConfigFile.read_option(:account_id)
+      account_id = ConfigFile.read_option(:account, :id)
 
       response = if credential_exists
         update_credential(server, account_id, params, type)
@@ -159,9 +163,10 @@ module Uffizzi
       params = {
         password: credential_content,
         type: type,
+        token: ConfigFile.read_option(:oidc_token),
       }
       server = ConfigFile.read_option(:server)
-      account_id = ConfigFile.read_option(:account_id)
+      account_id = ConfigFile.read_option(:account, :id)
 
       response = if credential_exists
         update_credential(server, account_id, params, type)
@@ -189,9 +194,10 @@ module Uffizzi
         username: username,
         password: password,
         type: type,
+        token: ConfigFile.read_option(:oidc_token),
       }
       server = ConfigFile.read_option(:server)
-      account_id = ConfigFile.read_option(:account_id)
+      account_id = ConfigFile.read_option(:account, :id)
 
       response = if credential_exists
         update_credential(server, account_id, params, type)
@@ -228,7 +234,7 @@ module Uffizzi
 
     def credential_exists?(type)
       server = ConfigFile.read_option(:server)
-      account_id = ConfigFile.read_option(:account_id)
+      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)

data/lib/uffizzi/cli/disconnect.rb

@@ -24,7 +24,7 @@ module Uffizzi
                           raise Uffizzi::Error.new('Unsupported credential type.')
       end
 
-      response = delete_credential(ConfigFile.read_option(:server), ConfigFile.read_option(:account_id), 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 from #{connection_name(credential_type)}.")