archy/scripts/dev-start.sh

#!/bin/bash
# Archipelago Development Server Starter

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
FRONTEND_DIR="$PROJECT_ROOT/neode-ui"
BACKEND_DIR="$PROJECT_ROOT/core"

# Quietly kill a port — avoids EAGAIN by not piping through xargs
kill_port() {
    local pids
    pids=$(lsof -ti:"$1" 2>/dev/null) || true
    if [ -n "$pids" ]; then
        echo "$pids" | while read -r pid; do
            kill -9 "$pid" 2>/dev/null || true
        done
        sleep 1
    fi
}

cleanup_ports() {
    kill_port 5959
    kill_port 8100
}

ensure_deps() {
    cd "$FRONTEND_DIR"
    if [ ! -d "node_modules" ]; then
        echo "   Installing dependencies..."
        npm install
    fi
}

if [ ! -d "$FRONTEND_DIR" ]; then
    echo "Frontend directory not found: $FRONTEND_DIR"
    exit 1
fi

echo ""
echo "Archipelago Dev Server"
echo ""
echo "  0) Boot branding dev (GRUB theme, Plymouth, installer — patch + QEMU)"
echo "  1) Mock backend (UI dev — fastest, no Docker/Podman needed)"
echo "  2) Full stack (Rust backend + frontend)"
echo "  3) Setup mode (first-time password setup — mock)"
echo "  4) Onboarding mode (onboarding flow — mock)"
echo "  5) Existing user (login screen — mock)"
echo "  6) Boot mode (simulated 25s startup — mock)"
echo "  7) Testnet stack (signet Bitcoin + LND + ThunderHub via Podman)"
echo "  8) Manual instructions"
echo "  9) Container orchestration dev (live testing on .228)"
echo ""
read -p "Enter choice [0-9]: " choice

