┌─────────────────────┐
│  Version Control    │  ← Git repository (source of truth)
│      (Git)          │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│  CI/CD Pipeline     │  ← GitHub Actions/GitLab CI
│   (Automated)       │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│ Deployment Scripts  │  ← WP-CLI + Bash automation
│    (This System)    │
└──────────┬──────────┘
           │
    ┌──────┴──────┐
    │             │
    ▼             ▼
┌────────┐   ┌────────┐
│Staging │   │  Prod  │  ← WordPress environments
└────────┘   └────────┘

wordpress-deploy-system/
├── bin/                      # Executable scripts
│   ├── deploy                # Main deployment command
│   ├── provision             # Server provisioning
│   ├── backup                # Backup management
│   ├── rollback              # Rollback deployments
│   └── monitor               # Health monitoring
├── lib/                      # Reusable functions
│   ├── common.sh             # Shared utilities
│   ├── deploy.sh             # Deployment logic
│   ├── database.sh           # DB operations
│   └── wordpress.sh          # WordPress operations
├── config/                   # Configuration files
│   ├── environments/         # Environment-specific configs
│   │   ├── development.conf
│   │   ├── staging.conf
│   │   └── production.conf
│   └── deploy.conf           # Global deployment config
├── migrations/               # Database migrations
│   ├── 001-initial-schema.sql
│   └── 002-add-custom-tables.sql
├── hooks/                    # Deployment hooks
│   ├── pre-deploy.sh
│   ├── post-deploy.sh
│   └── health-check.sh
├── logs/                     # Deployment logs
└── backups/                  # Backup storage

#!/bin/bash
# install.sh - Set up deployment system

INSTALL_DIR="/opt/wordpress-deploy"

echo "Installing WordPress Deployment System"
echo "======================================="

# Create directory structure
sudo mkdir -p "$INSTALL_DIR"/{bin,lib,config/environments,migrations,hooks,logs,backups}

