quick-test.sh

#!/bin/bash

# Quick Tailscale Exit Node Test
# Fast comparison between exit nodes (~2-3 min)
# Configuration loaded from config.json

set -euo pipefail

# Configuration
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
CONFIG_FILE="${CONFIG_FILE:-$SCRIPT_DIR/config.json}"

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

# Store original accept-routes setting
ORIGINAL_ACCEPT_ROUTES=""

# Results storage (associative arrays)
declare -A RESULTS_PING
declare -A RESULTS_TTFB_CLAUDE
declare -A RESULTS_TTFB_OPENAI
declare -A RESULTS_TTFB_GEMINI
declare -A RESULTS_SPEED
declare -a TESTED_NODES=()

log_info()  { echo -e "${BLUE}[INFO]${NC} $*"; }
log_ok()    { echo -e "${GREEN}[OK]${NC} $*"; }
log_warn()  { echo -e "${YELLOW}[WARN]${NC} $*"; }

# ============================================================================
# Tailscale Route Management
# ============================================================================

save_and_disable_accept_routes() {
    log_info "Checking current accept-routes setting..."

    # Get current prefs from tailscale
    local prefs
    prefs=$(tailscale debug prefs 2>/dev/null || echo "{}")

    # Extract RouteAll (accept-routes) setting
    ORIGINAL_ACCEPT_ROUTES=$(echo "$prefs" | grep -o '"RouteAll":[^,}]*' | cut -d: -f2 | tr -d ' ' || echo "false")

    if [[ -z "$ORIGINAL_ACCEPT_ROUTES" ]]; then
        ORIGINAL_ACCEPT_ROUTES="false"
    fi

    echo -e "  Original accept-routes: ${CYAN}$ORIGINAL_ACCEPT_ROUTES${NC}"

    if [[ "$ORIGINAL_ACCEPT_ROUTES" == "true" ]]; then
        log_info "Disabling accept-routes to avoid app connector interference..."
        sudo tailscale set --accept-routes=false 2>/dev/null || true
        sleep 1
        log_ok "accept-routes disabled for benchmark"
    else
        log_ok "accept-routes already disabled, no change needed"
    fi
}

restore_accept_routes() {
    if [[ "$ORIGINAL_ACCEPT_ROUTES" == "true" ]]; then
        log_info "Restoring accept-routes to: $ORIGINAL_ACCEPT_ROUTES"
        sudo tailscale set --accept-routes=true 2>/dev/null || true
        log_ok "accept-routes restored"
    fi
}

# Cleanup function for trap
cleanup() {
    local exit_code=$?
    echo ""

    # Reset exit node
    sudo tailscale set --exit-node= 2>/dev/null || true

    # Restore accept-routes
    restore_accept_routes

    if [[ $exit_code -ne 0 ]]; then
        log_warn "Script exited with code: $exit_code"
    fi

    exit $exit_code
}

print_header() {
    echo -e "\n${BOLD}${CYAN}╔══════════════════════════════════════════════════════════╗${NC}"
    echo -e "${BOLD}${CYAN}║     Quick Exit Node Test - $(date '+%H:%M:%S')                    ║${NC}"
    echo -e "${BOLD}${CYAN}╚══════════════════════════════════════════════════════════╝${NC}\n"
}

load_config() {
    if [[ ! -f "$CONFIG_FILE" ]]; then
        echo -e "${RED}Error: Config file not found: $CONFIG_FILE${NC}"
        exit 1
    fi

    if ! jq empty "$CONFIG_FILE" 2>/dev/null; then
        echo -e "${RED}Error: Invalid JSON in config file${NC}"
        exit 1
    fi
}