case $choice in
    0)
        echo ""
        echo "Boot Branding Dev"
        echo ""
        # Find an ISO to patch
        ISO=$(ls -t ~/Desktop/archipelago-dev-*.iso 2>/dev/null | head -1)
        if [ -z "$ISO" ]; then
            ISO=$(ls -t "$PROJECT_ROOT/image-recipe/results/archipelago-"*.iso 2>/dev/null | head -1)
        fi

        DEV_BRANDING="$PROJECT_ROOT/image-recipe/dev-branding.sh"

        if [ -z "$ISO" ] || [ ! -f "$ISO" ]; then
            echo "  No ISO found to patch. Options:"
            echo ""
            echo "  a) Preview GRUB background only (instant):"
            echo "     python3 image-recipe/branding/generate-grub-background.py /tmp/grub-bg.png && open /tmp/grub-bg.png"
            echo ""
            echo "  b) Download an ISO from FileBrowser (http://192.168.1.228:8083)"
            echo "     then drop it on your Desktop and re-run this option."
            echo ""
            echo "  Files you can edit:"
            echo "    image-recipe/branding/grub-theme/background.png  — GRUB boot background"
            echo "    image-recipe/branding/grub-theme/theme.txt       — GRUB menu colors/layout"
            echo "    image-recipe/branding/plymouth-theme/logo.png    — Plymouth boot logo"
            echo "    image-recipe/branding/plymouth-theme/*.script    — Plymouth animation"
            echo ""
            exit 0
        fi

        echo "  ISO: $ISO"
        echo "  Edit these files, then this script patches and boots in QEMU:"
        echo "    branding/grub-theme/background.png  — GRUB background"
        echo "    branding/grub-theme/theme.txt       — GRUB menu theme"
        echo "    branding/plymouth-theme/logo.png    — Plymouth logo"
        echo ""

        if [ -f "$DEV_BRANDING" ]; then
            exec bash "$DEV_BRANDING" "$ISO"
        else
            echo "  dev-branding.sh not found at: $DEV_BRANDING"
            exit 1
        fi
        ;;
    1)
        echo ""
        echo "Starting frontend with mock backend..."
        cleanup_ports
        ensure_deps
        exec npm run dev:mock
        ;;
    2)
        echo ""
        echo "Starting full stack (Rust backend + frontend)..."
        cleanup_ports

        if [ ! -d "$BACKEND_DIR" ]; then
            echo "Backend directory not found: $BACKEND_DIR"
            exit 1
        fi

        cd "$BACKEND_DIR"
        if ! cargo check --bin archipelago > /tmp/archipelago-backend-check.log 2>&1; then
            echo "Backend build check failed. See /tmp/archipelago-backend-check.log"
            echo "Falling back to mock backend."
            ensure_deps
            exec npm run dev:mock
        fi

        echo "   Starting Rust backend..."
        export ARCHIPELAGO_DATA_DIR=/tmp/archipelago-dev
        export ARCHIPELAGO_DEV_DATA_DIR=/tmp/archipelago-dev
        export ARCHIPELAGO_DEV_MODE=true
        export ARCHIPELAGO_BIND=127.0.0.1:5959
        export ARCHIPELAGO_LOG_LEVEL=debug
        export ARCHIPELAGO_BITCOIN_SIMULATION=mock

        cargo run --bin archipelago > /tmp/archipelago-backend.log 2>&1 &
        BACKEND_PID=$!
        echo "   Backend PID: $BACKEND_PID (logs: /tmp/archipelago-backend.log)"

        echo "   Waiting for backend on port 5959..."
        for i in $(seq 1 60); do
            if lsof -ti:5959 >/dev/null 2>&1; then break; fi
            sleep 1
        done

        if ! lsof -ti:5959 >/dev/null 2>&1; then
            echo "Backend did not start. Falling back to mock."
            kill "$BACKEND_PID" 2>/dev/null || true
            ensure_deps
            exec npm run dev:mock
        fi

        echo "   Backend ready."
        trap "kill $BACKEND_PID 2>/dev/null" EXIT

        ensure_deps
        exec npm run dev
        ;;
    3)
        echo ""
        echo "Starting setup mode..."
        cleanup_ports
        ensure_deps
        VITE_DEV_MODE=setup exec npm run dev:mock
        ;;
    4)
        echo ""
        echo "Starting onboarding mode..."
        cleanup_ports
        ensure_deps
        VITE_DEV_MODE=onboarding exec npm run dev:mock
        ;;
    5)
        echo ""
        echo "Starting existing user mode..."
        cleanup_ports
        ensure_deps
        VITE_DEV_MODE=existing exec npm run dev:mock
        ;;
    6)
        echo ""
        echo "Starting boot mode (25s simulated startup)..."
        cleanup_ports
        ensure_deps
        VITE_DEV_MODE=boot exec npm run dev:mock
        ;;
    7)
        echo ""
        echo "Starting testnet stack (signet) via Podman/Docker..."

        # Check for a working container runtime (binary exists AND daemon responds)
        RUNTIME=""
        COMPOSE=""
        if command -v docker &>/dev/null && docker ps &>/dev/null; then
            RUNTIME="docker"
            COMPOSE="docker compose"
        elif command -v podman &>/dev/null && podman ps &>/dev/null; then
            if command -v podman-compose &>/dev/null; then
                RUNTIME="podman"
                COMPOSE="podman-compose"
            else
                RUNTIME="podman"
                COMPOSE="podman compose"
            fi
        fi

        if [ -z "$RUNTIME" ]; then
            if command -v podman &>/dev/null; then
                echo "   Podman machine not running — starting it..."
                if ! podman machine ls --format '{{.Name}}' 2>/dev/null | grep -q .; then
                    echo "   No Podman machine found — initializing..."
                    podman machine init
                fi
                podman machine start
                if podman ps &>/dev/null; then
                    if command -v podman-compose &>/dev/null; then
                        RUNTIME="podman"
                        COMPOSE="podman-compose"
                    else
                        RUNTIME="podman"
                        COMPOSE="podman compose"
                    fi
                else
                    echo "   Failed to start Podman machine."
                    exit 1
                fi
            elif command -v docker &>/dev/null; then
                echo ""
                echo "Docker is installed but the daemon isn't running."
                echo "Start Docker Desktop and try again."
                exit 1
            else
                echo ""
                echo "No container runtime found. Install one:"
                echo "  brew install podman podman-compose"
                echo "  # or"
                echo "  brew install --cask docker"
                exit 1
            fi
        fi

        echo "   Using: $RUNTIME"
        cd "$PROJECT_ROOT"

        echo "   Starting signet Bitcoin + LND + ThunderHub + Fedimint..."
        $COMPOSE -f docker-compose.testnet.yml up -d

        echo ""
        echo "   Testnet stack starting. Services:"
        echo "     ThunderHub:       http://localhost:3010  (password: thunderhub)"
        echo "     Fedimint Guardian: http://localhost:18175"
        echo "     LND REST:         http://localhost:8080"
        echo "     Bitcoin RPC:      localhost:38332"
        echo ""
        echo "   Get signet coins: https://signetfaucet.com"
        echo ""
        echo "   Also starting mock frontend..."
        cleanup_ports
        ensure_deps
        exec npm run dev:mock
        ;;
    8)
        echo ""
        echo "Manual Instructions"
        echo ""
        echo "UI development (mock backend, no Docker):"
        echo "  cd $FRONTEND_DIR"
        echo "  npm install && npm run dev:mock"
        echo ""
        echo "Dev modes (prepend to command):"
        echo "  VITE_DEV_MODE=setup       First-time setup flow"
        echo "  VITE_DEV_MODE=onboarding  Onboarding flow"
        echo "  VITE_DEV_MODE=existing    Login screen"
        echo "  VITE_DEV_MODE=boot        Boot sequence"
        echo ""
        echo "Testnet stack (requires Podman or Docker):"
        echo "  podman compose -f docker-compose.testnet.yml up -d"
        echo ""
        echo "Full stack (requires Rust toolchain):"
        echo "  Terminal 1: cd $BACKEND_DIR && cargo run --bin archipelago"
        echo "  Terminal 2: cd $FRONTEND_DIR && npm run dev"
        echo ""
        echo "Access: http://localhost:8100  (password: password123)"
        ;;
    9)
        echo ""
        echo "Container Orchestration Dev (live testing on .228)"
        echo "Syncs code, builds on server, runs orchestration smoke tests."
        echo ""
        exec "$SCRIPT_DIR/dev-container-test.sh"
        ;;
    *)
        echo "Invalid choice"
        exit 1
        ;;
esac