# Copy files
sudo cp -r bin/* "$INSTALL_DIR/bin/"
sudo cp -r lib/* "$INSTALL_DIR/lib/"
sudo cp -r config/* "$INSTALL_DIR/config/"

# Make scripts executable
sudo chmod +x "$INSTALL_DIR"/bin/*
sudo chmod +x "$INSTALL_DIR"/hooks/*

# Add to PATH
echo "export PATH=\$PATH:$INSTALL_DIR/bin" | sudo tee -a /etc/profile.d/wordpress-deploy.sh

# Install WP-CLI if not present
if ! command -v wp &> /dev/null; then
    echo "Installing WP-CLI..."
    curl -O https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar
    sudo mv wp-cli.phar /usr/local/bin/wp
    sudo chmod +x /usr/local/bin/wp
fi

echo "✓ Installation complete"
echo "Usage: deploy <environment> <release>"

#!/bin/bash
# bin/provision - Provision WordPress server

set -euo pipefail

source "$(dirname "$0")/../lib/common.sh"

ENVIRONMENT="${1:-staging}"
CONFIG_FILE="$CONFIG_DIR/environments/$ENVIRONMENT.conf"

if [ ! -f "$CONFIG_FILE" ]; then
    error "Configuration not found: $CONFIG_FILE"
fi

source "$CONFIG_FILE"

log "Provisioning WordPress server for: $ENVIRONMENT"

# Update system packages
log "Updating system packages..."
sudo apt-get update
sudo apt-get upgrade -y

# Install LAMP stack
log "Installing LAMP stack..."
sudo apt-get install -y \
    nginx \
    mysql-server \
    php8.1-fpm \
    php8.1-mysql \
    php8.1-xml \
    php8.1-mbstring \
    php8.1-curl \
    php8.1-zip \
    php8.1-gd \
    php8.1-intl

# Configure Nginx
log "Configuring Nginx..."
sudo tee /etc/nginx/sites-available/wordpress <<EOF
server {
    listen 80;
    server_name $SERVER_NAME;
    root $DEPLOY_PATH/current;
    index index.php;

    location / {
        try_files \$uri \$uri/ /index.php?\$args;
    }

    location ~ \.php$ {
        fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME \$document_root\$fastcgi_script_name;
    }
}
EOF

sudo ln -sf /etc/nginx/sites-available/wordpress /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx

# Create deployment directories
log "Creating deployment directories..."
sudo mkdir -p "$DEPLOY_PATH"/{releases,shared}
sudo mkdir -p "$DEPLOY_PATH/shared"/{wp-content/uploads,logs}

# Set permissions
sudo chown -R www-data:www-data "$DEPLOY_PATH"
sudo chmod -R 755 "$DEPLOY_PATH"

# Create MySQL database
log "Creating WordPress database..."
sudo mysql <<EOF
CREATE DATABASE IF NOT EXISTS $DB_NAME;
CREATE USER IF NOT EXISTS '$DB_USER'@'localhost' IDENTIFIED BY '$DB_PASS';
GRANT ALL PRIVILEGES ON $DB_NAME.* TO '$DB_USER'@'localhost';
FLUSH PRIVILEGES;
EOF

# Install WordPress
log "Installing WordPress..."
cd "$DEPLOY_PATH"

wp core download --path=initial-install
cd initial-install

wp config create \
    --dbname="$DB_NAME" \
    --dbuser="$DB_USER" \
    --dbpass="$DB_PASS" \
    --dbhost=localhost

wp core install \
    --url="$SITE_URL" \
    --title="$SITE_TITLE" \
    --admin_user="$ADMIN_USER" \
    --admin_password="$ADMIN_PASS" \
    --admin_email="$ADMIN_EMAIL"

# Move to shared directory
mv wp-content/uploads/* "$DEPLOY_PATH/shared/wp-content/uploads/"
mv wp-config.php "$DEPLOY_PATH/shared/"

# Install SSL certificate (Let's Encrypt)
if [ "$SSL_ENABLED" = "true" ]; then
    log "Installing SSL certificate..."
    sudo apt-get install -y certbot python3-certbot-nginx
    sudo certbot --nginx -d "$SERVER_NAME" --non-interactive --agree-tos -m "$ADMIN_EMAIL"
fi

log "✓ Server provisioning complete"
log "WordPress URL: $SITE_URL"
log "Admin user: $ADMIN_USER"

# config/environments/production.conf

# Server settings
SERVER_NAME="example.com"
SITE_URL="https://example.com"
SITE_TITLE="Production Site"

# Deployment paths
DEPLOY_PATH="/var/www/production"
RELEASE_DIR="$DEPLOY_PATH/releases"
SHARED_DIR="$DEPLOY_PATH/shared"
CURRENT_LINK="$DEPLOY_PATH/current"

# Database credentials
DB_NAME="wp_production"
DB_USER="wp_user"
DB_PASS="strong-password-here"
DB_HOST="localhost"

# WordPress admin
ADMIN_USER="admin"
ADMIN_PASS="admin-password-here"
ADMIN_EMAIL="admin@example.com"

# Git repository
GIT_REPO="git@github.com:yourcompany/wordpress-site.git"
GIT_BRANCH="main"

# Deployment settings
KEEP_RELEASES=5
BACKUP_RETENTION_DAYS=30
SSL_ENABLED=true

# Notifications
SLACK_WEBHOOK="https://hooks.slack.com/services/YOUR/WEBHOOK/URL"
EMAIL_NOTIFICATIONS="team@example.com"

#!/bin/bash
# bin/deploy - Main deployment command

set -euo pipefail

source "$(dirname "$0")/../lib/common.sh"
source "$(dirname "$0")/../lib/deploy.sh"

ENVIRONMENT="${1:-staging}"
RELEASE_TAG="${2:-HEAD}"
CONFIG_FILE="$CONFIG_DIR/environments/$ENVIRONMENT.conf"

if [ ! -f "$CONFIG_FILE" ]; then
    error "Configuration not found: $CONFIG_FILE"
fi

source "$CONFIG_FILE"

log "=== WordPress Deployment Started ==="
log "Environment: $ENVIRONMENT"
log "Release: $RELEASE_TAG"
log "Time: $(date)"

# Pre-deployment checks
log "Running pre-deployment checks..."
run_hook "pre-deploy" || error "Pre-deployment checks failed"

# Create backup
log "Creating pre-deployment backup..."
"$BIN_DIR/backup" "$ENVIRONMENT" || error "Backup failed"

# Prepare new release
RELEASE_ID=$(date +%Y%m%d_%H%M%S)
RELEASE_PATH="$RELEASE_DIR/$RELEASE_ID"

log "Creating release: $RELEASE_ID"
mkdir -p "$RELEASE_PATH"

# Clone code from Git
log "Cloning repository..."
git clone --depth 1 --branch "$GIT_BRANCH" "$GIT_REPO" "$RELEASE_PATH"
cd "$RELEASE_PATH"

# Install dependencies
log "Installing dependencies..."
if [ -f composer.json ]; then
    composer install --no-dev --optimize-autoloader
fi

if [ -f package.json ]; then
    npm ci --production
    npm run build
fi

# Link shared directories
log "Linking shared resources..."
ln -nfs "$SHARED_DIR/wp-content/uploads" "$RELEASE_PATH/wp-content/uploads"
ln -nfs "$SHARED_DIR/wp-config.php" "$RELEASE_PATH/wp-config.php"

# Run database migrations
log "Running database migrations..."
run_migrations "$RELEASE_PATH" || {
    error "Database migration failed"
    rollback_deployment "$ENVIRONMENT" "$RELEASE_ID"
    exit 1
}

# Health check on new release
log "Running health checks..."
test_release "$RELEASE_PATH" || {
    error "Health checks failed"
    rollback_deployment "$ENVIRONMENT" "$RELEASE_ID"
    exit 1
}

# Atomic switch to new release
log "Switching to new release..."
ln -nfs "$RELEASE_PATH" "$CURRENT_LINK"

# Post-deployment tasks
log "Running post-deployment tasks..."
cd "$CURRENT_LINK"
wp cache flush
wp rewrite flush

run_hook "post-deploy"

# Cleanup old releases
log "Cleaning up old releases..."
cleanup_releases "$RELEASE_DIR" "$KEEP_RELEASES"

# Send notifications
notify_deployment "success" "$ENVIRONMENT" "$RELEASE_ID"

log "=== Deployment Complete ==="
log "Active release: $RELEASE_ID"
log "Site URL: $SITE_URL"

# lib/common.sh - Common utilities

LOG_FILE="$LOG_DIR/deploy-$(date +%Y%m%d).log"

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $@" | tee -a "$LOG_FILE"
}

error() {
    echo "[ERROR] $@" | tee -a "$LOG_FILE" >&2
    notify_deployment "failure" "$ENVIRONMENT" "$RELEASE_ID"
    exit 1
}

run_hook() {
    local hook_name="$1"
    local hook_script="$HOOKS_DIR/${hook_name}.sh"

    if [ -f "$hook_script" ]; then
        log "Running hook: $hook_name"
        bash "$hook_script" "$ENVIRONMENT"
    fi
}

notify_deployment() {
    local status="$1"
    local environment="$2"
    local release="$3"

    # Slack notification
    if [ -n "$SLACK_WEBHOOK" ]; then
        curl -X POST "$SLACK_WEBHOOK" \
            -H 'Content-Type: application/json' \
            -d "{\"text\":\"Deployment $status: $environment ($release)\"}"
    fi

    # Email notification
    if [ -n "$EMAIL_NOTIFICATIONS" ]; then
        echo "Deployment $status on $environment (Release: $release)" | \
            mail -s "WordPress Deployment $status" "$EMAIL_NOTIFICATIONS"
    fi
}

cleanup_releases() {
    local release_dir="$1"
    local keep_count="$2"

    cd "$release_dir"
    ls -t | tail -n +$((keep_count + 1)) | xargs rm -rf
}

# lib/database.sh - Database migration functions

run_migrations() {
    local release_path="$1"
    local migration_dir="$MIGRATIONS_DIR"
    local applied_file="$SHARED_DIR/.applied-migrations"

    touch "$applied_file"

    log "Checking for pending migrations..."

    for migration in $(ls "$migration_dir"/*.sql | sort); do
        local migration_name=$(basename "$migration")

        # Check if already applied
        if grep -q "$migration_name" "$applied_file"; then
            log "  ⊘ Skipping: $migration_name (already applied)"
            continue
        fi

        log "  → Applying: $migration_name"

        # Run migration
        if wp db query < "$migration" --path="$release_path"; then
            echo "$migration_name" >> "$applied_file"
            log "  ✓ Applied: $migration_name"
        else
            error "Migration failed: $migration_name"
        fi
    done

    log "✓ All migrations applied"
}

rollback_migration() {
    local migration_name="$1"
    local rollback_file="$MIGRATIONS_DIR/${migration_name%.sql}-rollback.sql"

    if [ -f "$rollback_file" ]; then
        log "Rolling back migration: $migration_name"
        wp db query < "$rollback_file"
    else
        error "Rollback file not found: $rollback_file"
    fi
}

-- migrations/001-add-custom-tables.sql

CREATE TABLE IF NOT EXISTS wp_custom_data (
    id BIGINT(20) UNSIGNED NOT NULL AUTO_INCREMENT,
    user_id BIGINT(20) UNSIGNED NOT NULL,
    data_key VARCHAR(255) NOT NULL,
    data_value LONGTEXT,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (id),
    KEY user_id (user_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- migrations/001-add-custom-tables-rollback.sql

DROP TABLE IF EXISTS wp_custom_data;

#!/bin/bash
# bin/rollback - Rollback to previous release

set -euo pipefail

source "$(dirname "$0")/../lib/common.sh"

ENVIRONMENT="${1:-staging}"
CONFIG_FILE="$CONFIG_DIR/environments/$ENVIRONMENT.conf"

source "$CONFIG_FILE"

log "=== Starting Rollback ==="

# Get current release
CURRENT=$(readlink "$CURRENT_LINK")
CURRENT_NAME=$(basename "$CURRENT")

log "Current release: $CURRENT_NAME"

# Get previous release
PREVIOUS=$(ls -t "$RELEASE_DIR" | grep -v "^$CURRENT_NAME
quot; | head -n 1)

if [ -z "$PREVIOUS" ]; then
    error "No previous release found for rollback"
fi

PREVIOUS_PATH="$RELEASE_DIR/$PREVIOUS"

log "Rolling back to: $PREVIOUS"

# Backup current state (in case rollback fails)
ROLLBACK_BACKUP="$BACKUP_DIR/pre-rollback-$(date +%Y%m%d_%H%M%S)"
mkdir -p "$ROLLBACK_BACKUP"
wp db export "$ROLLBACK_BACKUP/database.sql.gz" --path="$CURRENT"

# Switch to previous release
ln -nfs "$PREVIOUS_PATH" "$CURRENT_LINK"

# Clear caches
cd "$CURRENT_LINK"
wp cache flush
wp rewrite flush

# Verify rollback
if wp core is-installed --path="$CURRENT_LINK"; then
    log "✓ Rollback successful"
    notify_deployment "rollback-success" "$ENVIRONMENT" "$PREVIOUS"
else
    error "Rollback verification failed"
fi

log "=== Rollback Complete ==="
log "Active release: $PREVIOUS"

#!/bin/bash
# bin/monitor - WordPress health monitoring

set -euo pipefail

source "$(dirname "$0")/../lib/common.sh"

ENVIRONMENT="${1:-production}"
CONFIG_FILE="$CONFIG_DIR/environments/$ENVIRONMENT.conf"

source "$CONFIG_FILE"

check_site_health() {
    local url="$1"
    local response=$(curl -s -o /dev/null -w "%{http_code}" "$url")

    if [ "$response" = "200" ]; then
        log "✓ Site accessible: $url"
        return 0
    else
        error "✗ Site down: $url (HTTP $response)"
        return 1
    fi
}

check_database_connection() {
    if wp db check --path="$CURRENT_LINK"; then
        log "✓ Database connection OK"
        return 0
    else
        error "✗ Database connection failed"
        return 1
    fi
}

check_disk_space() {
    local usage=$(df -h "$DEPLOY_PATH" | awk 'NR==2 {print $5}' | sed 's/%//')

    if [ "$usage" -lt 80 ]; then
        log "✓ Disk space OK ($usage%)"
        return 0
    else
        log "⚠ Disk space warning: $usage%"
        return 1
    fi
}

check_plugin_updates() {
    local updates=$(wp plugin list --update=available --format=count --path="$CURRENT_LINK")

    if [ "$updates" -eq 0 ]; then
        log "✓ All plugins up to date"
    else
        log "⚠ $updates plugin updates available"
    fi
}

# Run all checks
log "=== Health Check: $ENVIRONMENT ==="

FAILED=0

check_site_health "$SITE_URL" || FAILED=$((FAILED + 1))
check_database_connection || FAILED=$((FAILED + 1))
check_disk_space || FAILED=$((FAILED + 1))
check_plugin_updates

if [ "$FAILED" -gt 0 ]; then
    error "$FAILED health checks failed"
else
    log "✓ All health checks passed"
fi

# Add to crontab: crontab -e

# Health check every 5 minutes
*/5 * * * * /opt/wordpress-deploy/bin/monitor production >> /var/log/wp-monitor.log 2>&1

