gh-ma

#!/bin/bash
# vim: set expandtab:tabstop=4:shiftwidth=4

# SPDX-License-Identifier: GPL-3.0-or-later
# Copyright Matthew Cline (2021)
# License: GPL v3+

set -o nounset

###############################################################################
# Basic setup

gh_ma_ver="1.0.0"
gh_ma_url="https://github.com/matthew-cline/gh-multi-account"

function gh_ma_help() {
    echo For help see: 1>&2
    echo $gh_ma_url/blob/v$gh_ma_ver/README.md 1>&2
}

gh_conf_dir=${GH_CONFIG_DIR:-"$HOME/.config/gh"}
conf_dir=${GH_MA_CONFIG_DIR:-"$gh_conf_dir/multi-account"}

conf_file="$conf_dir/tokens.conf"

if [[ ! -e "$gh_conf_dir" ]]; then
    echo gh-ma: ERROR: gh config dir \"$gh_conf_dir\" does not exist 1>&2
    gh_ma_help
    exit 1
fi
if [[ ! -e "$conf_dir" ]]; then
    echo gh-ma: ERROR: gh multi account config dir \"$conf_dir\" does \
        not exist 1>&2
    gh_ma_help
    exit 1
fi
if [[ ! -e "$conf_file" ]]; then
    echo gh-ma: ERROR: \"$conf_file\" does not exist 1>&2
    gh_ma_help
    exit 1
fi
if [[ ! -r "$conf_file" ]]; then
    echo gh-ma: ERROR: \"$conf_file\" not readable 1>&2
    gh_ma_help
    exit 1
fi

is_an_alias=0
is_in_path=0

if [[ ${BASH_SOURCE[0]} == "gh" || ${BASH_SOURCE[0]} =~ /gh$ ]]; then
    is_in_path=1
else
    is_an_alias=1
fi

###############################################################################
# Find the GitHub CLI executable to use

if [[ -n "${GH_EXE+unset}" ]]; then
    gh_exe=$GH_EXE
elif [[ $is_in_path -eq 1 ]]; then
    # Cache the path to the GitHub CLI executable via a symboloc link,
    # to reduce the expense of forks incurred by using non-builtin commands.
    gh_exe="$conf_dir/gh"

    # NOTE: if file test "-e" is given a symbolic link, it tests for the
    # existence of what the link points to, not the link itself.
    if [[ ! -e "$gh_exe" ]]; then
        if [[ ! -w $conf_dir ]]; then
            echo gh-ma: ERROR: cannot fix stale/nonexistent \"$gh_exe\" 1>&2
            gh_ma_help
            exit 1
        fi
        ma_exe="$(readlink -f "${BASH_SOURCE[0]}")"
        cli_exe=""
        possibilities=($(which -a gh))
        for file in ${possibilities[@]}; do
            # Expand "~"
            eval file="$file"

            # Only use absolute links
            if [[ ! $file =~ ^/ ]]; then
                continue
            fi

            # Skip anything that seems to be the multi account wrapper script
            if [[ "$ma_exe" != "$(readlink -f "$file")" ]]; then
                cli_exe="$file"
                break
            fi
        done
        if [[ -z "$cli_exe" ]]; then
            echo gh-ma: ERROR: could not find GitHub CLI executable 1>&2
            exit 1
        fi
        ln -f -s "$cli_exe" "$gh_exe"
    fi
else
    # If we're used via an alais just use whatever is in PATH
    gh_exe="gh"
fi

###############################################################################
# Setup is done, but we might not have a lot to do, depending upon the
# environmental variables and the command line arguments.

# If a GitHub token is already set we have nothing to do
set +o nounset
if [[ -n "$GH_TOKEN" || -n "$GITHUB_TOKEN" || -n "$GH_ENTERPRISE_TOKEN" ||
      -n "$GITHUB_ENTERPRISE_TOKEN" ]]; then
    exec $gh_exe "$@"
fi
set -o nounset

