webcoder

#!/bin/bash

# webcoder - VS Code Server Setup Script
# This script downloads VS Code CLI, installs nginx, and sets up a reverse proxy

set -e

# Default values
PORT=8000
DOMAIN=""
SECURE=false

# Get real user info early (before we use sudo)
get_real_user_info() {
    if [[ -n "$SUDO_USER" ]]; then
        REAL_USER="$SUDO_USER"
        REAL_HOME=$(getent passwd "$REAL_USER" | cut -d: -f6)
    else
        REAL_USER="$USER"
        REAL_HOME="$HOME"
    fi
}

# Initialize user info
get_real_user_info

# Generate or read authentication token
TOKEN_FILE="$REAL_HOME/.vscode/cli/token"
if [[ ! -s "$TOKEN_FILE" ]]; then
    TOKEN=$(head -c 32 /dev/urandom | base64 | tr -d '/+=' | cut -c1-64)
    mkdir -p "$(dirname "$TOKEN_FILE")"
    echo "$TOKEN" > "$TOKEN_FILE"
else
    TOKEN=$(cat "$TOKEN_FILE")
fi

VSCODE_CLI_DIR="$REAL_HOME/.vscode/cli"
VSCODE_CLI_BIN="$VSCODE_CLI_DIR/code"

# Color codes for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# Print functions
print_info() {
    echo -e "${GREEN}[INFO]${NC} $1"
}

print_warn() {
    echo -e "${YELLOW}[WARN]${NC} $1"
}

print_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# Usage function
usage() {
    cat << EOF
Usage: $0 [OPTIONS]

VS Code Server Setup Script - Downloads VS Code CLI, installs nginx, and sets up reverse proxy

OPTIONS:
    -p, --port PORT          Port for VS Code server to listen on (default: 8000)
    -d, --domain DOMAIN      Domain name for nginx (default: use server IP)
    -s, --secure             Enable HTTPS with certbot (default: false)
    -h, --help               Display this help message

EXAMPLES:
    $0                                    # Use defaults (port 8000, no domain, no SSL)
    $0 -p 9000                            # Use port 9000
    $0 -p 8000 -d example.com             # Use domain example.com
    $0 -p 8000 -d example.com -s          # Use domain with SSL/TLS

EOF
}

# Parse command line arguments
parse_args() {
    while [[ $# -gt 0 ]]; do
        case $1 in
            -p|--port)
                # Validate port: must be numeric and in range 1-65535
                if ! [[ "$2" =~ ^[0-9]+$ ]] || [ "$2" -lt 1 ] || [ "$2" -gt 65535 ]; then
                    print_error "Invalid port: $2. Must be an integer between 1 and 65535."
                    exit 1
                fi
                PORT="$2"
                shift 2
                ;;
            -d|--domain)
                DOMAIN="$2"
                shift 2
                ;;
            -s|--secure)
                SECURE=true
                shift
                ;;
            -h|--help)
                usage
                exit 0
                ;;
            *)
                print_error "Unknown option: $1"
                usage
                exit 1
                ;;
        esac
    done
}

# Check if running as root/sudo
check_sudo() {
    if [[ $EUID -ne 0 ]]; then
        print_error "This script requires root privileges. Please run with sudo."
        exit 1
    fi
}

# Detect OS and architecture
detect_system() {
    OS=$(uname -s | tr '[:upper:]' '[:lower:]')
    ARCH=$(uname -m)

    case $ARCH in
        x86_64)
            ARCH="x64"
            ;;
        aarch64|arm64)
            ARCH="arm64"
            ;;
        armv7l)
            ARCH="armhf"
            ;;
        *)
            print_error "Unsupported architecture: $ARCH"
            exit 1
            ;;
    esac

    case $OS in
        linux)
            OS="alpine"
            ;;
        darwin)
            OS="darwin"
            ;;
        *)
            print_error "Unsupported OS: $OS"
            exit 1
            ;;
    esac

    print_info "Detected system: $OS-$ARCH"
}