# Daily deployment report
0 9 * * * /opt/wordpress-deploy/bin/report production | mail -s "Daily WordPress Report" team@example.com

#!/bin/bash
# clone-wordpress-site.sh - Clone WordPress site locally

set -euo pipefail

SOURCE_PATH="$1"
DEST_PATH="$2"

if [ -z "$SOURCE_PATH" ] || [ -z "$DEST_PATH" ]; then
    echo "Usage: $0 <source_path> <dest_path>"
    exit 1
fi

echo "Cloning WordPress site..."
echo "Source: $SOURCE_PATH"
echo "Destination: $DEST_PATH"

# Create destination directory
mkdir -p "$DEST_PATH"

# Copy WordPress files
echo "Copying files..."
rsync -av --exclude='wp-content/cache' \
    --exclude='wp-content/backup*' \
    "$SOURCE_PATH/" "$DEST_PATH/"

# Export database from source
echo "Exporting database..."
cd "$SOURCE_PATH"
wp db export /tmp/clone-db.sql

# Create new database config for destination
cd "$DEST_PATH"

# Get source database details
SOURCE_DB=$(wp config get DB_NAME)
SOURCE_USER=$(wp config get DB_USER)
SOURCE_PASS=$(wp config get DB_PASSWORD)

# Create new database
NEW_DB="cloned_${SOURCE_DB}"
mysql -u"$SOURCE_USER" -p"$SOURCE_PASS" -e "CREATE DATABASE IF NOT EXISTS ${NEW_DB};"

