local class="$1"

local message="$2"

local extra="${3:-}" # Used for default value, icon, or other extras

local response

case "$class" in

"header") echo "${bd}${mg}$message${nc}" ;;

"success") echo "${gr}$message${extra:+ $extra}${nc}" ;;

"warning") echo "${yl}$message${extra:+ $extra}${nc}" ;;

"error") echo "${rd}$message${extra:+ $extra}${nc}" ;;

"info") echo "${wh}$message${nc}" ;;

"help") echo "${gy}$message${nc}" ;;

"example") echo "${gy}${it}$message${nc}" ;;

"code") echo "${bl}$message${nc}" ;;

"highlight") echo "${or}$message${nc}" ;;

"section") echo "${cy}$message${nc}" ;;

"status") echo "${gy}$message${extra:+ $extra}${nc}" ;;

# Interactive prompts

"question")

local default="${extra:-}"

local prompt

# Format based on default value

if [[ ${default,,} == "n" ]]; then

prompt="${mg}$message ${bl}[${gr}y${bl}/${rd}N${bl}]${nc}"

elif [[ ${default,,} == "y" ]]; then

prompt="${mg}$message ${bl}[${gr}Y${bl}/${rd}n${bl}]${nc}"

else

prompt="${mg}$message ${bl}[${gr}y${bl}/${rd}n${bl}]${nc}"

fi

while true; do

echo -n "$prompt: "

read -r response

# Handle empty response

if [[ -z $response ]]; then

[[ -n $default ]] && response="$default" && break

continue

fi

# Handle valid responses

if [[ ${response,,} =~ ^[yn]$ ]]; then

break

fi

echo -e "${rd}Please answer y or n${nc}"

done

[[ ${response,,} =~ ^y ]]

return $?

;;

"input")

printf "${mg}%s${nc}: " "$message" >&2

read -r response

echo "$response"

;;

"input_default")

printf "${mg}%s ${bl}[${wh}%s${bl}]${nc}: " "$message" "$extra" >&2

read -r response

echo "${response:-$extra}"

;;

"select")

local -a options=("${@:3}") # Get all args after class and message

# Display the menu to stderr

for i in "${!options[@]}"; do

printf '%s%d%s %s%s\n' "${bl}" "$((i + 1))" "${gy})" "${wh}${options[$i]}" "${nc}" >&2

done

# Get selection

printf '%s%s%s: ' "${mg}" "$message" "${nc}" >&2

read -r selection

# Validate and return selection

if [[ $selection =~ ^[0-9]+$ ]] && [ "$selection" -ge 1 ] && [ "$selection" -le "${#options[@]}" ]; then

echo "${options[$((selection - 1))]}"

return 0

else

printf '%s%s%s\n' "${rd}" "Invalid selection." "${nc}" >&2

msg "select" "$message" "${options[@]}"

fi

;;

*) echo "$message" ;;

esac

# First check if ~/.config exists

if [[ -d "${HOME}/.config" ]]; then

echo "${HOME}/.config/awsctx"

else

# Fall back to ~/.awsctxrc

echo "${HOME}"

fi

local config_dir

config_dir=$(get_config_dir)

if [[ $config_dir == "${HOME}" ]]; then

echo "${HOME}/.awsctxrc"

else

echo "${config_dir}/awsctxrc"

fi

local config_file

config_file=$(get_config_file)

local config_dir

config_dir=$(dirname "$config_file")

if [[ ! -f $config_file ]]; then

error "AWS Context configuration file not found at: $config_file"

info "Would you like to create a new configuration file?"

if ask "Create config file?"; then

create_config "$config_file"

else

error "Configuration file is required to run awsctx. Exiting..." "😢"

exit 1

fi

fi

# Check if config file is readable

if [[ ! -r $config_file ]]; then

error "Config file exists but is not readable: $config_file" "😢"

exit 1

fi

# Source the config file

if [[ -f $config_file ]]; then

