089f6e0be5
Patcher uses `which codex` to find binary. After migrating codex -> .codex-bin, wrapper must exist before Step 2 (patcher) or patcher fails with "Codex CLI not found". Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
210 lines
6.7 KiB
Bash
Executable File
210 lines
6.7 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# UnlimitedCoding — Codex CLI Installer
|
|
# Downloads Codex binary from GitHub + applies config patches
|
|
# Uses wrapper script so env vars work immediately in any shell.
|
|
#
|
|
# 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"
|
|
|
|
CODEX_BIN="/usr/local/bin/.codex-bin"
|
|
CODEX_WRAPPER="/usr/local/bin/codex"
|
|
ENV_FILE="/etc/profile.d/codex-env.sh"
|
|
|
|
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 ----
|
|
|
|
install_pkg() {
|
|
if command -v apt-get >/dev/null 2>&1; then
|
|
apt-get update -qq && apt-get install -y -qq "$@"
|
|
elif command -v dnf >/dev/null 2>&1; then
|
|
dnf install -y -q "$@"
|
|
elif command -v yum >/dev/null 2>&1; then
|
|
yum install -y -q "$@"
|
|
elif command -v brew >/dev/null 2>&1; then
|
|
brew install "$@"
|
|
else
|
|
err "No package manager found. Install $* manually."
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
if ! command -v python3 &>/dev/null; then
|
|
info "python3 not found, installing..."
|
|
install_pkg python3
|
|
fi
|
|
|
|
for cmd in curl tar; do
|
|
if ! command -v "$cmd" &>/dev/null; then
|
|
err "$cmd is required but not found"
|
|
exit 1
|
|
fi
|
|
done
|
|
|
|
log "Python3 $(python3 --version | awk '{print $2}')"
|
|
|
|
# ---- 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)"
|
|
|
|
# Migrate: if old codex is a real binary (not our wrapper), move it
|
|
if [ -f "$CODEX_WRAPPER" ] && file "$CODEX_WRAPPER" | grep -q "ELF"; then
|
|
info "Migrating existing binary to $CODEX_BIN..."
|
|
mv -f "$CODEX_WRAPPER" "$CODEX_BIN"
|
|
fi
|
|
|
|
# Get current version (from real binary)
|
|
OLD_VER="not installed"
|
|
if [ -f "$CODEX_BIN" ]; then
|
|
OLD_VER=$("$CODEX_BIN" --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
|
|
chmod +x "$BINARY_FILE"
|
|
mv -f "$BINARY_FILE" "$CODEX_BIN"
|
|
rm -rf "$TEMP_BIN"
|
|
hash -r 2>/dev/null || true
|
|
|
|
NEW_VER=$("$CODEX_BIN" --version 2>/dev/null | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -1 || echo "unknown")
|
|
log "Binary installed: $OLD_VER -> $NEW_VER"
|
|
fi
|
|
|
|
# Create temporary wrapper so patcher can find codex via `which codex`
|
|
if [ -f "$CODEX_BIN" ] && { [ ! -f "$CODEX_WRAPPER" ] || file "$CODEX_WRAPPER" | grep -q "ELF"; }; then
|
|
cat > "$CODEX_WRAPPER" << 'TWEOF'
|
|
#!/usr/bin/env bash
|
|
exec /usr/local/bin/.codex-bin "$@"
|
|
TWEOF
|
|
chmod +x "$CODEX_WRAPPER"
|
|
hash -r 2>/dev/null || true
|
|
info "Temporary wrapper created"
|
|
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 ----
|
|
|
|
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'])")
|
|
|
|
# /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"
|
|
|
|
# /etc/profile.d/ (login shells)
|
|
cat > "$ENV_FILE" << ENVEOF
|
|
export OPENAI_API_KEY="$API_KEY"
|
|
export OPENAI_BASE_URL="${BASE_URL}/v1"
|
|
ENVEOF
|
|
chmod 644 "$ENV_FILE"
|
|
log "Env file: $ENV_FILE"
|
|
|
|
# ---- Step 4: Create wrapper (auto-loads env) ----
|
|
|
|
echo -e "\n${BOLD}Step 4: Creating wrapper...${NC}"
|
|
|
|
cat > "$CODEX_WRAPPER" << 'WRAPPER_EOF'
|
|
#!/usr/bin/env bash
|
|
# Auto-generated wrapper — loads env vars before running codex binary
|
|
[ -f /etc/profile.d/codex-env.sh ] && . /etc/profile.d/codex-env.sh
|
|
exec /usr/local/bin/.codex-bin "$@"
|
|
WRAPPER_EOF
|
|
chmod +x "$CODEX_WRAPPER"
|
|
log "Wrapper: $CODEX_WRAPPER -> $CODEX_BIN"
|
|
|
|
# ---- Step 5: Verify ----
|
|
|
|
echo -e "\n${BOLD}Step 5: Verifying...${NC}"
|
|
|
|
if codex --version &>/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 (wrapper OK)"
|
|
else
|
|
err "codex wrapper not working"
|
|
exit 1
|
|
fi
|
|
|
|
echo ""
|
|
echo -e "${GREEN}${BOLD}=== Installation complete! ===${NC}"
|
|
echo -e "Run: ${CYAN}codex${NC} to start"
|
|
echo -e "${YELLOW}Env vars auto-loaded by wrapper. Works in any shell immediately.${NC}"
|