# Update wp-config.php
wp config set DB_NAME "$NEW_DB"

# Import database
echo "Importing database..."
wp db import /tmp/clone-db.sql

# Cleanup
rm /tmp/clone-db.sql

# Update URLs if needed
SOURCE_URL=$(wp option get siteurl)
echo "Current site URL: $SOURCE_URL"
read -p "Enter new site URL (or press Enter to keep same): " NEW_URL

if [ -n "$NEW_URL" ]; then
    echo "Updating URLs..."
    wp search-replace "$SOURCE_URL" "$NEW_URL"
    wp option update home "$NEW_URL"
    wp option update siteurl "$NEW_URL"
fi

# Clear caches
wp cache flush
wp rewrite flush

echo "✓ Clone complete: $DEST_PATH"

chmod +x clone-wordpress-site.sh
./clone-wordpress-site.sh /var/www/production /var/www/staging

#!/bin/bash
# migrate-wordpress-remote.sh - Migrate between servers

set -euo pipefail

SOURCE_HOST="$1"
SOURCE_PATH="$2"
DEST_PATH="$3"
OLD_URL="$4"
NEW_URL="$5"

if [ -z "$NEW_URL" ]; then
    echo "Usage: $0 <source_host> <source_path> <dest_path> <old_url> <new_url>"
    echo "Example: $0 user@old-server.com /var/www/html /var/www/html https://oldsite.com https://newsite.com"
    exit 1