# shellcheck source=/dev/null

source "$config_file"

else

error "Failed to load config file: $config_file" "😢"

exit 1

fi

# Validate required variables

if [[ -z ${SSO_START_URL:-} ]] || [[ -z ${SSO_REGION:-} ]] ||

[[ -z ${SSO_REGISTRATION_SCOPES:-} ]] || [[ -z ${CROSS_ACCOUNT_PROFILE:-} ]] ||

[[ -z ${OUTPUT_FORMAT:-} ]]; then

error "Config file is missing required variables" "😕"

warn "Please ensure all required variables are set in: $config_file"

info "Would you like to update the configuration file?"

if ask "Update config file?"; then

create_config "$config_file"

else

error "Configuration file is required to run awsctx. Exiting..." "😢"

exit 1

fi

fi

# Basic format check for region (just to catch obvious typos)

if [[ ! $SSO_REGION =~ ^[a-z]{2}-[a-z]+-[0-9]{1}$ ]]; then

error "Invalid AWS region format in config file: $SSO_REGION" "⚠️"

info "Region should be in the format: us-east-1, eu-west-2, etc."

exit 1

fi

local config_file="$1"

local config_dir

config_dir=$(dirname "$config_file")

info "Creating AWS Context configuration file..."

info "This will help you set up your AWS SSO configuration."

info "You can get these values from your AWS IAM administrator."

echo

# Create config directory if it doesn't exist

if [[ $config_dir != "${HOME}" ]]; then

mkdir -p "$config_dir"

fi

# Prompt for SSO Directory ID

while true; do

code "AWS SSO Directory ID"

info "This is your AWS SSO directory ID"

code "Format: d-xxxxxxxx"

example "Example: d-a1b2c3d4e5"

info "You can find this in your AWS SSO console under 'Directory ID'"

if [[ -n ${SSO_START_URL:-} ]]; then

# Extract just the directory ID from the full URL if needed

local default_id

