echo -e "${YELLOW}[INFO]${NC} Checking environment files..."

# Check/create root .env

if [ ! -f ".env" ]; then

echo -e "${YELLOW}[INFO]${NC} Creating .env from example-env..."

if [ -f "example-env" ]; then

cp "example-env" ".env"

# Update for local development

sed -i.bak 's/REDIS_HOST=redis/REDIS_HOST=localhost/g' ".env" 2>/dev/null || \

sed -i '' 's/REDIS_HOST=redis/REDIS_HOST=localhost/g' ".env"

sed -i.bak 's/MYSQL_HOST=mysql/MYSQL_HOST=localhost/g' ".env" 2>/dev/null || \

sed -i '' 's/MYSQL_HOST=mysql/MYSQL_HOST=localhost/g' ".env"

sed -i.bak 's/MONGODB_HOST=mongodb/MONGODB_HOST=localhost/g' ".env" 2>/dev/null || \

sed -i '' 's/MONGODB_HOST=mongodb/MONGODB_HOST=localhost/g' ".env"

sed -i.bak 's/KAFKA_BOOTSTRAP_SERVERS=kafka:9093/KAFKA_BOOTSTRAP_SERVERS=localhost:9092/g' ".env" 2>/dev/null || \

sed -i '' 's/KAFKA_BOOTSTRAP_SERVERS=kafka:9093/KAFKA_BOOTSTRAP_SERVERS=localhost:9092/g' ".env"

rm -f ".env.bak" 2>/dev/null

echo -e "${GREEN}[OK]${NC} Root .env created (local mode)"

else

create_default_env

fi

else

echo -e "${GREEN}[OK]${NC} Root .env exists"

fi

# Check/create API server .env

if [ ! -f "backend/api_server/.env" ]; then

echo -e "${YELLOW}[INFO]${NC} Creating API server .env..."

if [ -f "backend/api_server/example-env" ]; then

cp "backend/api_server/example-env" "backend/api_server/.env"

# Update AI_SERVER_URL for local

sed -i.bak 's/AI_SERVER_URL=http:\/\/ai_server:/AI_SERVER_URL=http:\/\/localhost:/g' "backend/api_server/.env" 2>/dev/null || \

sed -i '' 's/AI_SERVER_URL=http:\/\/ai_server:/AI_SERVER_URL=http:\/\/localhost:/g' "backend/api_server/.env"

rm -f "backend/api_server/.env.bak" 2>/dev/null

echo -e "${GREEN}[OK]${NC} API server .env created (local mode)"

else

create_api_env_local

fi

else

echo -e "${GREEN}[OK]${NC} API server .env exists"

fi

# Check/create AI server .env

if [ ! -f "backend/ai_server/.env" ]; then

echo -e "${YELLOW}[INFO]${NC} Creating AI server .env..."

if [ -f "backend/ai_server/example-env" ]; then

cp "backend/ai_server/example-env" "backend/ai_server/.env"

echo -e "${GREEN}[OK]${NC} AI server .env created"

else

create_ai_env_local

fi

else

echo -e "${GREEN}[OK]${NC} AI server .env exists"

fi

# Check/create frontend .env

if [ ! -f "frontend/project/.env" ]; then

echo -e "${YELLOW}[INFO]${NC} Creating frontend .env..."

if [ -f "frontend/project/example-env" ]; then

cp "frontend/project/example-env" "frontend/project/.env"

echo -e "${GREEN}[OK]${NC} Frontend .env created"

else

create_frontend_env_local

fi

else

echo -e "${GREEN}[OK]${NC} Frontend .env exists"

fi

echo ""

echo -e "${YELLOW}[INFO]${NC} Creating default .env file for local development..."

cat > ".env" << 'EOF'

echo -e "${GREEN}[OK]${NC} Default .env created for local development"

echo -e "${YELLOW}[INFO]${NC} Creating API server .env for local development..."

cat > "backend/api_server/.env" << 'EOF'

echo -e "${GREEN}[OK]${NC} API server .env created"

echo -e "${YELLOW}[INFO]${NC} Creating AI server .env for local development..."

cat > "backend/ai_server/.env" << 'EOF'

echo -e "${GREEN}[OK]${NC} AI server .env created"

echo -e "${YELLOW}[INFO]${NC} Creating frontend .env for local development..."

cat > "frontend/project/.env" << 'EOF'

echo -e "${GREEN}[OK]${NC} Frontend .env created"

echo -e "${BLUE}[INFO]${NC} Checking dependencies..."

echo ""

local ALL_OK=1

# Check Go

echo "Checking Go..."