set_exit_node() {
    local node="$1"
    if [[ -z "$node" ]]; then
        sudo tailscale set --exit-node= 2>/dev/null || true
    else
        sudo tailscale set --exit-node="$node" 2>/dev/null || true
    fi
    sleep 3

    # Verify and print current exit node status
    local current_exit
    current_exit=$(tailscale status --json 2>/dev/null | jq -r '
        .Peer | to_entries[] | select(.value.ExitNode == true) | .value.HostName
    ' 2>/dev/null) || current_exit=""

    if [[ -z "$current_exit" ]]; then
        echo -e "  Exit node: ${GREEN}None (direct connection)${NC}"
    else
        echo -e "  Exit node: ${CYAN}$current_exit${NC}"
    fi
}

check_exit_node_available() {
    local node_ip="$1"
    local node_name="$2"

    # Check if the node offers exit node capability
    local offers_exit
    offers_exit=$(tailscale status 2>/dev/null | grep -E "^${node_ip}\s" | grep -c "offers exit node") || offers_exit=0

    if [[ "$offers_exit" -eq 0 ]]; then
        log_warn "Node '$node_name' ($node_ip) does not offer exit node capability - SKIPPING"
        echo -e "  ${YELLOW}Hint: Run 'sudo tailscale up --advertise-exit-node' on that machine${NC}"
        return 1
    fi

    return 0
}

get_ping_avg() {
    local host="$1"
    local result
    result=$(ping -c 5 "$host" 2>/dev/null) || true
    echo "$result" | grep -E "rtt|round-trip" | sed 's/.*= //' | cut -d'/' -f2 || echo "N/A"
}

test_node() {
    local name="$1"
    local ip="$2"
    local dns="$3"

    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "${GREEN}${BOLD}Testing: $name${NC} ($ip)"
    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"

    # Track this node
    TESTED_NODES+=("$name")

    set_exit_node "$ip"

    # Public IP check
    local public_ip loc
    public_ip=$(curl -s --connect-timeout 5 https://ipinfo.io/ip 2>/dev/null || echo "timeout")
    loc=$(curl -s --connect-timeout 5 "https://ipinfo.io/$public_ip/city" 2>/dev/null || echo "?")
    echo -e "Public IP: ${CYAN}$public_ip${NC} ($loc)"

    # Ping
    echo -e "\n${BOLD}Ping to 8.8.8.8:${NC}"
    local ping_avg
    ping_avg=$(get_ping_avg "8.8.8.8")
    echo -e "  Avg: ${CYAN}${ping_avg}ms${NC}"
    RESULTS_PING["$name"]="$ping_avg"

    # AI API TTFB from config
    echo -e "\n${BOLD}AI API TTFB:${NC}"
    local ai_endpoints
    readarray -t ai_endpoints < <(jq -r '.ai_endpoints[]' "$CONFIG_FILE" | head -3)

    local idx=0
    for endpoint in "${ai_endpoints[@]}"; do
        local api="${endpoint#https://}"
        local ttfb
        ttfb=$(curl -w "%{time_starttransfer}" -o /dev/null -s --connect-timeout 10 "$endpoint" 2>/dev/null || echo "N/A")
        printf "  %-40s TTFB: ${CYAN}%ss${NC}\n" "$api" "$ttfb"

        # Store results based on endpoint
        case "$api" in
            *anthropic*) RESULTS_TTFB_CLAUDE["$name"]="$ttfb" ;;
            *openai*) RESULTS_TTFB_OPENAI["$name"]="$ttfb" ;;
            *googleapis*|*google*|*gemini*) RESULTS_TTFB_GEMINI["$name"]="$ttfb" ;;
        esac
        ((idx++)) || true
    done

    # Download
    echo -e "\n${BOLD}Download (10MB):${NC}"
    local speed speed_mbps
    speed=$(curl -w "%{speed_download}" -o /dev/null -s --connect-timeout 30 "https://speed.cloudflare.com/__down?bytes=10485760" 2>/dev/null || echo "0")
    if command -v bc &>/dev/null && [[ "$speed" != "0" ]]; then
        speed_mbps=$(echo "scale=2; $speed * 8 / 1024 / 1024" | bc 2>/dev/null || echo "0")
    else
        speed_mbps="N/A"
    fi
    echo -e "  Speed: ${CYAN}${speed_mbps} Mbps${NC}"
    RESULTS_SPEED["$name"]="$speed_mbps"

    echo ""
}

