prepare-app

name	prepare-app
description	Use when preparing an application for review by starting services and ensuring accessibility for testing. Triggered by 'start the app', 'prepare for review', 'prepare app', or before PR review with UI validation.

Prepare App

Prepare the application for review by starting necessary services and ensuring the app is accessible.

When to Use

• Before running /do-pr-review command with UI validation
• Before manual testing of web applications
• When setting up local development environment for testing
• Before browser automation with BYOB MCP tools (mcp__byob__browser_*, real Chrome, logged-in)

Instructions

Follow these steps to prepare the application for review:

1. Detect Project Type

Check for common project indicators:

# Django project
test -f manage.py && echo "Django project detected"

# Node/React/Next.js project
test -f package.json && echo "Node project detected"

# Go project
test -f go.mod && echo "Go project detected"

# Determine which setup to run

2. Django Projects

For Django applications:

# Activate virtual environment if exists
if [ -d venv ]; then
    source venv/bin/activate
elif [ -d .venv ]; then
    source .venv/bin/activate
fi

# Check if server is already running
if lsof -i:8000 >/dev/null 2>&1; then
    echo "Django server already running on port 8000"
else
    # Start server in background
    python manage.py runserver --noreload &
    SERVER_PID=$!

    # Wait for server to be ready
    echo "Starting Django server..."
    sleep 3

    # Verify server is responding
    if curl -s http://localhost:8000/ >/dev/null; then
        echo "Django server ready at http://localhost:8000"
        echo "PID: $SERVER_PID"
    else
        echo "Server failed to start"
        kill $SERVER_PID 2>/dev/null
        exit 1
    fi
fi

3. Node/React Projects

For Node-based applications:

# Check if server is already running on common ports
if lsof -i:3000 >/dev/null 2>&1; then
    echo "Server already running on port 3000"
elif lsof -i:3001 >/dev/null 2>&1; then
    echo "Server already running on port 3001"
else
    # Determine start command
    if grep -q "\"dev\":" package.json; then
        START_CMD="npm run dev"
    elif grep -q "\"start\":" package.json; then
        START_CMD="npm start"
    else
        echo "No start command found in package.json"
        exit 1
    fi

    # Start server in background
    echo "Starting server with: $START_CMD"
    $START_CMD &
    SERVER_PID=$!

    # Wait for server to be ready
    sleep 5

    # Check common ports
    if curl -s http://localhost:3000/ >/dev/null; then
        echo "Server ready at http://localhost:3000"
        echo "PID: $SERVER_PID"
    elif curl -s http://localhost:3001/ >/dev/null; then
        echo "Server ready at http://localhost:3001"
        echo "PID: $SERVER_PID"
    else
        echo "Server failed to start"
        kill $SERVER_PID 2>/dev/null
        exit 1
    fi
fi

4. Go Projects

For Go applications:

# Check if server is running
if lsof -i:8080 >/dev/null 2>&1; then
    echo "Server already running on port 8080"
else
    # Start server
    echo "Starting Go server..."
    go run . &
    SERVER_PID=$!

    # Wait for server
    sleep 3

    # Verify
    if curl -s http://localhost:8080/ >/dev/null; then
        echo "Go server ready at http://localhost:8080"
        echo "PID: $SERVER_PID"
    else
        echo "Server failed to start"
        kill $SERVER_PID 2>/dev/null
        exit 1
    fi
fi

5. Generic Web Server Check

If project type unclear, check for running web servers:

# Check common development ports
for port in 3000 3001 8000 8080 5000 4200; do
    if lsof -i:$port >/dev/null 2>&1; then
        echo "Server found running on port $port"
        echo "URL: http://localhost:$port"
        exit 0
    fi
done

echo "No running server detected on common ports"
echo "Please start your application manually or specify custom port"
exit 1

6. Database Services (if needed)

Check and start database services:

# PostgreSQL
if command -v pg_isready >/dev/null 2>&1; then
    if pg_isready -q; then
        echo "PostgreSQL is running"
    else
        echo "PostgreSQL not running. Start with: brew services start postgresql"
    fi
fi

# Redis
if command -v redis-cli >/dev/null 2>&1; then
    if redis-cli ping >/dev/null 2>&1; then
        echo "Redis is running"
    else
        echo "Redis not running. Start with: brew services start redis"
    fi
fi

# MySQL
if command -v mysql >/dev/null 2>&1; then
    if mysqladmin ping >/dev/null 2>&1; then
        echo "MySQL is running"
    else
        echo "MySQL not running. Start with: brew services start mysql"
    fi
fi

7. Environment Variables Check

Verify critical environment variables:

# Check for .env file
if [ -f .env ]; then
    echo ".env file found"

    # Check for common required variables
    if grep -q "DATABASE_URL" .env; then
        echo "  DATABASE_URL configured"
    fi

    if grep -q "SECRET_KEY" .env; then
        echo "  SECRET_KEY configured"
    fi
else
    echo "No .env file found. May need environment configuration."
fi

8. Output Summary

Report application status:

Application Preparation Summary

Project Type: {detected_type}
Server Status: {running/started/failed}
Server URL: {url}
Server PID: {pid} (if newly started)

Database Services:
  PostgreSQL: {status}
  Redis: {status}
  MySQL: {status}

Environment: {configured/needs_setup}

Ready for review

Cleanup Instructions

To stop servers started by this command:

# Kill server by PID
kill {SERVER_PID}

# Or kill by port
lsof -ti:8000 | xargs kill
lsof -ti:3000 | xargs kill

Error Handling

If server fails to start:

1. Check for port conflicts: lsof -i:{port}
2. Check for missing dependencies: npm install or pip install -r requirements.txt
3. Verify environment variables are set
4. Check application logs for startup errors

If database connection fails:

1. Verify database service is running
2. Check connection string in .env
3. Test database connectivity manually
4. Check database logs

Integration Notes

Works with:

• /do-pr-review - Ensures app is running before screenshots
• BYOB MCP tools (mcp__byob__browser_*, real Chrome, logged-in) - The browser surface this skill prepares the app for
• Local development workflow

Server lifecycle:

• Detects already-running servers (no duplicate starts)
• Starts servers in background for review
• Provides PID for manual cleanup
• Uses --noreload for Django to prevent auto-restart interference

Example Usage

# Auto-detect and prepare
/prepare-app

# Manual verification after
curl http://localhost:8000/

Best Practices

1. Check before starting: Don't start duplicate servers
2. Wait for ready: Give servers time to fully initialize
3. Verify with curl: Confirm server is actually responding
4. Track PIDs: Make cleanup easy
5. Handle errors gracefully: Report why server didn't start

Notes

• Servers started in background may need manual cleanup after review
• Django uses --noreload flag to prevent auto-restart during review
• Node servers may take longer to compile and start (5-10 seconds typical)
• Database services are checked but not auto-started (require user permission)