if command -v go &> /dev/null; then

GO_VERSION=$(go version | awk '{print $3}')

echo -e " ${GREEN}[OK]${NC} $GO_VERSION"

else

echo -e " ${RED}[MISSING]${NC} Go is not installed"

echo " Download from: https://golang.org/dl/"

ALL_OK=0

fi

# Check Python

echo "Checking Python..."

if command -v python3 &> /dev/null; then

PYTHON_VERSION=$(python3 --version 2>&1)

echo -e " ${GREEN}[OK]${NC} $PYTHON_VERSION"

elif command -v python &> /dev/null; then

PYTHON_VERSION=$(python --version 2>&1)

echo -e " ${GREEN}[OK]${NC} $PYTHON_VERSION"

else

echo -e " ${RED}[MISSING]${NC} Python is not installed"

echo " Download from: https://python.org/downloads/"

ALL_OK=0

fi

# Check Poetry

echo "Checking Poetry..."

if command -v poetry &> /dev/null; then

POETRY_VERSION=$(poetry --version 2>&1)

echo -e " ${GREEN}[OK]${NC} $POETRY_VERSION"

else

echo -e " ${RED}[MISSING]${NC} Poetry is not installed"

echo " Install with: pip install poetry"

echo " Or visit: https://python-poetry.org/docs/"

ALL_OK=0

fi

# Check Node.js

echo "Checking Node.js..."

if command -v node &> /dev/null; then

NODE_VERSION=$(node --version)

echo -e " ${GREEN}[OK]${NC} Node.js $NODE_VERSION"

else

echo -e " ${RED}[MISSING]${NC} Node.js is not installed"

echo " Download from: https://nodejs.org/"

ALL_OK=0

fi

# Check npm

echo "Checking npm..."

if command -v npm &> /dev/null; then

NPM_VERSION=$(npm --version)

echo -e " ${GREEN}[OK]${NC} npm $NPM_VERSION"

else

echo -e " ${RED}[MISSING]${NC} npm is not installed"

ALL_OK=0

fi

echo ""

if [ "$ALL_OK" -eq 1 ]; then

echo -e "${GREEN}[SUCCESS]${NC} All dependencies are installed!"

else

echo -e "${RED}[WARNING]${NC} Some dependencies are missing. Please install them before running the system."

fi

echo ""

return $((1 - ALL_OK))

command -v go &> /dev/null && \

command -v poetry &> /dev/null && \

command -v node &> /dev/null

echo -e "${BLUE}[INFO]${NC} Installing all dependencies..."

echo ""

# Install AI Server dependencies

echo -e "${CYAN}[1/3]${NC} Installing AI Server dependencies..."

if [ -f "backend/ai_server/pyproject.toml" ]; then

cd backend/ai_server

poetry install

if [ $? -eq 0 ]; then

echo -e "${GREEN}[OK]${NC} AI Server dependencies installed"

else

echo -e "${RED}[ERROR]${NC} Failed to install AI Server dependencies"

fi

cd ../..

else

echo -e "${RED}[ERROR]${NC} pyproject.toml not found"

fi

# Install API Server dependencies

echo ""

echo -e "${CYAN}[2/3]${NC} Installing API Server dependencies..."

if [ -f "backend/api_server/go.mod" ]; then

cd backend/api_server

go mod download

go mod tidy

if [ $? -eq 0 ]; then

echo -e "${GREEN}[OK]${NC} API Server dependencies installed"

else

echo -e "${RED}[ERROR]${NC} Failed to install API Server dependencies"

fi

cd ../..

else

echo -e "${RED}[ERROR]${NC} go.mod not found"

fi

# Install Frontend dependencies

echo ""

echo -e "${CYAN}[3/3]${NC} Installing Frontend dependencies..."

if [ -f "frontend/project/package.json" ]; then

cd frontend/project

npm install

if [ $? -eq 0 ]; then

echo -e "${GREEN}[OK]${NC} Frontend dependencies installed"

else

echo -e "${RED}[ERROR]${NC} Failed to install Frontend dependencies"

fi

cd ../..

else

echo -e "${RED}[ERROR]${NC} package.json not found"

fi

echo ""

echo -e "${GREEN}[SUCCESS]${NC} Dependency installation completed!"

echo ""

echo -e "${BLUE}[INFO]${NC} Starting AI Server..."

cd "$SCRIPT_DIR/backend/ai_server"

# Check if already running

if [ -f "$PID_DIR/ai_server.pid" ]; then

PID=$(cat "$PID_DIR/ai_server.pid")

if kill -0 "$PID" 2>/dev/null; then