fi

TEMP_DIR="/tmp/wp-migration-$"
DATE=$(date +%Y%m%d_%H%M%S)

mkdir -p "$TEMP_DIR"

echo "=== WordPress Remote Migration Started ==="
echo "From: $SOURCE_HOST:$SOURCE_PATH"
echo "To: $DEST_PATH"
echo "URL: $OLD_URL → $NEW_URL"

# Step 1: Export database from source
echo "Step 1/6: Exporting database from source..."
ssh "$SOURCE_HOST" "cd $SOURCE_PATH && wp db export - | gzip" > "$TEMP_DIR/database.sql.gz"

# Verify database export
DB_SIZE=$(stat -c%s "$TEMP_DIR/database.sql.gz")
if [ "$DB_SIZE" -lt 1000 ]; then
    echo "✗ Database export too small, aborting"
    exit 1
fi

# Step 2: Transfer files from source
echo "Step 2/6: Transferring files from source..."
rsync -avz --progress \
    --exclude='wp-content/cache/*' \
    --exclude='wp-content/backup*' \
    "$SOURCE_HOST:$SOURCE_PATH/" "$DEST_PATH/"

# Step 3: Backup destination (if exists)
if [ -d "$DEST_PATH" ]; then
    echo "Step 3/6: Backing up destination..."
    cd "$DEST_PATH"
    if wp core is-installed 2>/dev/null; then
        wp db export "/backups/dest-before-migration-$DATE.sql.gz" || true
    fi