test_direct() {
    local name="Direct"

    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "${GREEN}${BOLD}Testing: Direct (No Exit Node)${NC}"
    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"

    set_exit_node ""

    local public_ip loc
    public_ip=$(curl -s --connect-timeout 5 https://ipinfo.io/ip 2>/dev/null || echo "timeout")
    loc=$(curl -s --connect-timeout 5 "https://ipinfo.io/$public_ip/city" 2>/dev/null || echo "?")
    echo -e "Public IP: ${CYAN}$public_ip${NC} ($loc)"

    # Ping test
    echo -e "\n${BOLD}Ping to 8.8.8.8:${NC}"
    local ping_avg
    ping_avg=$(get_ping_avg "8.8.8.8")
    echo -e "  Avg: ${CYAN}${ping_avg}ms${NC}"
    RESULTS_PING["$name"]="$ping_avg"

    # AI API TTFB
    echo -e "\n${BOLD}AI API TTFB (baseline):${NC}"
    local ai_endpoints
    readarray -t ai_endpoints < <(jq -r '.ai_endpoints[]' "$CONFIG_FILE" | head -3)

    for endpoint in "${ai_endpoints[@]}"; do
        local api="${endpoint#https://}"
        local ttfb
        ttfb=$(curl -w "%{time_starttransfer}" -o /dev/null -s --connect-timeout 10 "$endpoint" 2>/dev/null || echo "N/A")
        printf "  %-40s TTFB: ${CYAN}%ss${NC}\n" "$api" "$ttfb"

        # Store results based on endpoint
        case "$api" in
            *anthropic*) RESULTS_TTFB_CLAUDE["$name"]="$ttfb" ;;
            *openai*) RESULTS_TTFB_OPENAI["$name"]="$ttfb" ;;
            *googleapis*|*google*|*gemini*) RESULTS_TTFB_GEMINI["$name"]="$ttfb" ;;
        esac
    done

    # Download speed test
    echo -e "\n${BOLD}Download (10MB):${NC}"
    local speed speed_mbps
    speed=$(curl -w "%{speed_download}" -o /dev/null -s --connect-timeout 30 "https://speed.cloudflare.com/__down?bytes=10485760" 2>/dev/null || echo "0")
    if command -v bc &>/dev/null && [[ "$speed" != "0" ]]; then
        speed_mbps=$(echo "scale=2; $speed * 8 / 1024 / 1024" | bc 2>/dev/null || echo "0")
    else
        speed_mbps="N/A"
    fi
    echo -e "  Speed: ${CYAN}${speed_mbps} Mbps${NC}"
    RESULTS_SPEED["$name"]="$speed_mbps"

    echo ""
}