echo -e "${YELLOW}[WARN]${NC} AI Server is already running (PID: $PID)"

return

fi

fi

poetry run server > "$SCRIPT_DIR/logs/ai_server.log" 2>&1 &

echo $! > "$PID_DIR/ai_server.pid"

echo -e "${GREEN}[OK]${NC} AI Server started (PID: $!)"

echo " URL: http://localhost:9999"

echo " Docs: http://localhost:9999/docs"

echo " Logs: $SCRIPT_DIR/logs/ai_server.log"

cd "$SCRIPT_DIR"

echo -e "${BLUE}[INFO]${NC} Starting API Server..."

cd "$SCRIPT_DIR/backend/api_server"

# Check if already running

if [ -f "$PID_DIR/api_server.pid" ]; then

PID=$(cat "$PID_DIR/api_server.pid")

if kill -0 "$PID" 2>/dev/null; then

echo -e "${YELLOW}[WARN]${NC} API Server is already running (PID: $PID)"

return

fi

fi

go run main.go > "$SCRIPT_DIR/logs/api_server.log" 2>&1 &

echo $! > "$PID_DIR/api_server.pid"

echo -e "${GREEN}[OK]${NC} API Server started (PID: $!)"

echo " URL: http://localhost:2030"

echo " Logs: $SCRIPT_DIR/logs/api_server.log"

cd "$SCRIPT_DIR"

echo -e "${BLUE}[INFO]${NC} Starting Frontend..."

cd "$SCRIPT_DIR/frontend/project"

# Check if already running

if [ -f "$PID_DIR/frontend.pid" ]; then

PID=$(cat "$PID_DIR/frontend.pid")

if kill -0 "$PID" 2>/dev/null; then

echo -e "${YELLOW}[WARN]${NC} Frontend is already running (PID: $PID)"

return

fi

fi

npm run dev > "$SCRIPT_DIR/logs/frontend.log" 2>&1 &

echo $! > "$PID_DIR/frontend.pid"

echo -e "${GREEN}[OK]${NC} Frontend started (PID: $!)"

echo " URL: http://localhost:5173"

echo " Logs: $SCRIPT_DIR/logs/frontend.log"

cd "$SCRIPT_DIR"

echo -e "${BLUE}[INFO]${NC} Starting all services locally (without Docker)..."

echo ""

# Check dependencies

if ! check_deps_silent; then

echo -e "${RED}[ERROR]${NC} Missing dependencies. Run './start-local.sh check' to see what's missing."

exit 1

fi

# Create logs directory

mkdir -p "$SCRIPT_DIR/logs"

echo -e "${YELLOW}[NOTE]${NC} Services will run in background. Use './start-local.sh logs' to view logs."

echo ""

# Start services

echo -e "${CYAN}[1/3]${NC} Starting AI Server (Python/FastAPI)..."

start_ai

sleep 3

echo ""

echo -e "${CYAN}[2/3]${NC} Starting API Server (Go)..."

start_api

sleep 3

echo ""

echo -e "${CYAN}[3/3]${NC} Starting Frontend (React/Vite)..."

start_frontend

echo ""

echo -e "${GREEN}========================================================${NC}"

echo -e "${GREEN} All services started successfully! ${NC}"

echo -e "${GREEN}========================================================${NC}"

echo ""

echo -e "${CYAN}Service URLs:${NC}"

echo " - Frontend: http://localhost:5173"

echo " - API Server: http://localhost:2030"

echo " - AI Server: http://localhost:9999"

echo ""

echo -e "${CYAN}Health Check URLs:${NC}"

echo " - API Server: http://localhost:2030/api/v1/ping"

echo " - AI Server: http://localhost:9999/api/v1/health"

echo " - AI Server Docs: http://localhost:9999/docs"

echo ""

echo -e "${YELLOW}[TIP]${NC} View logs: ./start-local.sh logs [ai|api|frontend]"

echo -e "${YELLOW}[TIP]${NC} Stop services: ./start-local.sh stop"

echo ""

local name=$1

local pid_file="$PID_DIR/${name}.pid"

if [ -f "$pid_file" ]; then

PID=$(cat "$pid_file")

if kill -0 "$PID" 2>/dev/null; then

kill "$PID" 2>/dev/null

# Wait a moment and force kill if necessary

sleep 1

if kill -0 "$PID" 2>/dev/null; then

kill -9 "$PID" 2>/dev/null

fi

echo -e "${GREEN}[OK]${NC} $name stopped (was PID: $PID)"

else

echo -e "${YELLOW}[WARN]${NC} $name was not running"

fi

rm -f "$pid_file"

else

