unlimitedcoding/codex/ucodex_install.sh

#!/usr/bin/env bash
# UnlimitedCoding — Codex CLI Installer
# Downloads Codex binary from GitHub + applies config patches
#
# Usage:
#   curl -fsSL -H "Authorization: token TOKEN" \
#     https://git.sensey24.ru/aibot777/unlimitedcoding/raw/branch/master/codex/ucodex_install.sh \
#     -o /tmp/ucodex_install.sh && sudo bash /tmp/ucodex_install.sh
set -euo pipefail

GITEA_TOKEN="${GITEA_TOKEN:-cadffcb0a6a3be728ac1ff619bb40c86588f6837}"
REPO_RAW="https://git.sensey24.ru/aibot777/unlimitedcoding/raw/branch/master/codex"
GITHUB_API="https://api.github.com/repos/openai/codex/releases/latest"

RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
CYAN='\033[0;36m'
BOLD='\033[1m'
NC='\033[0m'

log()  { echo -e "${GREEN}[+]${NC} $*"; }
err()  { echo -e "${RED}[!]${NC} $*" >&2; }
info() { echo -e "${CYAN}[i]${NC} $*"; }
warn() { echo -e "${YELLOW}[~]${NC} $*"; }

echo -e "${BOLD}"
echo "  +--------------------------------------+"
echo "  |    Codex CLI — Installer             |"
echo "  +--------------------------------------+"
echo -e "${NC}"

# ---- Check prerequisites ----

for cmd in python3 curl tar; do
    if ! command -v "$cmd" &>/dev/null; then
        err "$cmd is required but not found"
        exit 1
    fi
done

PY_VER=$(python3 -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')")
PY_MAJOR=$(echo "$PY_VER" | cut -d. -f1)
PY_MINOR=$(echo "$PY_VER" | cut -d. -f2)
if [ "$PY_MAJOR" -lt 3 ] || ([ "$PY_MAJOR" -eq 3 ] && [ "$PY_MINOR" -lt 11 ]); then
    err "Python 3.11+ required (found $PY_VER)"
    exit 1
fi
log "Python3 $PY_VER"

# ---- Step 1: Install Codex binary from GitHub ----

echo -e "\n${BOLD}Step 1: Installing Codex CLI binary...${NC}"

ARCH=$(uname -m)
case "$ARCH" in
    x86_64)  BINARY_SUFFIX="x86_64-unknown-linux-musl" ;;
    aarch64|arm64) BINARY_SUFFIX="aarch64-unknown-linux-musl" ;;
    *) err "Unsupported architecture: $ARCH"; exit 1 ;;
esac

LATEST_VER=$(curl -s "$GITHUB_API" | grep -oP '"tag_name":\s*"rust-v\K[0-9]+\.[0-9]+\.[0-9]+' | head -1)
if [ -z "$LATEST_VER" ]; then
    err "Could not fetch latest version from GitHub"
    exit 1
fi
info "Latest version: $LATEST_VER ($BINARY_SUFFIX)"

OLD_VER="not installed"
if command -v codex &>/dev/null; then
    OLD_VER=$(codex --version 2>/dev/null | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -1 || echo "unknown")
    info "Current version: $OLD_VER"
fi

if [ "$OLD_VER" = "$LATEST_VER" ]; then
    log "Already up to date ($LATEST_VER)"