fi

# Step 4: Import database
echo "Step 4/6: Importing database..."
cd "$DEST_PATH"
wp db import "$TEMP_DIR/database.sql.gz"

# Step 5: Update URLs
echo "Step 5/6: Updating URLs..."
wp search-replace "$OLD_URL" "$NEW_URL" --dry-run --report
wp search-replace "$OLD_URL" "$NEW_URL"
wp search-replace "//$(echo $OLD_URL | sed 's~http[s]*://~~')" "//$(echo $NEW_URL | sed 's~http[s]*://~~')"

# Update WordPress options
wp option update home "$NEW_URL"
wp option update siteurl "$NEW_URL"

# Step 6: Verify and cleanup
echo "Step 6/6: Verifying migration..."
if wp core is-installed; then
    echo "✓ WordPress installation verified"
else
    echo "✗ WordPress verification failed"
    exit 1
fi

if wp db check; then
    echo "✓ Database healthy"
else
    echo "✗ Database issues detected"
    exit 1
fi

# Clear caches
wp cache flush
wp rewrite flush

# Cleanup
rm -rf "$TEMP_DIR"

echo "=== Migration Complete ==="
echo "Site URL: $NEW_URL"
echo "Backup: /backups/dest-before-migration-$DATE.sql.gz"

#!/bin/bash
# push-to-production.sh - Push staging to production