# Download and install VS Code CLI
install_vscode_cli() {
    print_info "Checking VS Code CLI installation..."

    if [[ -f "$VSCODE_CLI_BIN" ]]; then
        print_info "VS Code CLI already installed at $VSCODE_CLI_BIN"
        return 0
    fi

    print_info "Downloading VS Code CLI..."
    mkdir -p "$VSCODE_CLI_DIR"

    # Download URL for VS Code CLI
    # Such as https://code.visualstudio.com/sha/download?build=stable&os=cli-alpine-x64
    VSCODE_URL="https://code.visualstudio.com/sha/download?build=stable&os=cli-${OS}-${ARCH}"

    print_info "Downloading from: $VSCODE_URL"

    # Download to temporary file
    TMP_FILE=$(mktemp)
    if ! curl -f -L --connect-timeout 30 --max-time 300 "$VSCODE_URL" -o "$TMP_FILE"; then
        print_error "Failed to download VS Code CLI"
        rm -f "$TMP_FILE"
        exit 1
    fi

    # Extract the CLI
    print_info "Extracting VS Code CLI..."
    if file "$TMP_FILE" | grep -q "gzip compressed"; then
        tar -xzf "$TMP_FILE" -C "$VSCODE_CLI_DIR"
    else
        # Try to extract as tar.gz anyway
        tar -xzf "$TMP_FILE" -C "$VSCODE_CLI_DIR" 2>/dev/null || {
            print_error "Failed to extract VS Code CLI"
            rm -f "$TMP_FILE"
            exit 1
        }
    fi

    rm -f "$TMP_FILE"

    # Make executable
    chmod +x "$VSCODE_CLI_BIN"

    print_info "VS Code CLI installed successfully at $VSCODE_CLI_BIN"
}

# Install nginx
install_nginx() {
    print_info "Checking nginx installation..."

    if command -v nginx &> /dev/null; then
        print_info "nginx is already installed"
        return 0
    fi

    print_info "Installing nginx..."

    # Detect package manager and install
    if command -v apt-get &> /dev/null; then
        apt-get update -qq
        apt-get install -y nginx
    elif command -v yum &> /dev/null; then
        yum install -y nginx
    elif command -v dnf &> /dev/null; then
        dnf install -y nginx
    elif command -v pacman &> /dev/null; then
        pacman -Sy --noconfirm nginx
    elif command -v brew &> /dev/null; then
        brew install nginx
    else
        print_error "Could not detect package manager. Please install nginx manually."
        exit 1
    fi

    print_info "nginx installed successfully"
}

# Get server IP
get_server_ip() {
    # Try to get public IP, fallback to local IP
    IP=$(curl -f -s --connect-timeout 10 --max-time 20 ifconfig.me 2>/dev/null || \
         curl -f -s --connect-timeout 10 --max-time 20 icanhazip.com 2>/dev/null || \
         hostname -I | awk '{print $1}')
    echo "$IP"
}

# Configure nginx
configure_nginx() {
    print_info "Configuring nginx..."

    # Determine server name
    if [[ -z "$DOMAIN" ]]; then
        SERVER_NAME=$(get_server_ip)
        print_info "Using IP address: $SERVER_NAME"
    else
        SERVER_NAME="$DOMAIN"
        print_info "Using domain: $SERVER_NAME"
    fi

    # Create nginx configuration
    NGINX_CONF="/etc/nginx/sites-available/vscode-server"

    # Create sites-available and sites-enabled directories if they don't exist
    mkdir -p /etc/nginx/sites-available
    mkdir -p /etc/nginx/sites-enabled

    cat > "$NGINX_CONF" << EOF
server {
    listen 80;
    server_name $SERVER_NAME;

    location / {
        if (\$http_cookie !~ "(^|;\\s*)tkn=$TOKEN(;|$)") {
            return 401;
        }
        proxy_pass http://127.0.0.1:$PORT;
        proxy_http_version 1.1;
        proxy_set_header Upgrade \$http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto \$scheme;
        proxy_read_timeout 86400;
    }
}
EOF

    # Enable the site
    ln -sf "$NGINX_CONF" /etc/nginx/sites-enabled/vscode-server

    # Test nginx configuration
    if ! nginx -t; then
        print_error "nginx configuration test failed"
        exit 1
    fi

    print_info "nginx configured successfully"

    # Reload nginx
    if ! systemctl reload nginx 2>/dev/null; then
        if ! service nginx reload 2>/dev/null; then
            if ! nginx -s reload; then
                print_error "Failed to reload nginx"
                exit 1
            fi
        fi
    fi

    print_info "nginx reloaded"
}