if [[ $SSO_START_URL =~ ^https:// ]]; then

default_id=$(echo "$SSO_START_URL" | sed -E 's|https://([^.]+)\.awsapps\.com/start|\1|')

else

default_id="$SSO_START_URL"

fi

input=$(prompt_default "Enter Directory ID" "$default_id")

SSO_START_URL=${input}

else

SSO_START_URL=$(prompt "Enter Directory ID")

fi

echo

if [[ $SSO_START_URL =~ ^[a-zA-Z0-9-]+$ ]]; then

# Construct the full SSO start URL

SSO_START_URL="https://${SSO_START_URL}.awsapps.com/start"

break

else

error "Invalid format. Please enter only alphanumeric characters and hyphens"

fi

done

# Prompt for SSO_REGION

while true; do

code "AWS Region"

info "This is the AWS region where your SSO is configured"

highlight "Example: us-east-1"

if [[ -n ${SSO_REGION:-} ]]; then

input=$(prompt_default "Enter AWS Region" "$SSO_REGION")

SSO_REGION=${input}

else

SSO_REGION=$(prompt "Enter AWS Region")

fi

echo

if [[ $SSO_REGION =~ ^[a-z]{2}-[a-z]+-[0-9]{1}$ ]]; then

break

else

error "Invalid region format. Please enter a region in the format: us-east-1, eu-west-2, etc."

fi

done

# Prompt for SSO_REGISTRATION_SCOPES

code "SSO Registration Scopes"

info "This is the SSO permission scope for your AWS account"

highlight "Example: sso:account:access"

if [[ -n ${SSO_REGISTRATION_SCOPES:-} ]]; then

input=$(prompt_default "Enter SSO Registration Scopes" "$SSO_REGISTRATION_SCOPES")

SSO_REGISTRATION_SCOPES=${input}

else

SSO_REGISTRATION_SCOPES=$(prompt "Enter SSO Registration Scopes")

fi

echo

# Prompt for CROSS_ACCOUNT_PROFILE

code "Cross Account Profile"

info "This is the name of the AWS profile that will be used to assume roles in other accounts"

highlight "Example: cross-account-access"

if [[ -n ${CROSS_ACCOUNT_PROFILE:-} ]]; then

input=$(prompt_default "Enter Cross Account Profile name" "$CROSS_ACCOUNT_PROFILE")

CROSS_ACCOUNT_PROFILE=${input}

else

CROSS_ACCOUNT_PROFILE=$(prompt "Enter Cross Account Profile name")

fi

echo

# Prompt for OUTPUT_FORMAT

code "AWS CLI Output Format"

info "This is the default output format for AWS CLI commands"

highlight "Example: json, text, table, yaml, yaml-stream"

# Define options for output format selection

local output_options=(

"json"

"text"

"table"

"yaml"

"yaml-stream"

)

# Use fzf to get user's choice

local selected_format

selected_format=$(select_option "Select output format" "${output_options[@]}")

if [[ -n $selected_format ]]; then

OUTPUT_FORMAT="$selected_format"

else

error "No output format selected. Using default: json" "⚠️"

OUTPUT_FORMAT="json"

fi

success "Output format selected: $OUTPUT_FORMAT" "✅"

# Ask about CLI pager preference

if ask "Would you like to set a CLI pager for AWS output?"; then

info "Common pager options:"

# Define options for pager selection

local pager_options=(

"bat -Ppl yaml (Syntax highlighted output - requires bat)"

"less (Standard pager)"

"more (Simple pager)"

"custom (Enter your own pager command)"

)

# Use fzf to get user's choice

local selected_pager

selected_pager=$(select_option "Select pager" "${pager_options[@]}")

case "$selected_pager" in

"bat -Ppl yaml (Syntax highlighted output - requires bat)")

# Check if bat is installed

if ! command -v bat &>/dev/null; then

error "bat is not installed. Please install bat to use this option." "⚠️"

info "https://github.com/sharkdp/bat#installation"

CLI_PAGER=""

else

CLI_PAGER="bat -Ppl yaml"

fi

;;

"less (Standard pager)")

CLI_PAGER="less"

;;

"more (Simple pager)")

CLI_PAGER="more"

;;

"custom (Enter your own pager command)")

CLI_PAGER=$(prompt "Enter your custom pager command")

;;

*)

warn "Invalid selection. No pager will be set." "⚠️"

CLI_PAGER=""

;;

esac

fi

# Write config file

cat >"$config_file" <<EOF

success "Configuration file created successfully at: $config_file" "✅"

info "You can edit this file at any time to update your configuration."

local cmd=$1

local url=$2

if ! command -v "$cmd" &>/dev/null; then

error "The '$cmd' command could not be found" "🤷‍♂️"

info "Please install '$cmd' from $url"

exit 1

fi

local major_version=${BASH_VERSION%%.*}

if [[ $major_version -lt 5 ]]; then

error "Bash version 5 or higher is required" "🏚️"

info "You are currently running Bash version $BASH_VERSION"

info "Please upgrade your Bash installation"

info "On macOS, you can use: brew install bash"

info "On Linux, use your distribution's package manager"

exit 1

fi

if ! command -v aws &>/dev/null; then

error "The 'aws' command could not be found" "🤷‍♂️"

info "Please install AWS CLI v2 from https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html"

exit 1

fi

local version

version=$(aws --version 2>&1)

if [[ $version != aws-cli/2* ]]; then

error "AWS CLI v2 is required" "🏚️"

info "Please install it from https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html"

exit 1

fi

local temp_file

temp_file=$(mktemp "${AWS_CONFIG_HOME}/$1.XXXXXX" 2>/dev/null)

if [[ -z $temp_file ]]; then

error "Failed to create temporary file for $1" "😢"

exit 1

fi

echo "$temp_file"

[[ -n $ACCOUNTS_LIST && -f $ACCOUNTS_LIST ]] && rm -f "$ACCOUNTS_LIST"