STAGING_PATH="/var/www/staging"
PROD_PATH="/var/www/production"
STAGING_URL="https://staging.example.com"
PROD_URL="https://example.com"

read -p "This will overwrite production. Continue? (y/n) " -n 1 -r
echo
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
    exit 0
fi

# Backup production first
cd "$PROD_PATH"
echo "Backing up production..."
wp db export "/backups/prod-$(date +%Y%m%d_%H%M%S).sql.gz"

# Export from staging
cd "$STAGING_PATH"
echo "Exporting staging..."
wp db export /tmp/staging-push.sql.gz

# Copy files
echo "Copying files..."
rsync -av --delete \
    --exclude='wp-config.php' \
    "$STAGING_PATH/" "$PROD_PATH/"

# Import to production
cd "$PROD_PATH"
echo "Importing database..."
wp db import /tmp/staging-push.sql.gz

# Update URLs
echo "Updating URLs for production..."
wp search-replace "$STAGING_URL" "$PROD_URL"
wp option update home "$PROD_URL"
wp option update siteurl "$PROD_URL"

# Clear caches
wp cache flush
wp rewrite flush

# Cleanup
rm /tmp/staging-push.sql.gz

echo "✓ Staging pushed to production"

#!/bin/bash
# selective-clone.sh - Clone only specific components

SOURCE_PATH="$1"
DEST_PATH="$2"
CLONE_TYPE="$3"  # database, files, plugins, themes, uploads

case "$CLONE_TYPE" in
    database)
        echo "Cloning database only..."
        cd "$SOURCE_PATH"
        wp db export /tmp/db-clone.sql.gz
        cd "$DEST_PATH"
        wp db import /tmp/db-clone.sql.gz
        rm /tmp/db-clone.sql.gz
        ;;

    files)
        echo "Cloning files only..."
        rsync -av "$SOURCE_PATH/" "$DEST_PATH/"
        ;;

    plugins)
        echo "Cloning plugins..."
        rsync -av "$SOURCE_PATH/wp-content/plugins/" "$DEST_PATH/wp-content/plugins/"
        ;;

    themes)
        echo "Cloning themes..."
        rsync -av "$SOURCE_PATH/wp-content/themes/" "$DEST_PATH/wp-content/themes/"
        ;;

    uploads)
        echo "Cloning uploads..."
        rsync -av "$SOURCE_PATH/wp-content/uploads/" "$DEST_PATH/wp-content/uploads/"
        ;;

    *)
        echo "Usage: $0 <source> <dest> <database|files|plugins|themes|uploads>"
        exit 1
        ;;
esac

echo "✓ Selective clone complete"

#!/bin/bash
# clone-sanitized.sh - Clone for development, remove sensitive data

SOURCE_PATH="$1"
DEST_PATH="$2"

# Clone site
bash /usr/local/bin/clone-wordpress-site.sh "$SOURCE_PATH" "$DEST_PATH"

cd "$DEST_PATH"

echo "Sanitizing clone for development..."

# Deactivate security plugins
wp plugin deactivate wordfence sucuri-scanner --quiet

# Remove sensitive data
echo "Removing sensitive user data..."

# Anonymize user emails
for user_id in $(wp user list --field=ID); do
    USERNAME=$(wp user get $user_id --field=user_login)
    wp user update $user_id --user_email="${USERNAME}@example.test"
done

# Remove real passwords (force password reset)
for user_id in $(wp user list --field=ID); do
    wp user update $user_id --user_pass="development"
done

# Remove payment gateway credentials
wp option update woocommerce_stripe_settings '{"enabled":"no"}'
wp option update woocommerce_paypal_settings '{"enabled":"no"}'

# Disable external services
wp plugin deactivate google-analytics mailchimp --quiet