else
    DOWNLOAD_URL="https://github.com/openai/codex/releases/download/rust-v${LATEST_VER}/codex-${BINARY_SUFFIX}.tar.gz"
    TEMP_BIN=$(mktemp -d)

    info "Downloading codex v${LATEST_VER}..."
    curl -L -# -o "$TEMP_BIN/codex.tar.gz" "$DOWNLOAD_URL"
    tar -xzf "$TEMP_BIN/codex.tar.gz" -C "$TEMP_BIN"

    BINARY_FILE=$(find "$TEMP_BIN" -maxdepth 1 -name 'codex*' -type f ! -name '*.gz' | head -1)
    if [ -z "$BINARY_FILE" ]; then
        err "Binary not found in archive"
        rm -rf "$TEMP_BIN"
        exit 1
    fi

    pkill -9 -x "codex" 2>/dev/null || true
    CODEX_PATH=$(which codex 2>/dev/null || echo "/usr/local/bin/codex")
    chmod +x "$BINARY_FILE"
    mv -f "$BINARY_FILE" "$CODEX_PATH"
    rm -rf "$TEMP_BIN"
    hash -r 2>/dev/null || true

    NEW_VER=$(codex --version 2>/dev/null | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -1 || echo "unknown")
    log "Binary installed: $OLD_VER → $NEW_VER"
fi

# ---- Step 2: Download and apply patches ----

echo -e "\n${BOLD}Step 2: Applying config patches...${NC}"

INSTALL_DIR=$(mktemp -d)
cleanup() { rm -rf "$INSTALL_DIR" 2>/dev/null || true; }
trap cleanup EXIT

info "Downloading patcher..."
curl -fsSL -H "Authorization: token ${GITEA_TOKEN}" "$REPO_RAW/codex_patcher.py"  -o "$INSTALL_DIR/codex_patcher.py"
curl -fsSL -H "Authorization: token ${GITEA_TOKEN}" "$REPO_RAW/codex_config.json" -o "$INSTALL_DIR/codex_config.json"

info "Applying patches..."
python3 "$INSTALL_DIR/codex_patcher.py" --apply --config "$INSTALL_DIR/codex_config.json"
log "Patches applied"

# ---- Step 3: Set env vars system-wide (all users, all sessions) ----

echo -e "\n${BOLD}Step 3: Setting environment variables...${NC}"

API_KEY=$(python3 -c "import json; print(json.load(open('$INSTALL_DIR/codex_config.json'))['api_key'])")
BASE_URL=$(python3 -c "import json; print(json.load(open('$INSTALL_DIR/codex_config.json'))['base_url'])")

# Write to /etc/environment (all users, all sessions including cron)
ETC_ENV="/etc/environment"
for kv in "OPENAI_API_KEY=\"$API_KEY\"" "OPENAI_BASE_URL=\"${BASE_URL}/v1\""; do
    KEY="${kv%%=*}"
    if grep -q "^${KEY}=" "$ETC_ENV" 2>/dev/null; then
        sed -i "s|^${KEY}=.*|${kv}|" "$ETC_ENV"
    else
        echo "$kv" >> "$ETC_ENV"
    fi
done
log "Env vars written to $ETC_ENV (all users)"

# Write to /etc/profile.d/ for export in login shells
cat > /etc/profile.d/codex-env.sh << ENVEOF
export OPENAI_API_KEY="$API_KEY"
export OPENAI_BASE_URL="${BASE_URL}/v1"
ENVEOF
chmod 644 /etc/profile.d/codex-env.sh
log "Export script created: /etc/profile.d/codex-env.sh"

# Export for current session
export OPENAI_API_KEY="$API_KEY"
export OPENAI_BASE_URL="${BASE_URL}/v1"

# ---- Step 4: Verify ----

echo -e "\n${BOLD}Step 4: Verifying...${NC}"

if command -v codex &>/dev/null; then
    VER=$(codex --version 2>/dev/null | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -1 || echo "unknown")
    log "Codex CLI v$VER"
else
    err "codex binary not found in PATH"
    exit 1
fi

echo ""
echo -e "${GREEN}${BOLD}=== Installation complete! ===${NC}"
echo -e "Run: ${CYAN}codex${NC} to start"
echo -e "${YELLOW}Note: Env vars are set system-wide. New shells pick them up automatically.${NC}"
echo -e "${YELLOW}For current shell: source /etc/profile.d/codex-env.sh${NC}"