[[ -n $ACCOUNTS_ROLES && -f $ACCOUNTS_ROLES ]] && rm -f "$ACCOUNTS_ROLES"

[[ -n $CTX_CONFIG && -f $CTX_CONFIG ]] && rm -f "$CTX_CONFIG"

[[ -n $TMP_ROLES && -f $TMP_ROLES ]] && rm -f "$TMP_ROLES"

[[ -n $WRITE_TMP && -f $WRITE_TMP ]] && rm -f "$WRITE_TMP"

[[ -n $AWS_CONFIG_PROFILES && -f $AWS_CONFIG_PROFILES ]] && rm -f "$AWS_CONFIG_PROFILES"

[[ -n $SPINTMP && -f $SPINTMP ]] && rm -f "$SPINTMP"

[[ -n $REGION_COUNTS && -f $REGION_COUNTS ]] && rm -f "$REGION_COUNTS"

tput cnorm

cleanup_temp_files

# Kill any background processes

jobs -p | xargs -r kill 2>/dev/null

local xtrace

xtrace=$(set -o | grep xtrace | awk '{print $2}')

set +x

local LC_CTYPE=C

local LC_ALL=en_US.utf-8

tput civis

local CL="\e[2K"

local spin='⢿⣿⣻⣿⣽⣿⣾⣿⣷⣿⣿⣾⣿⣷⣿⣯⣿⣟⣿⡿⣿⢿⡿⣿'

local pid

pid=$(jobs -p)

local charwidth=2

local i=0

while kill -0 "$pid" 2>/dev/null; do

local i=$(((i + charwidth) % ${#spin}))

printf "%s" "${gr}${spin:i:charwidth}${nc}"

_cursorBack 2

sleep .1

done

echo -ne "$CL"

tput cnorm

wait "$pid"

if [[ $xtrace == "on" ]]; then

set -x

fi

local cmd=$1

shift

"$cmd" "$@" >"$SPINTMP" &

[[ $DEBUG == "true" ]] && set +x

_spinner

[[ $DEBUG == "true" ]] && set -x

echo -ne "\r"

cat "$SPINTMP"

if [[ -n $BROWSER_OVERRIDE && $BROWSER_OVERRIDE != "none" ]]; then

BROWSER="$BROWSER_OVERRIDE" aws sso login --sso-session awsctx

elif [[ $BROWSER_OVERRIDE == "none" ]]; then

aws sso login --sso-session awsctx --no-browser

else

aws sso login --sso-session awsctx

fi

trap 'exit 2' SIGINT

if [[ -z $OUTPUT_FORMAT ]]; then

error "No output format provided with the ${it}-o${nc}${rd} flag 🪧${nc}"

# Define options for output format selection

local output_options=(

"json"

"text"

"table"

"yaml"

"yaml-stream"

)

# Use fzf to get user's choice

local selected_format

selected_format=$(select_option "Select output format" "${output_options[@]}")

if [[ -n $selected_format ]]; then

OUTPUT_FORMAT="$selected_format"

else

error "No output format selected. Using default: json" "⚠️"

OUTPUT_FORMAT="json"

fi

fi

success "Output format selected: $OUTPUT_FORMAT" "✅"

# Ask about CLI pager preference only if not already set

if [[ -z ${CLI_PAGER:-} ]]; then

if ask "Would you like to set a CLI pager for AWS output?" "y"; then

info "Common pager options:"

# Define options for pager selection

local pager_options=(

"bat -Ppl yaml (Syntax highlighted output - requires bat)"

"less (Standard pager)"

"more (Simple pager)"

"custom (Enter your own pager command)"

)

# Use fzf to get user's choice

local selected_pager

selected_pager=$(select_option "Select pager" "${pager_options[@]}")

case "$selected_pager" in

"bat -Ppl yaml (Syntax highlighted output - requires bat)")

# Check if bat is installed

if ! command -v bat &>/dev/null; then

error "bat is not installed. Please install bat to use this option." "⚠️"

info "https://github.com/sharkdp/bat#installation"

CLI_PAGER=""

else

CLI_PAGER="bat -Ppl yaml"

fi

;;

"less (Standard pager)")

CLI_PAGER="less"

;;

"more (Simple pager)")

