From 2daffdf101f21575f7904d92b29c16bcb448aa10 Mon Sep 17 00:00:00 2001 From: "ohmyzsh[bot]" <54982679+ohmyzsh[bot]@users.noreply.github.com> Date: Mon, 5 Jan 2026 13:07:40 +0100 Subject: [PATCH] chore(kube-ps1): update to 0b0e6daf (#13503) Co-authored-by: ohmyzsh[bot] <54982679+ohmyzsh[bot]@users.noreply.github.com> --- .github/dependencies.yml | 2 +- plugins/kube-ps1/LICENSE | 201 ++++++++++++++++++ plugins/kube-ps1/README.md | 201 ++++++++++++++---- plugins/kube-ps1/kube-ps1.plugin.zsh | 307 +++++++++++++++------------ 4 files changed, 533 insertions(+), 178 deletions(-) create mode 100644 plugins/kube-ps1/LICENSE diff --git a/.github/dependencies.yml b/.github/dependencies.yml index 048cc0f7f..270cb9ec6 100644 --- a/.github/dependencies.yml +++ b/.github/dependencies.yml @@ -30,7 +30,7 @@ dependencies: plugins/kube-ps1: repo: jonmosco/kube-ps1 branch: master - version: e1da055e905a91242f0c5a89a425a64ee8adcd6b + version: 0b0e6daf4197ecabb1ae4f2d46fb148a8e1e73e5 precopy: | set -e find . ! -name kube-ps1.sh ! -name LICENSE ! -name README.md -delete diff --git a/plugins/kube-ps1/LICENSE b/plugins/kube-ps1/LICENSE new file mode 100644 index 000000000..261eeb9e9 --- /dev/null +++ b/plugins/kube-ps1/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/plugins/kube-ps1/README.md b/plugins/kube-ps1/README.md index be3c184be..ef6d781ad 100644 --- a/plugins/kube-ps1/README.md +++ b/plugins/kube-ps1/README.md @@ -1,49 +1,82 @@ # kube-ps1: Kubernetes prompt for bash and zsh +![GitHub Release](https://img.shields.io/github/v/release/jonmosco/kube-ps1) +[![CI](https://github.com/jonmosco/kube-ps1/actions/workflows/ci.yml/badge.svg)](https://github.com/jonmosco/kube-ps1/actions/workflows/ci.yml) + A script that lets you add the current Kubernetes context and namespace configured on `kubectl` to your Bash/Zsh prompt strings (i.e. the `$PS1`). Inspired by several tools used to simplify usage of `kubectl`. +![prompt demo](img/kube-ps1-demo.gif) + ## Installing -### MacOS +### Packages + +### MacOS Brew Ports Homebrew package manager: +```sh +brew update +brew install kube-ps1 ``` -$ brew update -$ brew install kube-ps1 + +### Arch Linux + +AUR Package available at [https://aur.archlinux.org/packages/kube-ps1/](https://aur.archlinux.org/packages/kube-ps1/). + +### Oh My Zsh + +https://github.com/ohmyzsh/ohmyzsh + +kube-ps1 is included as a plugin in the oh-my-zsh project. To enable it, edit your `~/.zshrc` and +add the plugin: + +```bash +plugins=( + kube-ps1 +) +PROMPT='$(kube_ps1)'$PROMPT # or RPROMPT='$(kube_ps1)' ``` -### From Source + +## Zsh zinit plugin + +### Using [zinit](https://github.com/zdharma-continuum/zinit) + +Update `.zshrc` with: + +```sh +zinit light jonmosco/kube-ps1 +PROMPT='$(kube_ps1)'$PROMPT # or RPROMPT='$(kube_ps1)' +``` + +### Fig + +Install `kube-ps1` in zsh, bash, or fish with one click. + + + +### From Source (git clone) 1. Clone this repository 2. Source the kube-ps1.sh in your `~/.zshrc` or your `~/.bashrc` -### Arch Linux -AUR Package available at [https://aur.archlinux.org/packages/kube-ps1/](https://aur.archlinux.org/packages/kube-ps1/). - #### Zsh + ```sh source /path/to/kube-ps1.sh -PROMPT='$(kube_ps1)'$PROMPT +PROMPT='$(kube_ps1)'$PROMPT # or RPROMPT='$(kube_ps1)' ``` + #### Bash + ```sh source /path/to/kube-ps1.sh PS1='[\u@\h \W $(kube_ps1)]\$ ' ``` -### Zsh Plugin Managers - -#### Using [zplugin](https://github.com/zdharma/zplugin) - -Update `.zshrc` with: -```sh -zplugin light jonmosco/kube-ps1 -PROMPT='$(kube_ps1)'$PROMPT -``` - ## Requirements The default prompt assumes you have the `kubectl` command line utility installed. @@ -54,22 +87,23 @@ Official installation instructions and binaries are available: If using this with OpenShift, the `oc` tool needs installed. It can be obtained from brew ports: -``` +```sh brew install openshift-cli ``` + or the source can be downloaded: -[OC Client Tools](https://www.openshift.org/download.html) +[OC Client Tools](https://github.com/okd-project/okd/releases) -Set the binary to `oc` with the following environment variable: +Set the binary to `oc` with the following variable: -``` +```sh KUBE_PS1_BINARY=oc ``` If neither binary is available, the prompt will print the following: -``` +```sh (|BINARY-N/A:N/A) ``` @@ -90,13 +124,13 @@ tmux, and like the functionality provided by kube-ps1, checkout the The default prompt layout is: -``` +```sh (|:) ``` If the current-context is not set, kube-ps1 will return the following: -``` +```sh (|N/A:N/A) ``` @@ -107,7 +141,7 @@ run `kubeoff`. To disable the prompt for all shell sessions, run `kubeoff -g`. You can enable it again in the current shell by running `kubeon`, and globally with `kubeon -g`. -``` +```sh kubeon : turn on kube-ps1 status for this shell. Takes precedence over global setting for current session kubeon -g : turn on kube-ps1 status globally @@ -116,39 +150,69 @@ kubeoff : turn off kube-ps1 status for this shell. Takes precedence over kubeoff -g : turn off kube-ps1 status globally ``` +## Symbol + +The default symbols are UTF8 and should work with most fonts. If you want to use the Kubernetes and OpenShift +glyphs, you need to install a patched font that contains the glyph. [Nerd Fonts](https://www.nerdfonts.com/) provides both glyphs. Follow their installation instructions to install the patched font. + +`KUBE_PS1_SYMBOL_CUSTOM` options + +| Options | Symbol | Description | +| ------------- | ------ | ----------- | +| default (empty string) | ⎈ | Default symbol (Unicode `\u2388`) | +| img | ☸️ | Symbol often used to represent Kubernetes (Unicode `\u2638`) | +| oc | ![openshift-glyph](img/openshift-glyph.png) | Symbol representing OpenShift (Unicode `\ue7b7`) | +| k8s | ![k8s-glyph](img/k8s-glyph.png) | Symbol representing Kubernetes (Unicode `\ue7b7`) | + +To set the symbol to one of the custom glyphs, add the following to your `~/.bashrc` or `~/.zshrc`: + +```sh +KUBE_PS1_SYMBOL_CUSTOM=img +``` + +To set the symbol to the default, set the `KUBE_PS1_SYMBOL` to an empty string. + +Heres a demo of the symbols in action: +![kube-ps1-symbols](img/kube-ps1-symbol-demo.gif) + +If the font is not properly installed, and the glyph is not available, it will display an empty set of brackets or similar: + +```sh + echo -n "\ue7b7" + +``` + ## Customization The default settings can be overridden in `~/.bashrc` or `~/.zshrc` by setting -the following environment variables: +the following variables: | Variable | Default | Meaning | | :------- | :-----: | ------- | | `KUBE_PS1_BINARY` | `kubectl` | Default Kubernetes binary | | `KUBE_PS1_NS_ENABLE` | `true` | Display the namespace. If set to `false`, this will also disable `KUBE_PS1_DIVIDER` | -| `KUBE_PS1_PREFIX` | `(` | Prompt opening character | -| `KUBE_PS1_SYMBOL_ENABLE` | `true ` | Display the prompt Symbol. If set to `false`, this will also disable `KUBE_PS1_SEPARATOR` | +| `KUBE_PS1_PREFIX` | `(` | Prompt opening character | +| `KUBE_PS1_SYMBOL_ENABLE` | `true` | Display the prompt Symbol. If set to `false`, this will also disable `KUBE_PS1_SEPARATOR` | | `KUBE_PS1_SYMBOL_PADDING` | `false` | Adds a space (padding) after the symbol to prevent clobbering prompt characters | -| `KUBE_PS1_SYMBOL_DEFAULT` | `⎈ ` | Default prompt symbol. Unicode `\u2388` | -| `KUBE_PS1_SYMBOL_USE_IMG` | `false` | ☸️ , Unicode `\u2638` as the prompt symbol | +| `KUBE_PS1_SYMBOL_CUSTOM` | `⎈` | Change the Default prompt symbol. Unicode `\u2388`. Options are `k8s`, `img`, `oc` | +| `KUBE_PS1_SYMBOL_COLOR` | `blue` | Change the Default symbol color. | | `KUBE_PS1_SEPARATOR` | | | Separator between symbol and context name | | `KUBE_PS1_DIVIDER` | `:` | Separator between context and namespace | | `KUBE_PS1_SUFFIX` | `)` | Prompt closing character | | `KUBE_PS1_CLUSTER_FUNCTION` | No default, must be user supplied | Function to customize how cluster is displayed | | `KUBE_PS1_NAMESPACE_FUNCTION` | No default, must be user supplied | Function to customize how namespace is displayed | -| `KUBE_PS1_KUBECONFIG_SYMLINK` | `false` | Treat `KUBECONFIG` and `~/.kube/config` files as symbolic links | - -For terminals that do not support UTF-8, the symbol will be replaced with the -string `k8s`. +| `KUBE_PS1_CTX_COLOR_FUNCTION` | No default, must be user supplied | Function to customize context color based on context name | +| `KUBE_PS1_HIDE_IF_NOCONTEXT` | `false` | Hide the kube-ps1 prompt if no context is set | To disable a feature, set it to an empty string: -``` +```sh KUBE_PS1_SEPARATOR='' ``` ## Colors -The default colors are set with the following environment variables: +The default colors are set with the following variables: | Variable | Default | Meaning | | :------- | :-----: | ------- | @@ -166,13 +230,13 @@ namespace. Set the variable to an empty string if you do not want color for each prompt section: -``` +```sh KUBE_PS1_CTX_COLOR='' ``` Names are usable for the following colors: -``` +```text black, red, green, yellow, blue, magenta, cyan ``` @@ -216,6 +280,45 @@ export KUBE_PS1_NAMESPACE_FUNCTION=get_namespace_upper In both cases, the variable is set to the name of the function, and you must have defined the function in your shell configuration before kube_ps1 is called. The function must accept a single parameter and echo out the final value. +## Dynamic Context Colors + +You can set different colors for different contexts using the +`KUBE_PS1_CTX_COLOR_FUNCTION` variable. This is useful for color-coding +contexts to make production environments stand out visually. + +For example, to make production contexts red and development contexts green: + +```sh +function kube_ps1_ctx_color() { + local context="$1" + + case "$context" in + *prod*) + echo "red" + ;; + *dev*) + echo "green" + ;; + *staging*|*stg*) + echo "yellow" + ;; + *) + echo "cyan" # default color for other contexts + ;; + esac +} + +export KUBE_PS1_CTX_COLOR_FUNCTION=kube_ps1_ctx_color +``` + +The function receives the context name as the first parameter and should echo +the desired color name. All color options supported by `KUBE_PS1_CTX_COLOR` are +available, including named colors (black, red, green, yellow, blue, magenta, +cyan, white) and 256-color codes (0-256). + +If `KUBE_PS1_CTX_COLOR_FUNCTION` is not set, kube-ps1 will use the value of +`KUBE_PS1_CTX_COLOR` (default: red). + ### Bug Reports and shell configuration Due to the vast ways of customizing the shell, please try the prompt with a @@ -224,18 +327,28 @@ minimal configuration before submitting a bug report. This can be done as follows for each shell before loading kube-ps1: Bash: -```bash + +```sh bash --norc ``` Zsh: -```bash + +```sh zsh -f or zsh --no-rcs ``` -## Contributors +For the prompt symbol, a patched font that contains the glyphs must be installed. +[Nerd Fonts Downloads](https://www.nerdfonts.com/font-downloads) provides patched +fonts containing the glyphs. Please consult their documentation for this, support +is out of scope for this project. -* [Ahmet Alp Balkan](https://github.com/ahmetb) -* Jared Yanovich +### Contributors + +Thank you to everyone in the community for their contributions to kube-ps1! + + + + diff --git a/plugins/kube-ps1/kube-ps1.plugin.zsh b/plugins/kube-ps1/kube-ps1.plugin.zsh index 7edc62de8..95e91e0d3 100644 --- a/plugins/kube-ps1/kube-ps1.plugin.zsh +++ b/plugins/kube-ps1/kube-ps1.plugin.zsh @@ -3,7 +3,7 @@ # Kubernetes prompt helper for bash/zsh # Displays current context and namespace -# Copyright 2021 Jon Mosco +# Copyright 2026 Jon Mosco # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -24,9 +24,9 @@ # Override these values in ~/.zshrc or ~/.bashrc KUBE_PS1_BINARY="${KUBE_PS1_BINARY:-kubectl}" KUBE_PS1_SYMBOL_ENABLE="${KUBE_PS1_SYMBOL_ENABLE:-true}" -KUBE_PS1_SYMBOL_DEFAULT=${KUBE_PS1_SYMBOL_DEFAULT:-$'\u2388'} KUBE_PS1_SYMBOL_PADDING="${KUBE_PS1_SYMBOL_PADDING:-false}" -KUBE_PS1_SYMBOL_USE_IMG="${KUBE_PS1_SYMBOL_USE_IMG:-false}" +KUBE_PS1_SYMBOL_COLOR="${KUBE_PS1_SYMBOL_COLOR:-}" + KUBE_PS1_NS_ENABLE="${KUBE_PS1_NS_ENABLE:-true}" KUBE_PS1_CONTEXT_ENABLE="${KUBE_PS1_CONTEXT_ENABLE:-true}" KUBE_PS1_PREFIX="${KUBE_PS1_PREFIX-(}" @@ -34,29 +34,28 @@ KUBE_PS1_SEPARATOR="${KUBE_PS1_SEPARATOR-|}" KUBE_PS1_DIVIDER="${KUBE_PS1_DIVIDER-:}" KUBE_PS1_SUFFIX="${KUBE_PS1_SUFFIX-)}" -KUBE_PS1_SYMBOL_COLOR="${KUBE_PS1_SYMBOL_COLOR-blue}" -KUBE_PS1_CTX_COLOR="${KUBE_PS1_CTX_COLOR-red}" -KUBE_PS1_NS_COLOR="${KUBE_PS1_NS_COLOR-cyan}" -KUBE_PS1_BG_COLOR="${KUBE_PS1_BG_COLOR}" +KUBE_PS1_HIDE_IF_NOCONTEXT="${KUBE_PS1_HIDE_IF_NOCONTEXT:-false}" -KUBE_PS1_KUBECONFIG_CACHE="${KUBECONFIG}" -KUBE_PS1_KUBECONFIG_SYMLINK="${KUBE_PS1_KUBECONFIG_SYMLINK:-false}" -KUBE_PS1_DISABLE_PATH="${HOME}/.kube/kube-ps1/disabled" -KUBE_PS1_LAST_TIME=0 -KUBE_PS1_CLUSTER_FUNCTION="${KUBE_PS1_CLUSTER_FUNCTION}" -KUBE_PS1_NAMESPACE_FUNCTION="${KUBE_PS1_NAMESPACE_FUNCTION}" +_KUBE_PS1_KUBECONFIG_CACHE="${KUBECONFIG}" +_KUBE_PS1_DISABLE_PATH="${HOME}/.kube/kube-ps1/disabled" +_KUBE_PS1_LAST_TIME=0 # Determine our shell -if [ "${ZSH_VERSION-}" ]; then - KUBE_PS1_SHELL="zsh" -elif [ "${BASH_VERSION-}" ]; then - KUBE_PS1_SHELL="bash" -fi +_kube_ps1_shell_type() { + local _KUBE_PS1_SHELL_TYPE + + if [ "${ZSH_VERSION-}" ]; then + _KUBE_PS1_SHELL_TYPE="zsh" + elif [ "${BASH_VERSION-}" ]; then + _KUBE_PS1_SHELL_TYPE="bash" + fi + echo $_KUBE_PS1_SHELL_TYPE +} _kube_ps1_init() { - [[ -f "${KUBE_PS1_DISABLE_PATH}" ]] && KUBE_PS1_ENABLED=off + [[ -f "${_KUBE_PS1_DISABLE_PATH}" ]] && KUBE_PS1_ENABLED=off - case "${KUBE_PS1_SHELL}" in + case "$(_kube_ps1_shell_type)" in "zsh") _KUBE_PS1_OPEN_ESC="%{" _KUBE_PS1_CLOSE_ESC="%}" @@ -64,7 +63,7 @@ _kube_ps1_init() { _KUBE_PS1_DEFAULT_FG="%f" setopt PROMPT_SUBST autoload -U add-zsh-hook - add-zsh-hook precmd _kube_ps1_update_cache + add-zsh-hook precmd _kube_ps1_prompt_update zmodload -F zsh/stat b:zstat zmodload zsh/datetime ;; @@ -73,75 +72,75 @@ _kube_ps1_init() { _KUBE_PS1_CLOSE_ESC=$'\002' _KUBE_PS1_DEFAULT_BG=$'\033[49m' _KUBE_PS1_DEFAULT_FG=$'\033[39m' - [[ $PROMPT_COMMAND =~ _kube_ps1_update_cache ]] || PROMPT_COMMAND="_kube_ps1_update_cache;${PROMPT_COMMAND:-:}" + [[ $PROMPT_COMMAND =~ _kube_ps1_prompt_update ]] || PROMPT_COMMAND="_kube_ps1_prompt_update;${PROMPT_COMMAND:-:}" ;; esac } _kube_ps1_color_fg() { - local KUBE_PS1_FG_CODE + local _KUBE_PS1_FG_CODE case "${1}" in - black) KUBE_PS1_FG_CODE=0;; - red) KUBE_PS1_FG_CODE=1;; - green) KUBE_PS1_FG_CODE=2;; - yellow) KUBE_PS1_FG_CODE=3;; - blue) KUBE_PS1_FG_CODE=4;; - magenta) KUBE_PS1_FG_CODE=5;; - cyan) KUBE_PS1_FG_CODE=6;; - white) KUBE_PS1_FG_CODE=7;; + black) _KUBE_PS1_FG_CODE=0;; + red) _KUBE_PS1_FG_CODE=1;; + green) _KUBE_PS1_FG_CODE=2;; + yellow) _KUBE_PS1_FG_CODE=3;; + blue) _KUBE_PS1_FG_CODE=4;; + magenta) _KUBE_PS1_FG_CODE=5;; + cyan) _KUBE_PS1_FG_CODE=6;; + white) _KUBE_PS1_FG_CODE=7;; # 256 - [0-9]|[1-9][0-9]|[1][0-9][0-9]|[2][0-4][0-9]|[2][5][0-6]) KUBE_PS1_FG_CODE="${1}";; - *) KUBE_PS1_FG_CODE=default + [0-9]|[1-9][0-9]|[1][0-9][0-9]|[2][0-4][0-9]|[2][5][0-6]) _KUBE_PS1_FG_CODE="${1}";; + *) _KUBE_PS1_FG_CODE=default esac - if [[ "${KUBE_PS1_FG_CODE}" == "default" ]]; then - KUBE_PS1_FG_CODE="${_KUBE_PS1_DEFAULT_FG}" + if [[ "${_KUBE_PS1_FG_CODE}" == "default" ]]; then + _KUBE_PS1_FG_CODE="${_KUBE_PS1_DEFAULT_FG}" return - elif [[ "${KUBE_PS1_SHELL}" == "zsh" ]]; then - KUBE_PS1_FG_CODE="%F{$KUBE_PS1_FG_CODE}" - elif [[ "${KUBE_PS1_SHELL}" == "bash" ]]; then + elif [[ "$(_kube_ps1_shell_type)" == "zsh" ]]; then + _KUBE_PS1_FG_CODE="%F{$_KUBE_PS1_FG_CODE}" + elif [[ "$(_kube_ps1_shell_type)" == "bash" ]]; then if tput setaf 1 &> /dev/null; then - KUBE_PS1_FG_CODE="$(tput setaf ${KUBE_PS1_FG_CODE})" - elif [[ $KUBE_PS1_FG_CODE -ge 0 ]] && [[ $KUBE_PS1_FG_CODE -le 256 ]]; then - KUBE_PS1_FG_CODE="\033[38;5;${KUBE_PS1_FG_CODE}m" + _KUBE_PS1_FG_CODE="$(tput setaf "${_KUBE_PS1_FG_CODE}")" + elif [[ $_KUBE_PS1_FG_CODE -ge 0 ]] && [[ $_KUBE_PS1_FG_CODE -le 256 ]]; then + _KUBE_PS1_FG_CODE="\033[38;5;${_KUBE_PS1_FG_CODE}m" else - KUBE_PS1_FG_CODE="${_KUBE_PS1_DEFAULT_FG}" + _KUBE_PS1_FG_CODE="${_KUBE_PS1_DEFAULT_FG}" fi fi - echo ${_KUBE_PS1_OPEN_ESC}${KUBE_PS1_FG_CODE}${_KUBE_PS1_CLOSE_ESC} + echo "${_KUBE_PS1_OPEN_ESC}${_KUBE_PS1_FG_CODE}${_KUBE_PS1_CLOSE_ESC}" } _kube_ps1_color_bg() { - local KUBE_PS1_BG_CODE + local _KUBE_PS1_BG_CODE case "${1}" in - black) KUBE_PS1_BG_CODE=0;; - red) KUBE_PS1_BG_CODE=1;; - green) KUBE_PS1_BG_CODE=2;; - yellow) KUBE_PS1_BG_CODE=3;; - blue) KUBE_PS1_BG_CODE=4;; - magenta) KUBE_PS1_BG_CODE=5;; - cyan) KUBE_PS1_BG_CODE=6;; - white) KUBE_PS1_BG_CODE=7;; + black) _KUBE_PS1_BG_CODE=0;; + red) _KUBE_PS1_BG_CODE=1;; + green) _KUBE_PS1_BG_CODE=2;; + yellow) _KUBE_PS1_BG_CODE=3;; + blue) _KUBE_PS1_BG_CODE=4;; + magenta) _KUBE_PS1_BG_CODE=5;; + cyan) _KUBE_PS1_BG_CODE=6;; + white) _KUBE_PS1_BG_CODE=7;; # 256 - [0-9]|[1-9][0-9]|[1][0-9][0-9]|[2][0-4][0-9]|[2][5][0-6]) KUBE_PS1_BG_CODE="${1}";; - *) KUBE_PS1_BG_CODE=$'\033[0m';; + [0-9]|[1-9][0-9]|[1][0-9][0-9]|[2][0-4][0-9]|[2][5][0-6]) _KUBE_PS1_BG_CODE="${1}";; + *) _KUBE_PS1_BG_CODE=$'\033[0m';; esac - if [[ "${KUBE_PS1_BG_CODE}" == "default" ]]; then - KUBE_PS1_FG_CODE="${_KUBE_PS1_DEFAULT_BG}" + if [[ "${_KUBE_PS1_BG_CODE}" == "default" ]]; then + _KUBE_PS1_FG_CODE="${_KUBE_PS1_DEFAULT_BG}" return - elif [[ "${KUBE_PS1_SHELL}" == "zsh" ]]; then - KUBE_PS1_BG_CODE="%K{$KUBE_PS1_BG_CODE}" - elif [[ "${KUBE_PS1_SHELL}" == "bash" ]]; then + elif [[ "$(_kube_ps1_shell_type)" == "zsh" ]]; then + _KUBE_PS1_BG_CODE="%K{$_KUBE_PS1_BG_CODE}" + elif [[ "$(_kube_ps1_shell_type)" == "bash" ]]; then if tput setaf 1 &> /dev/null; then - KUBE_PS1_BG_CODE="$(tput setab ${KUBE_PS1_BG_CODE})" - elif [[ $KUBE_PS1_BG_CODE -ge 0 ]] && [[ $KUBE_PS1_BG_CODE -le 256 ]]; then - KUBE_PS1_BG_CODE="\033[48;5;${KUBE_PS1_BG_CODE}m" + _KUBE_PS1_BG_CODE="$(tput setab "${_KUBE_PS1_BG_CODE}")" + elif [[ $_KUBE_PS1_BG_CODE -ge 0 ]] && [[ $_KUBE_PS1_BG_CODE -le 256 ]]; then + _KUBE_PS1_BG_CODE="\033[48;5;${_KUBE_PS1_BG_CODE}m" else - KUBE_PS1_BG_CODE="${DEFAULT_BG}" + _KUBE_PS1_BG_CODE="${DEFAULT_BG}" fi fi - echo ${OPEN_ESC}${KUBE_PS1_BG_CODE}${CLOSE_ESC} + echo "${_KUBE_PS1_OPEN_ESC}${_KUBE_PS1_BG_CODE}${_KUBE_PS1_CLOSE_ESC}" } _kube_ps1_binary_check() { @@ -149,38 +148,60 @@ _kube_ps1_binary_check() { } _kube_ps1_symbol() { + # Exit early if symbol display is disabled [[ "${KUBE_PS1_SYMBOL_ENABLE}" == false ]] && return - case "${KUBE_PS1_SHELL}" in - bash) - if ((BASH_VERSINFO[0] >= 4)) && [[ $'\u2388' != "\\u2388" ]]; then - KUBE_PS1_SYMBOL="${KUBE_PS1_SYMBOL_DEFAULT}" - KUBE_PS1_SYMBOL_IMG=$'\u2638\ufe0f' - else - KUBE_PS1_SYMBOL=$'\xE2\x8E\x88' - KUBE_PS1_SYMBOL_IMG=$'\xE2\x98\xB8' - fi + local symbol_arg="${KUBE_PS1_SYMBOL_CUSTOM}" + + local symbol="" + local symbol_default=$'\u2388' + local symbol_img="☸️" + local k8s_glyph=$'\Uf10fe' + local k8s_symbol_color=blue + local oc_glyph=$'\ue7b7' + local oc_symbol_color=red + local custom_symbol_color="${KUBE_PS1_SYMBOL_COLOR:-$k8s_symbol_color}" + + # Choose the symbol based on the provided argument or environment variable + case "${symbol_arg}" in + "img") + symbol="${symbol_img}" + ;; + "k8s") + symbol="$(_kube_ps1_color_fg "${custom_symbol_color}")${k8s_glyph}${KUBE_PS1_RESET_COLOR}" + ;; + "oc") + symbol="$(_kube_ps1_color_fg ${oc_symbol_color})${oc_glyph}${KUBE_PS1_RESET_COLOR}" ;; - zsh) - KUBE_PS1_SYMBOL="${KUBE_PS1_SYMBOL_DEFAULT}" - KUBE_PS1_SYMBOL_IMG="\u2638";; *) - KUBE_PS1_SYMBOL="k8s" + case "$(_kube_ps1_shell_type)" in + bash) + if ((BASH_VERSINFO[0] >= 4)) && [[ $'\u2388' != "\\u2388" ]]; then + symbol="$(_kube_ps1_color_fg $custom_symbol_color)${symbol_default}${KUBE_PS1_RESET_COLOR}" + symbol_img=$'\u2638\ufe0f' + else + symbol=$'\xE2\x8E\x88' + symbol_img=$'\xE2\x98\xB8' + fi + ;; + zsh) + symbol="$(_kube_ps1_color_fg $custom_symbol_color)${symbol_default}${KUBE_PS1_RESET_COLOR}" + symbol_img="☸️" + ;; + *) + symbol="k8s" + esac esac - if [[ "${KUBE_PS1_SYMBOL_USE_IMG}" == true ]]; then - KUBE_PS1_SYMBOL="${KUBE_PS1_SYMBOL_IMG}" - fi - + # Append padding if enabled if [[ "${KUBE_PS1_SYMBOL_PADDING}" == true ]]; then - echo "${KUBE_PS1_SYMBOL} " + echo "${symbol} " else - echo "${KUBE_PS1_SYMBOL}" + echo "${symbol}" fi - } -_kube_ps1_split() { +_kube_ps1_split_config() { type setopt >/dev/null 2>&1 && setopt SH_WORD_SPLIT local IFS=$1 echo $2 @@ -191,32 +212,21 @@ _kube_ps1_file_newer_than() { local file=$1 local check_time=$2 - if [[ "${KUBE_PS1_KUBECONFIG_SYMLINK}" == "true" ]]; then - if [[ "${KUBE_PS1_SHELL}" == "zsh" ]]; then - mtime=$(zstat -L +mtime "${file}") - elif stat -c "%s" /dev/null &> /dev/null; then - # GNU stat - mtime=$(stat -c %Y "${file}") - else - # BSD stat - mtime=$(stat -f %m "$file") - fi + if [[ "$(_kube_ps1_shell_type)" == "zsh" ]]; then + # Use zstat '-F %s.%s' to make it compatible with low zsh version (eg: 5.0.2) + mtime=$(zstat -L +mtime -F %s.%s "${file}") + elif stat -c "%s" /dev/null &> /dev/null; then + # GNU stat + mtime=$(stat -L -c %Y "${file}") else - if [[ "${KUBE_PS1_SHELL}" == "zsh" ]]; then - mtime=$(zstat +mtime "${file}") - elif stat -c "%s" /dev/null &> /dev/null; then - # GNU stat - mtime=$(stat -L -c %Y "${file}") - else - # BSD stat - mtime=$(stat -L -f %m "$file") - fi + # BSD stat + mtime=$(stat -L -f %m "$file") fi [[ "${mtime}" -gt "${check_time}" ]] } -_kube_ps1_update_cache() { +_kube_ps1_prompt_update() { local return_code=$? [[ "${KUBE_PS1_ENABLED}" == "off" ]] && return $return_code @@ -225,27 +235,35 @@ _kube_ps1_update_cache() { # No ability to fetch context/namespace; display N/A. KUBE_PS1_CONTEXT="BINARY-N/A" KUBE_PS1_NAMESPACE="N/A" - return + return $return_code fi - if [[ "${KUBECONFIG}" != "${KUBE_PS1_KUBECONFIG_CACHE}" ]]; then + if [[ "${KUBECONFIG}" != "${_KUBE_PS1_KUBECONFIG_CACHE}" ]]; then # User changed KUBECONFIG; unconditionally refetch. - KUBE_PS1_KUBECONFIG_CACHE=${KUBECONFIG} + _KUBE_PS1_KUBECONFIG_CACHE=${KUBECONFIG} _kube_ps1_get_context_ns - return + return $return_code fi # kubectl will read the environment variable $KUBECONFIG # otherwise set it to ~/.kube/config local conf - for conf in $(_kube_ps1_split : "${KUBECONFIG:-${HOME}/.kube/config}"); do + local config_file_cache + + for conf in $(_kube_ps1_split_config : "${KUBECONFIG:-${HOME}/.kube/config}"); do [[ -r "${conf}" ]] || continue - if _kube_ps1_file_newer_than "${conf}" "${KUBE_PS1_LAST_TIME}"; then + config_file_cache+=":${conf}" + if _kube_ps1_file_newer_than "${conf}" "${_KUBE_PS1_LAST_TIME}"; then _kube_ps1_get_context_ns - return + return $return_code fi done + if [[ "${config_file_cache}" != "${_KUBE_PS1_CFGFILES_READ_CACHE}" ]]; then + _kube_ps1_get_context_ns + return $return_code + fi + return $return_code } @@ -255,8 +273,8 @@ _kube_ps1_get_context() { # Set namespace to 'N/A' if it is not defined KUBE_PS1_CONTEXT="${KUBE_PS1_CONTEXT:-N/A}" - if [[ ! -z "${KUBE_PS1_CLUSTER_FUNCTION}" ]]; then - KUBE_PS1_CONTEXT=$($KUBE_PS1_CLUSTER_FUNCTION $KUBE_PS1_CONTEXT) + if [[ -n "${KUBE_PS1_CLUSTER_FUNCTION}" ]]; then + KUBE_PS1_CONTEXT="$("${KUBE_PS1_CLUSTER_FUNCTION}" "${KUBE_PS1_CONTEXT}")" fi fi } @@ -264,27 +282,36 @@ _kube_ps1_get_context() { _kube_ps1_get_ns() { if [[ "${KUBE_PS1_NS_ENABLE}" == true ]]; then KUBE_PS1_NAMESPACE="$(${KUBE_PS1_BINARY} config view --minify --output 'jsonpath={..namespace}' 2>/dev/null)" - # Set namespace to 'default' if it is not defined - KUBE_PS1_NAMESPACE="${KUBE_PS1_NAMESPACE:-default}" + KUBE_PS1_NAMESPACE="${KUBE_PS1_NAMESPACE:-N/A}" - if [[ ! -z "${KUBE_PS1_NAMESPACE_FUNCTION}" ]]; then - KUBE_PS1_NAMESPACE=$($KUBE_PS1_NAMESPACE_FUNCTION $KUBE_PS1_NAMESPACE) + if [[ -n "${KUBE_PS1_NAMESPACE_FUNCTION}" ]]; then + KUBE_PS1_NAMESPACE="$("${KUBE_PS1_NAMESPACE_FUNCTION}" "${KUBE_PS1_NAMESPACE}")" fi fi } _kube_ps1_get_context_ns() { # Set the command time - if [[ "${KUBE_PS1_SHELL}" == "bash" ]]; then + if [[ "$(_kube_ps1_shell_type)" == "bash" ]]; then if ((BASH_VERSINFO[0] >= 4 && BASH_VERSINFO[1] >= 2)); then - KUBE_PS1_LAST_TIME=$(printf '%(%s)T') + _KUBE_PS1_LAST_TIME=$(printf '%(%s)T') else - KUBE_PS1_LAST_TIME=$(date +%s) + _KUBE_PS1_LAST_TIME=$(date +%s) fi - elif [[ "${KUBE_PS1_SHELL}" == "zsh" ]]; then - KUBE_PS1_LAST_TIME=$EPOCHSECONDS + elif [[ "$(_kube_ps1_shell_type)" == "zsh" ]]; then + _KUBE_PS1_LAST_TIME=$EPOCHREALTIME fi + KUBE_PS1_CONTEXT="${KUBE_PS1_CONTEXT:-N/A}" + KUBE_PS1_NAMESPACE="${KUBE_PS1_NAMESPACE:-N/A}" + + # Cache which cfgfiles we can read in case they change. + local conf + _KUBE_PS1_CFGFILES_READ_CACHE= + for conf in $(_kube_ps1_split_config : "${KUBECONFIG:-${HOME}/.kube/config}"); do + [[ -r $conf ]] && _KUBE_PS1_CFGFILES_READ_CACHE+=":$conf" + done + _kube_ps1_get_context _kube_ps1_get_ns } @@ -298,7 +325,7 @@ Toggle kube-ps1 prompt on Usage: kubeon [-g | --global] [-h | --help] -With no arguments, turn off kube-ps1 status for this shell instance (default). +With no arguments, turn oon kube-ps1 status for this shell instance (default). -g --global turn on kube-ps1 status globally -h --help print this message @@ -322,7 +349,7 @@ kubeon() { if [[ "${1}" == '-h' || "${1}" == '--help' ]]; then _kubeon_usage elif [[ "${1}" == '-g' || "${1}" == '--global' ]]; then - rm -f -- "${KUBE_PS1_DISABLE_PATH}" + rm -f -- "${_KUBE_PS1_DISABLE_PATH}" elif [[ "$#" -ne 0 ]]; then echo -e "error: unrecognized flag ${1}\\n" _kubeon_usage @@ -336,8 +363,8 @@ kubeoff() { if [[ "${1}" == '-h' || "${1}" == '--help' ]]; then _kubeoff_usage elif [[ "${1}" == '-g' || "${1}" == '--global' ]]; then - mkdir -p -- "$(dirname "${KUBE_PS1_DISABLE_PATH}")" - touch -- "${KUBE_PS1_DISABLE_PATH}" + mkdir -p -- "$(dirname "${_KUBE_PS1_DISABLE_PATH}")" + touch -- "${_KUBE_PS1_DISABLE_PATH}" elif [[ $# -ne 0 ]]; then echo "error: unrecognized flag ${1}" >&2 _kubeoff_usage @@ -351,22 +378,29 @@ kubeoff() { kube_ps1() { [[ "${KUBE_PS1_ENABLED}" == "off" ]] && return [[ -z "${KUBE_PS1_CONTEXT}" ]] && [[ "${KUBE_PS1_CONTEXT_ENABLE}" == true ]] && return + [[ "${KUBE_PS1_CONTEXT}" == "N/A" ]] && [[ ${KUBE_PS1_HIDE_IF_NOCONTEXT} == true ]] && return + local KUBE_PS1 local KUBE_PS1_RESET_COLOR="${_KUBE_PS1_OPEN_ESC}${_KUBE_PS1_DEFAULT_FG}${_KUBE_PS1_CLOSE_ESC}" + # If background color is set, reset color should also reset the background + if [[ -n "${KUBE_PS1_BG_COLOR}" ]]; then + KUBE_PS1_RESET_COLOR="${_KUBE_PS1_OPEN_ESC}${_KUBE_PS1_DEFAULT_FG}${_KUBE_PS1_DEFAULT_BG}${_KUBE_PS1_CLOSE_ESC}" + fi + # Background Color - [[ -n "${KUBE_PS1_BG_COLOR}" ]] && KUBE_PS1+="$(_kube_ps1_color_bg ${KUBE_PS1_BG_COLOR})" + [[ -n "${KUBE_PS1_BG_COLOR}" ]] && KUBE_PS1+="$(_kube_ps1_color_bg "${KUBE_PS1_BG_COLOR}")" # Prefix if [[ -z "${KUBE_PS1_PREFIX_COLOR:-}" ]] && [[ -n "${KUBE_PS1_PREFIX}" ]]; then KUBE_PS1+="${KUBE_PS1_PREFIX}" else - KUBE_PS1+="$(_kube_ps1_color_fg $KUBE_PS1_PREFIX_COLOR)${KUBE_PS1_PREFIX}${KUBE_PS1_RESET_COLOR}" + KUBE_PS1+="$(_kube_ps1_color_fg "${KUBE_PS1_PREFIX_COLOR}")${KUBE_PS1_PREFIX}${KUBE_PS1_RESET_COLOR}" fi # Symbol - KUBE_PS1+="$(_kube_ps1_color_fg $KUBE_PS1_SYMBOL_COLOR)$(_kube_ps1_symbol)${KUBE_PS1_RESET_COLOR}" + KUBE_PS1+="$(_kube_ps1_symbol)" if [[ -n "${KUBE_PS1_SEPARATOR}" ]] && [[ "${KUBE_PS1_SYMBOL_ENABLE}" == true ]]; then KUBE_PS1+="${KUBE_PS1_SEPARATOR}" @@ -374,7 +408,14 @@ kube_ps1() { # Context if [[ "${KUBE_PS1_CONTEXT_ENABLE}" == true ]]; then - KUBE_PS1+="$(_kube_ps1_color_fg $KUBE_PS1_CTX_COLOR)${KUBE_PS1_CONTEXT}${KUBE_PS1_RESET_COLOR}" + local ctx_color="${KUBE_PS1_CTX_COLOR:-red}" + + # Allow custom function to override color based on context + if [[ -n "${KUBE_PS1_CTX_COLOR_FUNCTION}" ]]; then + ctx_color="$("${KUBE_PS1_CTX_COLOR_FUNCTION}" "${KUBE_PS1_CONTEXT}")" + fi + + KUBE_PS1+="$(_kube_ps1_color_fg "${ctx_color}")${KUBE_PS1_CONTEXT}${KUBE_PS1_RESET_COLOR}" fi # Namespace @@ -382,14 +423,14 @@ kube_ps1() { if [[ -n "${KUBE_PS1_DIVIDER}" ]] && [[ "${KUBE_PS1_CONTEXT_ENABLE}" == true ]]; then KUBE_PS1+="${KUBE_PS1_DIVIDER}" fi - KUBE_PS1+="$(_kube_ps1_color_fg ${KUBE_PS1_NS_COLOR})${KUBE_PS1_NAMESPACE}${KUBE_PS1_RESET_COLOR}" + KUBE_PS1+="$(_kube_ps1_color_fg "${KUBE_PS1_NS_COLOR:-cyan}")${KUBE_PS1_NAMESPACE}${KUBE_PS1_RESET_COLOR}" fi # Suffix if [[ -z "${KUBE_PS1_SUFFIX_COLOR:-}" ]] && [[ -n "${KUBE_PS1_SUFFIX}" ]]; then KUBE_PS1+="${KUBE_PS1_SUFFIX}" else - KUBE_PS1+="$(_kube_ps1_color_fg $KUBE_PS1_SUFFIX_COLOR)${KUBE_PS1_SUFFIX}${KUBE_PS1_RESET_COLOR}" + KUBE_PS1+="$(_kube_ps1_color_fg "${KUBE_PS1_SUFFIX_COLOR}")${KUBE_PS1_SUFFIX}${KUBE_PS1_RESET_COLOR}" fi # Close Background color if defined