AutoGen Assistant Runner

run.sh

#!/bin/bash -i

# This script runs autogenra UI easily with a folder.  Simply create the folder, drop this script into it, and run.
#
# Notice:  Because this script adds groups to your user, for anaconda, python, and node, you'll need to re-run it a few times.
#          The process isn't fully automated due to a restriction with newgrp command spawning a subshell.

# Put your OPENAI API key here.
export OPENAI_API_KEY="your_api_key_here"

SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
PYTHON_VERSION="3.10.13"
NODE_VERSION="lts/iron"

# @name exit_program
# @brief Trap for exiting the program gracefully
# @description This is an exit trap for exiting the program gracefully.  For example, if the user presses ctrl+c.
function exit_program() {
    cd "${SCRIPT_DIR}"
    __manage_nvm deactivate version="${NODE_VERSION}"
    __manage_conda deactivate environment="autogenra"
    __manage_pyenv deactivate version="${PYTHON_VERSION}"
    exit 1
}
trap exit_program EXIT

# @name __safe_cmd
# @brief Executes a command and exits if it fails
# @description Executes a command and exits if it fails
# @arg $1 string cmd: command to execute
function __safe_cmd() {
    local cmd="$*"
    $cmd
    local status=$?
    if [ $status -ne 0 ]; then
        echo "Command exited with status: $status"
        exit 1
    fi
}

# @name __manage_pyenv
# @brief Manages pyenv installation and activation
# @description Manages pyenv installation and activation automatically
# @arg $1 string action: install, uninstall, activate, deactivate
# @arg $2 string cmd: arguments to parse for version
function __manage_pyenv() {
    local action="$1"
    shift 1
    local cmd="$*"

    MY_PYTHON_VERSION=$(echo "$cmd" | grep -oP "(?<=version=)[0-9\.]+" | grep -oP "[0-9\.]+")

    case "$action" in
        "install")
            if [[ -n $MY_PYTHON_VERSION ]]; then
                if ! pyenv versions | grep -q "${MY_PYTHON_VERSION}"; then
                    echo "Installing python ${MY_PYTHON_VERSION}"
                    __safe_cmd "pyenv install ${MY_PYTHON_VERSION}"
                else
                    echo "Python ${MY_PYTHON_VERSION} already installed"
                fi
                return 0
            fi
            if ! grep -q "python" /etc/group; then
                echo "Adding python group"
                __safe_cmd sudo groupadd python
            fi
            if ! groups | grep -q "python"; then
                echo "Adding user to python group"
                __safe_cmd sudo usermod -a -G python $USER
                newgrp python
            fi
            if [[ ! -d /usr/local/pyenv ]] && ! command pyenv versions &>/dev/null; then
                echo "Installing pyenv"
                __safe_cmd git clone 'https://github.com/pyenv/pyenv.git' /usr/local/pyenv
                __safe_cmd sudo chown -R root:python /usr/local/pyenv
                __safe_cmd sudo chmod -R 770 /usr/local/pyenv
                pushd /usr/local/pyenv || exit
                __safe_cmd "src/configure && make -C src"
                popd || exit
            fi
            if ! echo "$PYENV_ROOT/bin" | grep -q "$PATH"; then
                export PATH="$PYENV_ROOT/bin:$PATH"
            fi
            eval "$(pyenv init --path)"
            eval "$(pyenv init -)"
            . "$HOME/.bashrc"
            ;;
        "uninstall")
            if [[ -n $MY_PYTHON_VERSION ]]; then
                __manage_pyenv deactivate $cmd
                if pyenv versions | grep -q "${MY_PYTHON_VERSION}"; then
                    echo "Removing python ${MY_PYTHON_VERSION}"
                    __safe_cmd "pyenv uninstall ${MY_PYTHON_VERSION}"
                fi
                return 0
            fi

            if grep -q "pyenv init" ~/.bashrc; then
                echo "Removing pyenv init from bashrc"
                # shellcheck disable=SC2001
                new_bashrc=$(cat ~/.bashrc | sed -e "s#eval \"\$(pyenv init -)\"##g")
                echo "$new_bashrc" > ~/.bashrc
                . "$HOME/.bashrc"
            fi
            if echo "$PYENV_ROOT/bin" | grep -q "$PATH"; then
                # shellcheck disable=SC2001
                new_path=$(echo "$PATH" | sed -e "s#$PYENV_ROOT/bin:##g")
                export PATH="$new_path"
            fi
            if groups | grep -q "python"; then
                echo "Removing user from python group"
                __safe_cmd sudo gpasswd -d $USER python
            fi
            if grep -q "python" /etc/group; then
                echo "Removing python group"
                __safe_cmd sudo groupdel python
            fi
            if [[ -d /usr/local/pyenv ]]; then
                echo "Removing pyenv"
                __safe_cmd sudo rm -rf /usr/local/pyenv
            fi
            ;;
        "activate")
            if [[ -z $MY_PYTHON_VERSION ]]; then
                echo "No python version specified"
                return 0
            fi
            if ! python version 2>&1 | grep -q "${MY_PYTHON_VERSION}"; then
                echo "Activating python ${MY_PYTHON_VERSION}"
                __safe_cmd "pyenv local ${MY_PYTHON_VERSION}"
            else
                echo "Python ${MY_PYTHON_VERSION} already activated"
                return 0
            fi
            ;;
        "deactivate")
            if [[ -z $MY_PYTHON_VERSION ]]; then
                echo "No python version specified"
                return 0
            fi
            echo "Deactivating python ${MY_PYTHON_VERSION}"
            __safe_cmd pyenv local system
            ;;
        *)
            echo "Unknown action: $action"
            exit 1
            ;;
    esac
}