print_summary() {
    echo ""
    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "${BOLD}${CYAN}Summary${NC}"
    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"

    # Build list of all columns: Direct first, then tested exit nodes
    local all_nodes=("Direct" "${TESTED_NODES[@]}")

    if [[ ${#TESTED_NODES[@]} -eq 0 ]]; then
        echo "No exit nodes tested."
        return
    fi

    local col_width=14
    local metric_width=16

    # Header
    local header=""
    header+=$(printf "%-${metric_width}s" "Metric")
    for name in "${all_nodes[@]}"; do
        if [[ "$name" == "Direct" ]]; then
            header+=$(printf " | ${CYAN}%-${col_width}s${NC}" "$name")
        else
            header+=$(printf " | %-${col_width}s" "$name")
        fi
    done
    header+=$(printf " | %-${col_width}s" "Winner")

    echo -e "${BOLD}$header${NC}"

    # Separator
    local sep=""
    sep+=$(printf '%*s' "$metric_width" '' | tr ' ' '-')
    for name in "${all_nodes[@]}"; do
        sep+="-+-"
        sep+=$(printf '%*s' "$col_width" '' | tr ' ' '-')
    done
    sep+="-+-"
    sep+=$(printf '%*s' "$col_width" '' | tr ' ' '-')
    echo "$sep"

    # Print a metric row
    print_metric_row() {
        local metric="$1"
        local array_name="$2"
        local unit="$3"
        local lower_better="$4"

        local row=""
        row+=$(printf "%-${metric_width}s" "$metric")

        local best_val=""
        local best_name=""

        # First pass: find winner (only from TESTED_NODES, not Direct)
        for node in "${TESTED_NODES[@]}"; do
            local key="${array_name}[$node]"
            local val="${!key:-N/A}"

            if [[ "$val" != "N/A" && -n "$val" ]]; then
                if [[ -z "$best_val" ]]; then
                    best_val="$val"
                    best_name="$node"
                elif [[ "$lower_better" == "true" ]]; then
                    if (( $(echo "$val < $best_val" | bc -l 2>/dev/null || echo 0) )); then
                        best_val="$val"
                        best_name="$node"
                    fi
                else
                    if (( $(echo "$val > $best_val" | bc -l 2>/dev/null || echo 0) )); then
                        best_val="$val"
                        best_name="$node"
                    fi
                fi
            fi
        done

        # Second pass: build row (include Direct and all tested nodes)
        for node in "${all_nodes[@]}"; do
            local key="${array_name}[$node]"
            local val="${!key:-N/A}"
            if [[ "$val" != "N/A" && -n "$val" ]]; then
                if [[ "$node" == "Direct" ]]; then
                    row+=$(printf " | ${CYAN}%-${col_width}s${NC}" "${val}${unit}")
                else
                    row+=$(printf " | %-${col_width}s" "${val}${unit}")
                fi
            else
                row+=$(printf " | %-${col_width}s" "N/A")
            fi
        done

        # Winner column (only from exit nodes, not Direct)
        if [[ -n "$best_name" ]]; then
            row+=$(printf " | ${GREEN}%-${col_width}s${NC}" "$best_name")
        else
            row+=$(printf " | %-${col_width}s" "-")
        fi

        echo -e "$row"
    }

    # Print metrics
    print_metric_row "Ping (avg)" "RESULTS_PING" "ms" "true"
    print_metric_row "Claude TTFB" "RESULTS_TTFB_CLAUDE" "s" "true"
    print_metric_row "OpenAI TTFB" "RESULTS_TTFB_OPENAI" "s" "true"
    print_metric_row "Gemini TTFB" "RESULTS_TTFB_GEMINI" "s" "true"
    print_metric_row "Download" "RESULTS_SPEED" "Mbps" "false"

    echo ""
    echo -e "${CYAN}Note: 'Direct' shown for reference only, not included in winner calculation${NC}"
    echo ""
}

main() {
    print_header

    # Check dependencies
    if ! command -v tailscale &>/dev/null; then
        echo -e "${RED}Error: tailscale not installed${NC}"
        exit 1
    fi

    if ! command -v jq &>/dev/null; then
        echo -e "${RED}Error: jq not installed${NC}"
        exit 1
    fi

    if ! tailscale status &>/dev/null; then
        echo -e "${RED}Error: tailscale not running${NC}"
        exit 1
    fi

    load_config

    # Set up cleanup trap (handles Ctrl+C, errors, and normal exit)
    trap cleanup EXIT INT TERM

    # Inform user about sudo usage
    echo ""
    log_info "This script requires sudo to control Tailscale exit node settings."
    log_info "You may be prompted for your password."
    echo ""

    # Disable accept-routes to avoid app connector interference
    save_and_disable_accept_routes

    # Clear any existing exit node before starting tests
    log_info "Clearing any existing exit node..."
    sudo tailscale set --exit-node= 2>/dev/null || true
    sleep 3

    # Verify exit node is cleared
    local current_exit
    current_exit=$(tailscale status --json 2>/dev/null | jq -r '
        .Peer | to_entries[] | select(.value.ExitNode == true) | .value.HostName
    ' 2>/dev/null) || current_exit=""

    if [[ -z "$current_exit" ]]; then
        log_ok "Exit node cleared (direct connection confirmed)"
    else
        log_warn "Exit node still active: $current_exit"
    fi
    echo ""

    # Test direct connection first
    test_direct

    # Get exit nodes from config and test each
    local node_count
    node_count=$(jq '.exit_nodes | length' "$CONFIG_FILE")

    for i in $(seq 0 $((node_count - 1))); do
        local node_ip node_name node_dns
        node_ip=$(jq -r ".exit_nodes[$i].ip" "$CONFIG_FILE")
        node_name=$(jq -r ".exit_nodes[$i].name" "$CONFIG_FILE")
        node_dns=$(jq -r ".exit_nodes[$i].dns" "$CONFIG_FILE")

        echo ""
        # Check if node offers exit node capability before testing
        if ! check_exit_node_available "$node_ip" "$node_name"; then
            echo ""
            continue
        fi

        test_node "$node_name" "$node_ip" "$node_dns"
    done

    # Print summary table
    print_summary

    echo -e "${GREEN}${BOLD}Done!${NC}"

    # Cleanup (exit node reset + accept-routes restore) handled by trap
}

main "$@"