What’s in your Bash Prompt?

I spend a great deal of time on the command line. That’s how I usually manipulate files, do little maintenance tasks, run tests from and etc. Because of this I like to make that environment nice to look at. I typically set up my console terminals and editors with the excellent and rather popular Solarized theme. I like it because it provides an unified look and feel to my command line regardless of the client or the platform. It works in Konsole, iTerm2 and even in PuTTY on windows via a neat registry hack. Not to mention that the Solarized Dark theme is actually one of the very few light text on dark background combinations that doesn’t make my eyes hurt.

Last week we talked about various ways to streamline and customize Bash. That post didn’t include an important area: the command prompt itself. That’s because it is a complex topic in and of itself.

There are prompt purists out there who swear by the standard, minimalistic prompt like:

PS1="\$ "

This is enough to distinguish whether or not you are logged in as root (though I don’t recall the last time I had to log in anywhere as root because of the magical properties of sudo. But, that’s way to simple for me. For example, I tend to forget where I am in the file system quite easily. Sure, I could always just run pwd to see my location, but why do that if I could simply display it in my prompt using the \w tag like this:

PS1="\w \$ "

While you’re adding crap to your prompt, you might as well go all the way and use the standard prompt string you commonly see on Ubuntu boxes:

PS1="\u@\h:\w \$"

This typically evaluates to the boring username@host:~ $ style prompt. Purists and unix Longbeards scoff at this. They are like “does your username and host change so often you need it in the prompt?” The answer to this is of course… Yes. Kinda. On a typical day I have bunch of terminals open, each of them logged into a different machine. Having my username and host on the prompt lets me ascertain at a glance weather I am logged into the production server, the test server, my home server, my other home server, my vagrant instance or if I’m just on the local prompt. So I actually really need these things there. I also need them not to be this ugly.

Bash lets you use ANSI color codes to colorize your output, using the rather ugly \033 sequence followed by a color code. Unfortunately using these color codes directly turns your prompt into a completely unreadable mess. Check this out:

PS1="\[\033[32m\]\u\[\033[0m\]@\[\033[32m\]\h\[\033[0m\]:\[\033[33m\]\ w\[\033[0m\] \$ "

I absolutely hate this. I edit my prompt only every once in a blue moon, so I don’t memorize these codes. Every time I have to make a change to the prompt I have to make effort to actually parse this ungodly string. So I like to define my color codes like this:

##-ANSI-COLOR-CODES-##
Color_Off="\[\033[0m\]"
###-Regular-###
Red="\[\033[0;31m\]"
Green="\[\033[0;32m\]"
Purple="\[\033[0;35\]"
####-Bold-####
BRed="\[\033[1;31m\]"
BPurple="\[\033[1;35m\]"

Then I can just write my prompt with readable variable names. Please tell me that this is not much, much better than the thorn-bush-tangle looking line from paragraph above:

PS1+="$BRed\u$Color_Off@$BRed\h$Color_Off:$BPurple\w$Color_Off \$"

This gives you a prompt that looks like the one you might have seen in my PHP or bash tutorials from the past – a red username/host part and purple path. It is simple, aesthetic and useful. Lately though I’ve been kinda jealous of the people with tricked out prompts that return the status of the last command or the status of their git repository. So I decided to be fancy and write my own.

The status of the last command was pretty easy. You just check the $? variable and set the colors appropriately. I wanted to do it nicely, so I wrote it as a function.

# Status of last command (for prompt)
function __stat() { 
    if [ $? -eq 0 ]; then 
        echo -en "$Green[✔]$Color_Off" 
    else 
        echo -en "$Red[✘]$Color_Off" 
    fi 
}

The git part was little bit more difficult because while most systems have a __git_ps1 function that is to be used specifically in the prompts, it only returns the name of the current branch, but not it’s status. What I really wanted was to have prompt that could tell me whether or not my index is “dirty” or not.

Most of the time when I cd into a git repository, I run git status to see if there are any uncommited or untracked files in there. Wouldn’t it be nice to have that information in the prompt? But how?

Well, I tried couple of different things and settled on a solution I mostly stole from here. It turns out that there is no way to avoid running git status, but you can force your prompt to do it automatically and then parse the results like this:

# Display the branch name of git repository
# Green -> clean
# purple -> untracked files
# red -> files to commit
function __git_prompt() {

    local git_status="`git status -unormal 2>&1`"

    if ! [[ "$git_status" =~ Not\ a\ git\ repo ]]; then
        if [[ "$git_status" =~ nothing\ to\ commit ]]; then
            local Color_On=$Green
        elif [[ "$git_status" =~ nothing\ added\ to\ commit\ but\ untracked\ files\ present ]]; then
            local Color_On=$Purple
        else
            local Color_On=$Red
        fi

        if [[ "$git_status" =~ On\ branch\ ([^[:space:]]+) ]]; then
            branch=${BASH_REMATCH[1]}
        else
            # Detached HEAD. (branch=HEAD is a faster alternative.)
            branch="(`git describe --all --contains --abbrev=4 HEAD 2> /dev/null || echo HEAD`)"
        fi

        echo -ne "$Color_On[$branch]$Color_Off "
    fi
}

This is not a perfect solution. It parses what is commonly known as the porcelain – the user readable output that is bound to change. So upgrading git to the next release is likely to break if they decide to change the wording of these prompts a bit. Still, this is by far the fastest solution which utilizes only a single external command (other than bash built-ins).

Now you put it all together like this:

PS1=""
# command status (shows check-mark or red x if last command failed)
PS1+='$(__stat) '$Color_Off

# debian chroot stuff (take it or leave it)
PS1+="${debian_chroot:+($debian_chroot)}"

# basic information (user@host:path)
PS1+="$BRed\u$Color_Off@$BRed\h$Color_Off:$BPurple\w$Color_Off "

# add git display to prompt
PS1+='$(__git_prompt)'$Color_Off

# prompt $ or # for root
PS1+="\$ "
export PS1

In a perfect world you ought to have a prompt that looks like this:

My Bash Prompt

Unfortunately, it does not work. Or rather it outputs something that looks like this:

\[\][✔]\[\] luke@firmin:~ \[\][master]\[\] $

The stuff in the middle is fine, but the non-printable character escape codes \[ and \] get printed from within the function calls. Why? Well, internally Bash recognizes these as escape codes when it parses the PS1 prompt variable but the echo command does not recognize them as such. So you can’t use these characters when you echo.

You could always set up your color codes without these characters like this:

Color_Off="\033[0m"
Red="\033[0;31m"
Green="\033[0;32m"
Purple="033[0;35"

Now my functions will work correctly but this causes another issue. If you don’t use the \[ and \] escape codes, Bash treats the ASNI codes as printable characters when it calculates the column count. If your column count is off, then your commands won’t wrap to the next line. Instead they will wrap around and overwrite your prompt. This is endlessly frustrating and annoying. Unfortunately it is a catch 22 – for PS1 prompt to work correctly you must escape color codes. But if you use functions you must echo the results and can’t escape properly.

I spent countless hours fighting with this issue, until I realized that using functions was just not a practical idea. In most scripting environments this would be a sound choice – modular code, encapsulation, etc. But Bash just doesn’t work that way.

So I rewrote it using the PROMPT_COMMAND variable. Normally when you set up your PS1 it gets evaluated when a Bash shell is instantiated. The trick I was using was injecting function literals into that variable, to trick Bash into running them each time it evaluates the prompt. This is hackish, but that’s how most people do it.

There is actually a proper way to set up Bash to build your prompt at run time. What you do is you assign a callback function to PROMPT_COMMAND variable. This function then gets called every time Bash is about to print out your PS1. What’s more important is that this function can manipulate and update the PS1 variable before it gets printed. So as long as you do all your magic in that function, you can append variables directly to PS1 without the need to echo them.

Here is my solution:

# set up command prompt
function __prompt_command()
{
    # capture the exit status of the last command
    EXIT="$?"
    PS1=""

    if [ $EXIT -eq 0 ]; then PS1+="\[$Green\][\!]\[$Color_Off\] "; else PS1+="\[$Red\][\!]\[$Color_Off\] "; fi

    # if logged in via ssh shows the ip of the client
    if [ -n "$SSH_CLIENT" ]; then PS1+="\[$Yellow\]("${$SSH_CLIENT%% *}")\[$Color_Off\]"; fi
    
    # debian chroot stuff (take it or leave it)
    PS1+="${debian_chroot:+($debian_chroot)}"

    # basic information (user@host:path)
    PS1+="\[$BRed\]\u\[$Color_Off\]@\[$BRed\]\h\[$Color_Off\]:\[$BPurple\]  \w\[$Color_Off\] "
    
    # check if inside git repo
    local git_status="`git status -unormal 2>&1`"    
    if ! [[ "$git_status" =~ Not\ a\ git\ repo ]]; then
        # parse the porcelain output of git status
        if [[ "$git_status" =~ nothing\ to\ commit ]]; then
            local Color_On=$Green
        elif [[ "$git_status" =~ nothing\ added\ to\ commit\ but\ untracked\ files\ present ]]; then
            local Color_On=$Purple
        else
            local Color_On=$Red
        fi

        if [[ "$git_status" =~ On\ branch\ ([^[:space:]]+) ]]; then
            branch=${BASH_REMATCH[1]}
        else
            # Detached HEAD. (branch=HEAD is a faster alternative.)
            branch="(`git describe --all --contains --abbrev=4 HEAD 2> /dev/null || echo HEAD`)"
        fi

        # add the result to prompt
        PS1+="\[$Color_On\][$branch]\[$Color_Off\] "
    fi

    # prompt $ or # for root
    PS1+="\$ "
}
PROMPT_COMMAND=__prompt_command

The end result looks like this:

Improved Prompt

As you can see I sort of abandoned the check-mark and x notation in lieu of command history numbers. Why? Mostly because these characters were causing line wrapping issues in some terminals (notably PuTTY). But also because the history numbers are actually somewhat more useful than simple ok/fail which is effectively communicated by color alone.

In addition I also added a little yellow tag that shows your remote IP if you happen to be connected via SSH like this:

Logging into Remote Systems

Why do I need that on my prompt? Well, sometimes it is useful to know your IP – for example not to firewall yourself off from a remote system by accident. It also helps when you do port forwarding or have to play SSH-INCEPTION to get somewhere. For example, if I’m at work I can’t really SSH out of the network because of draconian firewall rules. The only outbound ports that are open to end users are 80 and 443. So if I for some reason I need to log in to one of my Linode boxes or to a university server I first have to SSH home. I run a tiny server listening for SSH connections on port 80 at home for the sole purpose of being my “relay” when I’m at work. So seeing the IP on the prompt gives me an idea where the hell am I logged in from when I suddenly find an open terminal with a live ssh session from 4 hours ago.

How about you? What is on your prompt?