CLI_PAGER="more"

;;

"custom (Enter your own pager command)")

CLI_PAGER=$(prompt "Enter your custom pager command")

;;

*)

warn "Invalid selection. No pager will be set." "⚠️"

CLI_PAGER=""

;;

esac

fi

fi

trap 'exit 2' SIGINT

unset AWS_PROFILE

if [[ -e ${AWS_CONFIG_FILE} && -s ${AWS_CONFIG_FILE} ]]; then

warn "This will overwrite your existing AWS config file: ${AWS_CONFIG_FILE}" "⚠️"

if ask "Would you like to backup your existing AWS config file?" "y"; then

success "Backing up existing AWS config file: ${AWS_CONFIG_FILE}" "💾"

mv "${AWS_CONFIG_FILE}" "${AWS_CONFIG_FILE}.$(date "+%d%b%Y_%H-%M-%S")"

touch "${AWS_CONFIG_FILE}"

fi

fi

echo "$SESSION_BLOCK" >"${AWS_CONFIG_FILE}"

if run_aws_sso_login; then

success "AWS SSO configuration initialized successfully" "✅"

if ask "Would you like to generate AWS profiles now?" "y"; then

GENERATE_CONFIG="true"

if [[ -z $OUTPUT_FORMAT ]]; then

validate_output

fi

generate_config

exit 0 # Exit after generating config to prevent double execution

else

info "You can run '${bl}${bd}awsctx -g${nc}' later to generate your AWS profiles"

fi

else

error "Failed to initialize AWS CLI configuration" "😭"

exit 1

fi

local region=$1

local count=0

# Use set +e to prevent individual AWS command failures from stopping the script

set +e

# Capture counts, defaulting to 0 if commands fail

local ec2_count=0

local s3_count=0

local lambda_count=0

local rds_instance_count=0

local rds_cluster_count=0

ec2_count=$(aws ec2 describe-instances --region "$region" --query "Reservations[*].Instances[*].[InstanceId]" --output text 2>/dev/null | wc -l) || ec2_count=0

if [[ $region == "us-east-1" ]]; then

s3_count=$(aws s3api list-buckets --query "Buckets[*].Name" --output text 2>/dev/null | wc -l) || s3_count=0

fi

lambda_count=$(aws lambda list-functions --region "$region" --query "Functions[*].FunctionName" --output text 2>/dev/null | wc -l) || lambda_count=0

rds_instance_count=$(aws rds describe-db-instances --region "$region" --query "DBInstances[*].DBInstanceIdentifier" --output text 2>/dev/null | wc -l) || rds_instance_count=0

rds_cluster_count=$(aws rds describe-db-clusters --region "$region" --query "DBClusters[*].DBClusterIdentifier" --output text 2>/dev/null | wc -l) || rds_cluster_count=0

# Re-enable error checking

set -e

count=$((ec2_count + s3_count + lambda_count + rds_instance_count + rds_cluster_count))

printf "%s=%d\n" "$region" "$count" >>"$REGION_COUNTS"

return 0

trap 'exit 2' SIGINT

rm -f "$REGION_COUNTS"

touch "$REGION_COUNTS"

# Clear the global associative array

region_counts=()

# Read regions into array

readarray -t region_array < <(echo "$regions" | tr '\t' '\n')

# Store PIDs for background processes

pids=()

# Start all region counts in background

for region in "${region_array[@]}"; do

count_resources "$region" &

pids+=($!)

done

# Wait for all background processes to complete and check their exit status

failed=0

for pid in "${pids[@]}"; do

wait "$pid" || ((failed++))

done

# Read the results