token_id=""
case ${1:-""} in
    --version|--help|alias|completion|config|help)
        # These don't use authorization, simply pass to gh
        exec $gh_exe "$@"
        ;;

    --version-ma)
        echo "gh multi account version $gh_ma_ver"
        exit 0
        ;;

    --ma-info)
        if [[ $is_in_path -eq 1 ]]; then
            echo We appear to be installed in PATH
            if [[ -z "${GH_EXE+unset}" ]]; then
                gh_exe="$(readlink "$gh_exe")"
            fi
        else
            echo We appear to be used via an alias
        fi
        echo GitHub CLI executable used is \"$gh_exe\"
        if [[ -n "${GH_EXE+unset}" ]]; then
            echo Executable was set via env var GH_EXE
        fi
        echo

        default_token_id_file="$conf_dir/default-token-id"
        default_token_id_script="$conf_dir/default-token-id.sh"

        if [[ -r "$default_token_id_script" ]]; then
            source "$default_token_id_script"
            script_default_id=${token_id:-""}
        fi

        if [[ -n ${GH_DEFAULT_TOKEN_ID+unset} ]]; then
            echo Default token id is $GH_DEFAULT_TOKEN_ID
            echo Default token id set by env var GH_DEFAULT_TOKEN_ID
            if [[ -n "$srcript_default_id" ]]; then
                echo A default token id is also specified in \
                    $default_token_id_script
            fi
            if [[ -r "$default_token_id_file" ]]; then
                echo A default token id is also specified in \
                    $default_token_id_file
            fi
        elif [[ -n "$script_default_id" ]]; then
            echo Default token id is $script_default_id
            echo Default token id is specified in $default_token_id_script
            if [[ -r "$default_token_id_file" ]]; then
                echo A default token id is also specified in \
                    $default_token_id_file
            fi
        elif [[ -r "$default_token_id_file" ]]; then
            echo Default token id is $(<$default_token_id_file)
            echo Default token id is specified in $default_token_id_file
        else
            echo No default token id specified
        fi

        if [[ -r "$default_token_id_script" && -z "$script_default_id" ]]; then
            echo $default_token_id_script exists but does not set token_id \
                when sourced
        fi

        echo
        echo GitHub CLI config dir is \"$gh_conf_dir\"
        if [[ -n ${GH_CONFIG_DIR+unset} ]]; then
            echo Directory set via env var GH_CONFIG_DIR
        fi
        if [[ ! -w "$gh_conf_dir" ]]; then
            echo NOTE: you do not have write access to that directory
        fi
        echo

        echo gh multi account config dir is \"$conf_dir\"
        if [[ -n ${GH_MA_CONFIG_DIR+unset} ]]; then
            echo Directory set via env var GH_MA_CONFIG_DIR
        fi
        if [[ ! -w "$conf_dir" ]]; then
            echo NOTE: you do not have write access to that directory
        fi

        exit 0
        ;;

    --token-id)
        shift
        if [[ -z ${1:-""} ]]; then
            echo gh-ma: ERROR: --token-id missing token 1>&2
            gh_ma_help
            exit 1
        fi
        token_id="$1"
        shift
        ;;

    --is-ma)
        # Simply return true (0), for use by scripts
        exit 0
        ;;

    *)
        ;;
esac

###############################################################################
# Get down to it

# Bash file descriptor redirection, so we don't have to do "done < $conf"
# at the end of the while loop.  Also makes for a cleaner test of read
# failure.
FD=""
exec {FD}<"$conf_file"

if [[ -z "${FD}" ]]; then
    echo gh-ma: ERROR: could not read \"$conf_file\" 1>&2
    gh_ma_help
    exit 1
fi

declare -A tokens_arr
while IFS=$': \t' read -u ${FD} id tok ; do
    # Ignore empty lines and comments
    if [[ -z "$id" || "$id" =~ ^# ]]; then
        continue
    fi
    if [[ -z "$tok" ]]; then
        tok="none"
    fi
    tokens_arr["$id"]="$tok"
done

exec {FD}<&- # close file

id_arr=("${!tokens_arr[@]}")
if [[ ${#id_arr[@]} -eq 0 ]]; then
    echo gh-ma: ERROR: \"$conf_file\" has no tokens 1>&2
    exit 1
fi

remote_url=$(git config remote.origin.url)
if [[ -n "$token_id" ]]; then
    : # token id already set via the command line option
elif [[ -n "$remote_url" ]]; then
    # Get id in the form of "host/account/repo" from
    # "https://host/account/repo.git" or "host:account/repo"
    # from "git@host:account/repo.git"
    repo_id=${remote_url#https://}
    repo_id=${repo_id##*@}
    repo_id=${repo_id%.git}

    # Split into parts
    OLD_IFS="$IFS"
    IFS=':/' id_parts=($repo_id)
    IFS="$OLD_IFS"

    if [[ ${#id_parts[@]} -ne 3 ]]; then
        echo gh-ma: ERROR: unable to parse remote url \"$remote_url\" 1>&2
        gh_ma_help
        exit 1
    fi

    # Possible token ids, from most specific to least specific
    possible_ids=(
        "${id_parts[0]}/${id_parts[1]}/${id_parts[2]}"
        "${id_parts[0]}/${id_parts[1]}"
        "${id_parts[0]}"
    )

    for id in ${possible_ids[@]}; do
        if [[ -n ${tokens_arr[$id]+unset} ]]; then
            token_id="$id"
            break
        fi
    done

    if [[ -z "$token_id" ]]; then
        echo gh-ma: ERROR: no matching token id for \"$remote_url\" 1>&2
        gh_ma_help
        exit 1
    fi
else
    if [[ -n "${GH_DEFAULT_TOKEN_ID+unset}" ]]; then
        token_id="${GH_DEFAULT_TOKEN_ID}"
    else
        if [[ -r "$conf_dir/default-token-id.sh" ]]; then
            source "$conf_dir/default-token-id.sh"
        fi
        if [[ -z "$token_id" && -r "$conf_dir/default-token-id" ]]; then
            read token_id < "$conf_dir/default-token-id" 
        fi
    fi

    if [[ -z "$token_id" ]]; then
        echo gh-ma: ERROR: no default token id 1>&2
        gh_ma_help
        exit 1
    fi
fi

token="${tokens_arr[$token_id]:-""}"

if [[ -z "$token" ]]; then
    echo gh-ma: ERROR: token id $token_id not present in tokens.conf 1>&2
    gh_ma_help
    exit 1
fi

if [[ "$token" == "none" ]]; then
    # User wants to specifically log in for this.
    exec $gh_exe "$@"
fi

export GH_TOKEN="$token"
export GH_ENTERPRISE_TOKEN="$token"

exec "$gh_exe" "$@"