# Enable debug mode
wp config set WP_DEBUG true --raw
wp config set WP_DEBUG_LOG true --raw

echo "✓ Clone sanitized for development"

#!/bin/bash
# sync-environments.sh - Sync between dev/staging/prod

OPERATION="$1"  # pull or push
ENV_FROM="$2"   # dev, staging, prod
ENV_TO="$3"     # dev, staging, prod

# Environment paths
declare -A PATHS=(
    ["dev"]="/var/www/dev"
    ["staging"]="/var/www/staging"
    ["prod"]="/var/www/production"
)

# Environment URLs
declare -A URLS=(
    ["dev"]="http://dev.local"
    ["staging"]="https://staging.example.com"
    ["prod"]="https://example.com"
)

if [ -z "$ENV_TO" ]; then
    echo "Usage: $0 <pull|push> <from_env> <to_env>"
    echo "Environments: dev, staging, prod"
    exit 1
fi

SOURCE_PATH="${PATHS[$ENV_FROM]}"
DEST_PATH="${PATHS[$ENV_TO]}"
SOURCE_URL="${URLS[$ENV_FROM]}"
DEST_URL="${URLS[$ENV_TO]}"

echo "Syncing $ENV_FROM → $ENV_TO"

# Confirmation for production
if [ "$ENV_TO" == "prod" ]; then
    read -p "WARNING: Syncing to production. Continue? (y/n) " -n 1 -r
    echo
    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
        exit 0
    fi
fi

# Backup destination
cd "$DEST_PATH"
echo "Backing up $ENV_TO..."
wp db export "/backups/${ENV_TO}-before-sync-$(date +%Y%m%d).sql.gz"

# Clone
cd "$SOURCE_PATH"
wp db export /tmp/env-sync.sql.gz

rsync -av \
    --exclude='wp-config.php' \
    --exclude='wp-content/cache' \
    "$SOURCE_PATH/" "$DEST_PATH/"

cd "$DEST_PATH"
wp db import /tmp/env-sync.sql.gz

# Update URLs
wp search-replace "$SOURCE_URL" "$DEST_URL"
wp option update home "$DEST_URL"
wp option update siteurl "$DEST_URL"

# Clear caches
wp cache flush
wp rewrite flush

rm /tmp/env-sync.sql.gz

echo "✓ Environment sync complete: $ENV_FROM → $ENV_TO"

#!/bin/bash
# verify-clone.sh - Verify WordPress clone

CLONE_PATH="$1"

if [ -z "$CLONE_PATH" ]; then
    echo "Usage: $0 <clone_path>"
    exit 1
fi

cd "$CLONE_PATH"

echo "Verifying WordPress clone..."

# Check WordPress is installed
if ! wp core is-installed 2>/dev/null; then
    echo "✗ WordPress not properly installed"
    exit 1
fi
echo "✓ WordPress installed"

# Check database connection
if ! wp db check 2>/dev/null; then
    echo "✗ Database connection failed"
    exit 1
fi
echo "✓ Database connected"

# Verify post count matches
# (Would need original count passed in for real comparison)
POST_COUNT=$(wp post list --format=count)
echo "✓ Posts: $POST_COUNT"

# Verify user count
USER_COUNT=$(wp user list --format=count)
echo "✓ Users: $USER_COUNT"

# Verify plugins
PLUGIN_COUNT=$(wp plugin list --format=count)
echo "✓ Plugins: $PLUGIN_COUNT"

# Check for broken URLs
SITE_URL=$(wp option get siteurl)
echo "Site URL: $SITE_URL"

# Test site accessibility
if curl -f -s "$SITE_URL" > /dev/null; then
    echo "✓ Site accessible"
else
    echo "✗ Site not accessible"
    exit 1
fi

# Verify file permissions
if [ -w wp-content ]; then
    echo "✓ wp-content writable"
else
    echo "✗ wp-content not writable"
fi

echo "✓ Clone verification complete"