echo -e "${YELLOW}[WARN]${NC} No PID file for $name"

fi

echo -e "${BLUE}[INFO]${NC} Stopping all services..."

echo ""

# Stop by PID files

stop_service "ai_server"

stop_service "api_server"

stop_service "frontend"

# Also try to kill by port as fallback

echo ""

echo "Cleaning up any remaining processes..."

# Kill processes on ports

for port in 9999 2030 5173; do

PID=$(lsof -ti :$port 2>/dev/null)

if [ -n "$PID" ]; then

kill $PID 2>/dev/null

echo " Killed process on port $port"

fi

done

echo ""

echo -e "${GREEN}[OK]${NC} All services stopped"

echo ""

echo -e "${BLUE}[INFO]${NC} Restarting all services..."

stop_all

sleep 2

start_all

echo -e "${BLUE}[INFO]${NC} Checking service status..."

echo ""

# Check AI Server

echo "AI Server (port 9999):"

if lsof -i :9999 &>/dev/null || netstat -tuln 2>/dev/null | grep -q ":9999 "; then

echo -e " ${GREEN}[RUNNING]${NC} http://localhost:9999"

else

echo -e " ${RED}[STOPPED]${NC} Not running"

fi

# Check API Server

echo "API Server (port 2030):"

if lsof -i :2030 &>/dev/null || netstat -tuln 2>/dev/null | grep -q ":2030 "; then

echo -e " ${GREEN}[RUNNING]${NC} http://localhost:2030"

else

echo -e " ${RED}[STOPPED]${NC} Not running"

fi

# Check Frontend

echo "Frontend (port 5173):"

if lsof -i :5173 &>/dev/null || netstat -tuln 2>/dev/null | grep -q ":5173 "; then

echo -e " ${GREEN}[RUNNING]${NC} http://localhost:5173"

else

echo -e " ${RED}[STOPPED]${NC} Not running"

fi

echo ""

local service=$1

case "$service" in

ai|ai_server)

echo -e "${BLUE}[INFO]${NC} Showing AI Server logs (Ctrl+C to exit)..."

tail -f "$SCRIPT_DIR/logs/ai_server.log"

;;

api|api_server)

echo -e "${BLUE}[INFO]${NC} Showing API Server logs (Ctrl+C to exit)..."

tail -f "$SCRIPT_DIR/logs/api_server.log"

;;

frontend|fe)

echo -e "${BLUE}[INFO]${NC} Showing Frontend logs (Ctrl+C to exit)..."

tail -f "$SCRIPT_DIR/logs/frontend.log"

;;

all|"")

echo -e "${BLUE}[INFO]${NC} Showing all logs (Ctrl+C to exit)..."

tail -f "$SCRIPT_DIR/logs/"*.log

;;

*)

echo -e "${RED}[ERROR]${NC} Unknown service: $service"

echo "Usage: ./start-local.sh logs [ai|api|frontend|all]"

;;

esac

echo -e "${CYAN}VRecommendation System - Local Startup Script (No Docker)${NC}"

echo ""

echo "Usage: ./start-local.sh [COMMAND] [OPTIONS]"

echo ""

echo "Commands:"

echo " start, up Start all services locally (default)"

echo " stop, down Stop all running services"

echo " restart Restart all services"

echo " status Check status of all services"

echo " install Install all dependencies"

echo " check Check if all dependencies are installed"

echo " ai Start only AI Server"

echo " api Start only API Server"

echo " frontend Start only Frontend"

echo " logs [service] View logs (ai|api|frontend|all)"

echo " help Show this help message"

echo ""

echo "Examples:"

echo " ./start-local.sh Start all services"

echo " ./start-local.sh status Check service status"

echo " ./start-local.sh stop Stop all services"

echo " ./start-local.sh install Install dependencies"

echo " ./start-local.sh ai Start only AI Server"

echo " ./start-local.sh logs ai View AI Server logs"

echo ""

echo "Requirements:"

echo " - Go 1.24+ (for API Server)"

echo " - Python 3.9+ (for AI Server)"

echo " - Poetry (for AI Server dependency management)"

echo " - Node.js 18+ (for Frontend)"

echo " - npm (for Frontend)"

echo ""

echo "Service URLs (after starting):"

echo " - Frontend: http://localhost:5173"

echo " - API Server: http://localhost:2030"

echo " - AI Server: http://localhost:9999"

echo " - AI Server Docs: http://localhost:9999/docs"

echo ""

echo -e "${YELLOW}Note:${NC} External services (Redis, MySQL, MongoDB, Kafka) must be"

echo " running separately if required by your configuration."

echo ""