# Install and configure certbot
setup_certbot() {
    if [[ "$SECURE" != true ]]; then
        print_info "Skipping certbot setup (not requested)"
        return 0
    fi

    if [[ -z "$DOMAIN" ]]; then
        print_error "Cannot use certbot without a domain name. Please specify -d option."
        exit 1
    fi

    print_info "Installing certbot..."

    # Install certbot
    if command -v apt-get &> /dev/null; then
        apt-get update -qq
        apt-get install -y certbot python3-certbot-nginx
    elif command -v yum &> /dev/null; then
        yum install -y certbot python3-certbot-nginx
    elif command -v dnf &> /dev/null; then
        dnf install -y certbot python3-certbot-nginx
    elif command -v pacman &> /dev/null; then
        pacman -Sy --noconfirm certbot certbot-nginx
    else
        print_error "Could not detect package manager. Please install certbot manually."
        exit 1
    fi

    print_info "Running certbot to obtain SSL certificate..."
    print_warn "Make sure your domain $DOMAIN points to this server's IP address"

    # Prompt for email if not provided
    # read -p "Enter email address for Let's Encrypt notifications (press Enter to skip): " CERTBOT_EMAIL
    CERTBOT_EMAIL="webcoder@example.com"

    # Run certbot
    if [[ -n "$CERTBOT_EMAIL" ]]; then
        certbot --nginx -d "$DOMAIN" --non-interactive --agree-tos --email "$CERTBOT_EMAIL" || {
            print_error "Certbot configuration failed. Please ensure:"
            print_error "  1. Domain $DOMAIN points to this server"
            print_error "  2. Port 80 and 443 are open"
            print_error "  3. Email address is valid"
            exit 1
        }
    else
        print_warn "Proceeding without email (not recommended for production)"
        certbot --nginx -d "$DOMAIN" --non-interactive --agree-tos --register-unsafely-without-email || {
            print_error "Certbot configuration failed. Please ensure:"
            print_error "  1. Domain $DOMAIN points to this server"
            print_error "  2. Port 80 and 443 are open"
            exit 1
        }
    fi

    print_info "SSL certificate obtained and configured successfully"
}

# Create systemd service for VS Code server
create_vscode_service() {
    print_info "Creating systemd service for VS Code server..."

    print_info "VS Code server will use cookie-based authentication for security"

    # Create systemd service file
    cat > /etc/systemd/system/vscode-server.service << EOF
[Unit]
Description=VS Code Server
After=network.target

[Service]
Type=simple
User=$REAL_USER
WorkingDirectory=$REAL_HOME
Environment="HOME=$REAL_HOME"
ExecStart=$VSCODE_CLI_BIN serve-web --host 127.0.0.1 --port $PORT --without-connection-token --accept-server-license-terms
Restart=always
RestartSec=10
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
EOF

    print_info "Systemd service created at /etc/systemd/system/vscode-server.service"
}

# Start VS Code server
start_vscode_server() {
    print_info "Starting VS Code server..."

    # Create systemd service
    create_vscode_service

    # Reload systemd daemon
    systemctl daemon-reload

    # Enable service to start on boot
    systemctl enable vscode-server.service

    # Start the service
    if systemctl start vscode-server.service; then
        print_info "VS Code server started successfully"

        # Wait a moment for service to start
        sleep 3

        # Check status
        if systemctl is-active --quiet vscode-server.service; then
            print_info "VS Code server is running"
        else
            print_warn "VS Code server may not be running properly. Check with: systemctl status vscode-server.service"
        fi
    else
        print_error "Failed to start VS Code server"
        print_info "Check logs with: journalctl -u vscode-server.service -f"
        exit 1
    fi

    print_info ""
    print_info "VS Code server is accessible through nginx at:"

    if [[ "$SECURE" == true ]]; then
        print_info "  https://$DOMAIN"
    elif [[ -n "$DOMAIN" ]]; then
        print_info "  http://$DOMAIN"
    else
        print_info "  http://$(get_server_ip)"
    fi

    print_info ""
    print_info "Authentication Token: $TOKEN"
    print_info "To access the server, you need to set a browser cookie:"
    print_info "  Name: tkn"
    print_info "  Value: $TOKEN"
    print_info "  Domain: ${SERVER_NAME}"
    print_info ""
    print_info "In browser developer tools console, run:"
    print_info "  document.cookie = 'tkn=$TOKEN; path=/; domain=$SERVER_NAME'"
    print_info ""
    print_info "Useful commands:"
    print_info "  Check status: systemctl status vscode-server.service"
    print_info "  View logs: journalctl -u vscode-server.service -f"
    print_info "  Stop server: systemctl stop vscode-server.service"
    print_info "  Restart server: systemctl restart vscode-server.service"
}

# Main function
main() {
    print_info "Starting VS Code Server setup..."

    parse_args "$@"

    print_info "Configuration:"
    print_info "  Port: $PORT"
    print_info "  Domain: ${DOMAIN:-<use IP>}"
    print_info "  Secure: $SECURE"

    check_sudo
    detect_system
    install_vscode_cli
    install_nginx
    configure_nginx
    setup_certbot
    start_vscode_server

    print_info "Setup completed successfully!"
}

# Run main function
main "$@"