# @name __manage_conda
# @brief Manages conda installation and activation
# @description Manages conda installation and activation automatically
# @arg $1 string action: install, uninstall, activate, deactivate
# @arg $2 string cmd: arguments to parse for environment
function __manage_conda() {
    local action="$1"
    shift 1
    local cmd="$*"

    local MY_CONDA_ENV
    MY_CONDA_ENV=$(echo "$cmd" | grep -oP "(?<=environment=)[0-9\.a-zA-Z\\/\_]+" | grep -oP "[0-9\.a-zA-Z\\/\_]+")
    local MY_CONDA_ENV_PATH
    MY_CONDA_ENV_PATH="${SCRIPT_DIR}/.conda/${MY_CONDA_ENV}"

    case "$action" in
        "install")
            if [[ -n $MY_CONDA_ENV ]]; then
                if ! conda env list | grep -q "${MY_CONDA_ENV_PATH}"; then
                    local ENVIRONMENT_YML
                    ENVIRONMENT_YML=$(find "${SCRIPT_DIR}" -name "*.yml" -exec grep -l "name: ${MY_CONDA_ENV}" {} \; | head -n 1)
                    if [[ -n $ENVIRONMENT_YML ]]; then
                        echo "Creating conda environment ${MY_CONDA_ENV}"
                        __safe_cmd conda env create -f "${ENVIRONMENT_YML}" -p "${MY_CONDA_ENV_PATH}"
                        return 0
                    else
                        echo "No environment.yml file found for ${MY_CONDA_ENV}"
                        return 1
                    fi
                else
                    echo "Conda environment ${MY_CONDA_ENV} already installed"
                fi
                return 0
            fi
            if ! grep -q "python" /etc/group; then
                echo "Adding python group"
                __safe_cmd sudo groupadd python
            fi
            if ! groups | grep -q "python"; then
                echo "Adding user to python group"
                __safe_cmd sudo usermod -a -G python $USER
            fi
            if ! conda --version &>/dev/null || [[ ! -d /usr/local/anaconda3 ]]; then
                echo "Installing Anaconda3"
                __safe_cmd wget https://repo.anaconda.com/archive/Anaconda3-2023.09-0-Linux-x86_64.sh
                __safe_cmd chmod +x Anaconda3-2023.09-0-Linux-x86_64.sh
                __safe_cmd sudo bash Anaconda3-2023.09-0-Linux-x86_64.sh -b -p /user/local/anaconda3
                __safe_cmd rm Anaconda3-2023.09-0-Linux-x86_64.sh
                __safe_cmd sudo chown -R root:python /usr/local/anaconda3
                __safe_cmd sudo chmod -R 770 /usr/local/anaconda3
                if ! grep -q "conda init" ~/.bashrc; then
                    echo "Adding conda init to bashrc"
                    __safe_cmd echo "/usr/local/anaconda3/bin/conda init -path" >> ~/.bashrc
                fi
                echo "Anaconda3 installed, please restart your terminal"
                exit 0
            fi
            ;;
        "uninstall")
            if [[ -n $MY_CONDA_ENV ]]; then
                __manage_conda deactivate $cmd
                if conda env list | grep -q "${MY_CONDA_ENV_PATH}"; then
                    echo "Removing conda environment ${MY_CONDA_ENV}"
                    __safe_cmd conda env remove -p "${MY_CONDA_ENV_PATH}"
                fi
                return 0
            fi
            # Remove conda from bashrc
            if grep -q "conda activate" ~/.bashrc; then
                echo "Removing conda init from bashrc"
                # shellcheck disable=SC2001
                new_bashrc=$(cat ~/.bashrc | sed -e "s#conda init -path##g")
                echo "$new_bashrc" > ~/.bashrc
                . "$HOME/.bashrc"
            fi
            if echo $PATH | grep -q "/usr/local/anaconda3/bin"; then
                # shellcheck disable=SC2001
                new_path=$(echo "$PATH" | sed -e "s#/usr/local/anaconda3/bin:##g")
                export PATH="$new_path"
            fi
            if [[ -d /usr/local/anaconda3 ]]; then
                echo "Removing Anaconda3"
                __safe_cmd sudo rm -rf /usr/local/anaconda3
            fi
            if groups | grep -q "python"; then
                echo "Removing user from python group"
                __safe_cmd sudo gpasswd -d $USER python
            fi
            if grep -q "python" /etc/group; then
                echo "Removing python group"
                __safe_cmd sudo groupdel python
            fi
            ;;
        "activate")
            if [[ -z $MY_CONDA_ENV ]]; then
                echo "No conda environment specified"
                return 0
            fi
            eval "$(conda shell.bash hook)"
            if ! conda env list | grep -q "${MY_CONDA_ENV_PATH}"; then
                echo "Local conda environment not installed"
                return 0
            fi
            if ! conda activate "${MY_CONDA_ENV_PATH}"; then
                echo "Activating local conda environment"
                __safe_cmd conda activate "${MY_CONDA_ENV_PATH}"
            else
                echo "Local conda environment already activated"
            fi
            return 0
            ;;
        "deactivate")
            if [[ -z $MY_CONDA_ENV ]]; then
                echo "No conda environment specified"
                return 0
            fi
            eval "$(conda shell.bash hook)"
            if ! conda env list | grep -q "${MY_CONDA_ENV_PATH}"; then
                echo "Local conda environment not installed"
                return 0
            fi
            echo "Deactivating local conda environment"
            __safe_cmd conda deactivate
            ;;
        *)
            echo "Unknown action: $action"
            exit 1
            ;;
    esac
}