while IFS='=' read -r region count; do

if [[ -n $region && -n $count ]]; then

region_counts["$region"]=$count

fi

done <"$REGION_COUNTS"

# Find the maximum count and primary region

max_count=0

primary_region=""

for region in "${!region_counts[@]}"; do

if ((region_counts[$region] > max_count)); then

max_count=${region_counts[$region]}

primary_region=$region

fi

done

# Export scalar variables

export max_count primary_region

return 0

local count=$1

local max_count=$2

local length=70

local bar_length=$((count * length / max_count))

local bar=""

local part_length=$((length / 2))

for ((i = 0; i < bar_length; i++)); do

if ((i < part_length)); then

local ratio=$((i * 100 / part_length))

local red=$((255 * ratio / 100))

local green=255

local blue=0

else

local ratio=$(((i - part_length) * 100 / part_length))

local red=255

local green=$((255 * (100 - ratio) / 100))

local blue=0

fi

bar="${bar}\e[48;2;${red};${green};${blue}m \e[0m"

done

echo -e "$bar"

trap 'exit 2' SIGINT

if [[ ! -s ${AWS_CONFIG_FILE} ]]; then

error "AWS config file empty: ${AWS_CONFIG_FILE}" "🫥"

info "Proceeding to initialize your AWS CLI configuration..."

setup_aws_config

return

fi

if [[ ! -d $SSO_CACHE_DIR ]]; then

error "SSO cache directory not found: $SSO_CACHE_DIR" "😰"

info "Proceeding to initialize your AWS CLI configuration..."

setup_aws_config

return

fi

LATEST_SSO_CACHE="$(find "${SSO_CACHE_DIR}" -type f -print0 | xargs -0 ls -t | head -n1)"

ACCESS_TOKEN_FILE="${LATEST_SSO_CACHE}"

ACCESS_TOKEN="" # Initialize ACCESS_TOKEN

if [[ ! -f $ACCESS_TOKEN_FILE ]]; then

error "SSO access token could not be found" "😦"

info "Proceeding to initialize your AWS CLI configuration..."

setup_aws_config

return

else

ACCESS_TOKEN=$(jq -e -r '.accessToken' "$ACCESS_TOKEN_FILE" || echo "")

if [[ -z $ACCESS_TOKEN ]]; then

if [[ ! -f ${AWS_CONFIG_FILE} ]]; then

error "AWS config file not found: $AWS_CONFIG_FILE" "🫥"

info "Proceeding to initialize your AWS CLI configuration..."

setup_aws_config

return

else

error "SSO access token not found in cache directory: $SSO_CACHE_DIR" "😶‍🌫️"

info "Please run '${bl}${bd}aws sso login --sso-session awsctx${nc}' to login to AWS SSO"

if ask "Attempt to login to AWS SSO?" "y"; then

run_aws_sso_login

else

exit 1

fi

fi

fi

EXPIRES_AT=$(jq -e -r '.expiresAt' "$ACCESS_TOKEN_FILE")

if [[ $CURRENT_TIME > $EXPIRES_AT ]]; then

error "SSO access token has expired" "👴🏼"

info "Please run '${bl}${bd}aws sso login --sso-session awsctx${nc}' to login to AWS SSO"

if ask "Attempt to login to AWS SSO?" "y"; then

run_aws_sso_login

else

exit 1

fi

fi

fi

# Ensure we have a valid token before proceeding

validate_token

# Now we can safely use ACCESS_TOKEN as it will be set by validate_token

aws \

sso \

list-accounts \

--region us-east-1 \

--access-token "$ACCESS_TOKEN" \

--output json \

--query "accountList[].{accountName: accountName, accountId: accountId}" |

jq 'map(

) | sort_by(.accountName|ascii_upcase)' \

>"$ACCOUNTS_LIST"

trap 'exit 2' SIGINT

# Ensure we have a valid token before proceeding

validate_token

echo "[]" >"$ACCOUNTS_ROLES"

jq -e -c '.[]' "$ACCOUNTS_LIST" | while read -r account; do

ACCOUNT_ID=$(echo "$account" | jq -e -r '.accountId')

ROLES=$(

if [[ -z $ROLES || $ROLES == "[]" ]]; then

warn "No roles found for account ID $ACCOUNT_ID 🙅"

continue

fi

for role in $(echo "$ROLES" | jq -r '.[]'); do

UPDATED_ACCOUNT=$(echo "$account" | jq -e --arg role "$role" '. + {sso_role_name: $role}')

jq -e --argjson newAccount "$UPDATED_ACCOUNT" '. += [$newAccount]' "$ACCOUNTS_ROLES" >"$TMP_ROLES"

mv "$TMP_ROLES" "$ACCOUNTS_ROLES"

done

done

# Create a temporary file for the default profile section

local default_section

default_section=$(create_temp_file "default_section")

# Extract the default profile section to a temporary file first

awk -v common_profile="profile $CROSS_ACCOUNT_PROFILE" '

' "${AWS_CONFIG_PROFILES}" >"$default_section"

# Write all config sections to AWS_CONFIG_PROFILES in a single operation

{

# Write session block

echo "$SESSION_BLOCK"

# Write account profiles

jq -r '

' "$ACCOUNTS_ROLES"

# Write default profile section

echo "[default]"

cat "$default_section"

} >"${AWS_CONFIG_PROFILES}"

# Clean up temporary file

rm -f "$default_section"

# Copy temporary file to final config file

cp "${AWS_CONFIG_PROFILES}" "${AWS_CONFIG_FILE}"

success "AWS profiles have been successfully generated, and written to: ${AWS_CONFIG_FILE}" "✅"

info "You can now use '${bl}${bd}awsctx${nc}' to switch between AWS accounts and roles 🏁"

validate_output

echo -n "📇 Populating Accounts..."

accounts_load

echo "📇 Populating Accounts...${gr}✓${nc}"

echo -n "👥 Gathering roles for accounts..."

roles_load

echo "👥 Gathering roles for accounts...${gr}✓${nc}"

write_config

printf '\n%s%-14s%s │ %s%s%s\n' "${bl}" "Region" "${nc}" "${bl}" "Resources" "${nc}"

printf '%-14s┼%s\n' "───────────────" "───────────"

# Sort regions alphabetically using mapfile

mapfile -t sorted_regions < <(printf '%s\n' "${!region_counts[@]}" | sort)

for region in "${sorted_regions[@]}"; do

local count=${region_counts["$region"]}

local bar=""

if ((count > 0)); then

bar=$(generate_bar "$count" "$max_count")

fi

printf '%-14s │ %s\n' "$region" "$bar"

done

if [[ -n $primary_region ]]; then

printf '\n%s%s%s%s%s (%d resources)\n\n' \

"${cy}" "The primary region with the majority of resources is: " \

"${mg}" "$primary_region" "${nc}" \

"${region_counts[$primary_region]}"

else

printf '\n%s%s%s\n\n' "${cy}" "No resources found in any region." "${nc}"

fi

return 0

local profile_name="$1"

local temp_config="$2"

# Get list of all AWS regions and properly format them

local regions

regions=$(aws --profile "$profile_name" ec2 describe-regions --query "Regions[].RegionName" --output text 2>/dev/null | tr '\t' '\n' | sort) || {

echo "Failed to get regions for profile: $profile_name"

return 1

}

# Process each region

while IFS= read -r region; do

# Skip regions that are known to not have EKS (optional optimization)

case "$region" in

"ap-northeast-3") continue ;; # Osaka - Limited availability

"ap-southeast-4") continue ;; # Melbourne - Limited availability

"eu-south-2") continue ;; # Spain - Limited availability

"eu-central-2") continue ;; # Zurich - Limited availability

"il-central-1") continue ;; # Israel - Limited availability

esac