# @name __manage_nvm
# @brief Manages nvm installation and activation
# @description Manages nvm installation and activation automatically
# @arg $1 string action: install, uninstall, activate, deactivate
# @arg $2 string cmd: arguments to parse for version
function __manage_nvm() {
    local action="$1"
    shift 1
    local cmd="$*"

    local MY_NODE_VERSION
    MY_NODE_VERSION=$(echo "$cmd" | grep -oP "(?<=version=)[0-9\.a-zA-Z\/]+" | grep -oP "[0-9\.a-zA-Z\/]+")

    case "$action" in
        "install")
            if [[ -n $MY_NODE_VERSION ]]; then
                if ! nvm ls | grep -q "${MY_NODE_VERSION}"; then
                    echo "Installing node ${MY_NODE_VERSION}"
                    __safe_cmd "nvm install ${MY_NODE_VERSION}"
                else
                    echo "Node ${MY_NODE_VERSION} already installed"
                fi
                return 0
            fi
            if ! grep -q "node" /etc/group; then
                echo "Adding node group"
                __safe_cmd sudo groupadd node
            fi
            if ! groups | grep -q "node"; then
                echo "Adding user to node group"
                __safe_cmd sudo usermod -aG node $USER
            fi
            export NVM_DIR="/usr/local/nvm"
            if ! nvm --version &>/dev/null; then
                echo "Installing nvm"
                if [[ ! -d /usr/local/nvm ]]; then
                    __safe_cmd sudo mkdir -p /usr/local/nvm
                fi
                sudo PROFILE=/dev/null NVM_DIR="/usr/local/nvm" bash -c 'curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/master/install.sh | bash'
                __safe_cmd sudo chown -R root:node ${NVM_DIR}
                __safe_cmd sudo chmod -R 770 ${NVM_DIR}
                if ! grep -q "# >>> nvm init >>>" ~/.bashrc && ! grep -q "# >>> nvm init >>>" ~/.bashrc; then
                    echo "Adding nvm init to bashrc"
                    { 
                        echo "# >>> nvm init >>>"
                        echo "export NVM_DIR=\"/usr/local/nvm\""
                        echo "[ -s \"\$NVM_DIR/nvm.sh\" ] && . \"\$NVM_DIR/nvm.sh\""
                        echo "[ -s \"\$NVM_DIR/bash_completion\" ] && . \"\$NVM_DIR/bash_completion\""
                        echo "# <<< nvm init <<<"
                    } >> ~/.bashrc
                fi 
                source "$HOME/.bashrc"
                echo "Node version ${NODE_VERSION} installed, please restart your terminal"
                exit 0
            fi
            ;;
        "uninstall")
            if [[ -n $MY_NODE_VERSION ]]; then
                __manage_nvm deactivate $cmd
                if nvm ls | grep -q "${MY_NODE_VERSION}"; then
                    echo "Removing node ${MY_NODE_VERSION}"
                    __safe_cmd "nvm uninstall ${MY_NODE_VERSION}"
                fi
                return 0
            fi
            if grep -q "# >>> nvm init >>>" ~/.bashrc && grep -q "# >>> nvm init >>>" ~/.bashrc; then
                echo "Removing nvm from bashrc"
                sed -i '/# >>> nvm init >>>/,/# <<< nvm init <<<//d' "$HOME/.bashrc"
                source "$HOME/.bashrc"
            fi
            if [[ -d /usr/local/nvm ]]; then
                echo "Removing nvm installation directory."
                __safe_cmd sudo rm -rf /usr/local/nvm
            fi
            if groups | grep -q "node"; then
                echo "Removing user from node group"
                __safe_cmd sudo gpasswd -d $USER node
            fi
            if grep -q "node" /etc/group; then
                echo "Removing node group"
                __safe_cmd sudo groupdel node
            fi
            ;;
        "activate")
            if [[ -z $MY_NODE_VERSION ]]; then
                echo "No node version specified"
                return 0
            fi
            if ! nvm ls | grep -q "${MY_NODE_VERSION}"; then
                echo "Activating node ${MY_NODE_VERSION}"
                __safe_cmd "nvm use ${MY_NODE_VERSION}"
            else
                echo "Node ${MY_NODE_VERSION} already activated"
                return 0
            fi
            ;;
        "deactivate")
            if [[ -z $MY_NODE_VERSION ]]; then
                echo "No node version specified"
                return 0
            fi
            echo "Deactivating node ${MY_NODE_VERSION}"
            __safe_cmd nvm deactivate
            ;;
        *)
            echo "Unknown action: $action"
            exit 1
            ;;
    esac
}

# If repo is not cloned, clone it
if [[ ! -d ${SCRIPT_DIR}/AutoGen ]]; then
    echo "Cloning repo"
    __safe_cmd "git clone 'https://github.com/microsoft/autogen.git' --recursive ${SCRIPT_DIR}/AutoGen"
fi

pushd "${SCRIPT_DIR}/AutoGen"

__manage_pyenv install
__manage_pyenv install version="${PYTHON_VERSION}"
__manage_pyenv activate version="${PYTHON_VERSION}"

__manage_conda install
cat <<EOF > "${SCRIPT_DIR}/environment.yml"
name: autogenra
channels:
  - defaults
  - conda-forge
  - microsoft
dependencies:
  - bzip2
  - ca-certificates
  - libffi
  - libgcc-ng
  - libgomp
  - libstdcxx-ng
  - libuuid=1.41.5
  - ncurses=6.4
  - openssl
  - pip
  - python=3.10.13
  - readline
  - setuptools
  - sqlite
  - tk
  - tzdata
  - wheel
  - xz
  - zlib
EOF
__manage_conda install environment="autogenra"
__manage_conda activate environment="autogenra"

echo "Installing autogenra"
__safe_cmd pip install -e .[samples]

__manage_nvm install
__manage_nvm install version="${NODE_VERSION}"
__manage_nvm activate version="${NODE_VERSION}"

pushd "samples/apps/autogen-assistant/frontend"

# If yarn is not installed, install it
if ! which yarn | grep -q "yarn"; then
    echo "Installing yarn"
    __safe_cmd npm install -g yarn
fi

# if gatsby-cli is not installed, install it
if ! which gatsby | grep -q "gatsby"; then
    echo "Installing gatsby-cli"
    __safe_cmd npm install -g gatsby-cli
fi

echo "Installing frontend dependencies..."
__safe_cmd yarn install

echo "Building frontend..."
__safe_cmd yarn build

popd

pushd "samples/apps/autogen-assistant"

echo "Installing backend dependencies..."
__safe_cmd pip install -e .

autogenra ui --port 6968

popd
popd