mirror of
https://hk.gh-proxy.com/https://github.com/CaptainCore/do.git
synced 2025-10-03 23:34:10 +08:00
6989 lines
266 KiB
Bash
Executable file
6989 lines
266 KiB
Bash
Executable file
#!/bin/bash
|
||
|
||
# ----------------------------------------------------
|
||
# Command: _do
|
||
# Description: A collection of useful command-line utilities for managing WordPress sites.
|
||
# Author: Austin Ginder
|
||
# License: MIT
|
||
# ----------------------------------------------------
|
||
|
||
# --- Global Variables ---
|
||
CAPTAINCORE_DO_VERSION="1.4"
|
||
GUM_VERSION="0.14.4"
|
||
CWEBP_VERSION="1.5.0"
|
||
RCLONE_VERSION="1.69.3"
|
||
GIT_VERSION="2.50.0"
|
||
GUM_CMD=""
|
||
CWEBP_CMD=""
|
||
IDENTIFY_CMD=""
|
||
WP_CLI_CMD=""
|
||
RESTIC_CMD=""
|
||
DISEMBARK_CMD=""
|
||
|
||
# --- Helper Functions ---
|
||
|
||
# ----------------------------------------------------
|
||
# Intelligently finds or creates a private directory.
|
||
# Sets a global variable CAPTAINCORE_PRIVATE_DIR and echoes the path.
|
||
# ----------------------------------------------------
|
||
function _get_private_dir() {
|
||
# Return immediately if already found
|
||
if [[ -n "$CAPTAINCORE_PRIVATE_DIR" ]]; then
|
||
echo "$CAPTAINCORE_PRIVATE_DIR"
|
||
return 0
|
||
fi
|
||
|
||
local wp_root=""
|
||
local parent_dir=""
|
||
|
||
# --- Tier 1: Preferred WP-CLI Method (if in a WP directory) ---
|
||
# Check if wp-cli is set up and if we are in a WP installation.
|
||
if setup_wp_cli && "$WP_CLI_CMD" core is-installed --quiet 2>/dev/null; then
|
||
local wp_config_path
|
||
wp_config_path=$("$WP_CLI_CMD" config path --quiet 2>/dev/null)
|
||
if [ -n "$wp_config_path" ] && [ -f "$wp_config_path" ]; then
|
||
wp_root=$(dirname "$wp_config_path")
|
||
parent_dir=$(dirname "$wp_root")
|
||
|
||
# --- WPE Specific Checks ---
|
||
# A. Check for _wpeprivate inside the WP root directory first (most common).
|
||
if [ -d "${wp_root}/_wpeprivate" ]; then
|
||
CAPTAINCORE_PRIVATE_DIR="${wp_root}/_wpeprivate"
|
||
echo "$CAPTAINCORE_PRIVATE_DIR"
|
||
return 0
|
||
fi
|
||
# B. Check for _wpeprivate in the parent directory.
|
||
if [ -d "${parent_dir}/_wpeprivate" ]; then
|
||
CAPTAINCORE_PRIVATE_DIR="${parent_dir}/_wpeprivate"
|
||
echo "$CAPTAINCORE_PRIVATE_DIR"
|
||
return 0
|
||
fi
|
||
|
||
# --- Standard Checks (relative to WP root's parent) ---
|
||
# Check for a standard ../private directory
|
||
if [ -d "${parent_dir}/private" ]; then
|
||
CAPTAINCORE_PRIVATE_DIR="${parent_dir}/private"
|
||
echo "$CAPTAINCORE_PRIVATE_DIR"
|
||
return 0
|
||
fi
|
||
# Try to create a ../private directory, suppressing errors
|
||
if mkdir -p "${parent_dir}/private" 2>/dev/null; then
|
||
CAPTAINCORE_PRIVATE_DIR="${parent_dir}/private"
|
||
echo "$CAPTAINCORE_PRIVATE_DIR"
|
||
return 0
|
||
fi
|
||
# Fallback to ../tmp if it exists
|
||
if [ -d "${parent_dir}/tmp" ]; then
|
||
CAPTAINCORE_PRIVATE_DIR="${parent_dir}/tmp"
|
||
echo "$CAPTAINCORE_PRIVATE_DIR"
|
||
return 0
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
# --- Tier 2: Manual Fallback (if WP-CLI fails or not in a WP install) ---
|
||
local current_dir
|
||
current_dir=$(pwd)
|
||
# WPE check in current directory
|
||
if [ -d "${current_dir}/_wpeprivate" ]; then
|
||
CAPTAINCORE_PRIVATE_DIR="${current_dir}/_wpeprivate"
|
||
echo "$CAPTAINCORE_PRIVATE_DIR"
|
||
return 0
|
||
fi
|
||
# Relative private check
|
||
if [ -d "../private" ]; then
|
||
CAPTAINCORE_PRIVATE_DIR=$(cd ../private && pwd)
|
||
echo "$CAPTAINCORE_PRIVATE_DIR"
|
||
return 0
|
||
fi
|
||
# Attempt to create relative private, suppressing errors
|
||
if mkdir -p "../private" 2>/dev/null; then
|
||
CAPTAINCORE_PRIVATE_DIR=$(cd ../private && pwd)
|
||
echo "$CAPTAINCORE_PRIVATE_DIR"
|
||
return 0
|
||
fi
|
||
# Relative tmp check
|
||
if [ -d "../tmp" ]; then
|
||
CAPTAINCORE_PRIVATE_DIR=$(cd ../tmp && pwd)
|
||
echo "$CAPTAINCORE_PRIVATE_DIR"
|
||
return 0
|
||
fi
|
||
|
||
# --- Tier 3: Last Resort Fallback to Home Directory ---
|
||
# Suppress errors in case $HOME is not writable
|
||
if mkdir -p "$HOME/private" 2>/dev/null; then
|
||
CAPTAINCORE_PRIVATE_DIR="$HOME/private"
|
||
echo "$CAPTAINCORE_PRIVATE_DIR"
|
||
return 0
|
||
fi
|
||
|
||
echo "Error: Could not find or create a suitable private, writable directory." >&2
|
||
return 1
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Checks for and installs 'disembark' if not present.
|
||
# Prioritizes standard PATH, then a DISEMBARK_DEV_PATH env var.
|
||
# ----------------------------------------------------
|
||
function setup_disembark() {
|
||
# Return if already found
|
||
if [[ -n "$DISEMBARK_CMD" ]]; then
|
||
return 0
|
||
fi
|
||
|
||
# 1. Check if 'disembark' is in the standard PATH
|
||
if command -v disembark &> /dev/null; then
|
||
echo " - Found 'disembark' in system PATH." >&2
|
||
DISEMBARK_CMD="disembark"
|
||
return 0
|
||
fi
|
||
|
||
# 2. Check for a user-defined development path via environment variable
|
||
if [[ -n "$DISEMBARK_DEV_PATH" && -f "$DISEMBARK_DEV_PATH" && -x "$DISEMBARK_DEV_PATH" ]]; then
|
||
echo " - Found development version of 'disembark' via DISEMBARK_DEV_PATH." >&2
|
||
DISEMBARK_CMD="$DISEMBARK_DEV_PATH"
|
||
return 0
|
||
fi
|
||
|
||
# 3. If not found, attempt to install it system-wide
|
||
echo " Required tool 'disembark' not found. Attempting to install system-wide..." >&2
|
||
|
||
# Check for dependencies needed for the installation
|
||
if ! command -v wget &>/dev/null || ! command -v sudo &>/dev/null; then
|
||
echo " Error: 'wget' and 'sudo' are required to install disembark." >&2
|
||
return 1
|
||
fi
|
||
|
||
local temp_file
|
||
temp_file=$(mktemp)
|
||
|
||
echo " - Downloading disembark.phar..."
|
||
if ! wget -q "https://github.com/DisembarkHost/disembark-cli/raw/main/disembark.phar" -O "$temp_file"; then
|
||
echo " Error: Failed to download disembark.phar." >&2
|
||
rm -f "$temp_file"
|
||
return 1
|
||
fi
|
||
|
||
chmod +x "$temp_file"
|
||
|
||
echo " - Moving to /usr/local/bin/disembark. You may be prompted for your password." >&2
|
||
if ! sudo mv "$temp_file" /usr/local/bin/disembark; then
|
||
echo " Error: Failed to move disembark.phar to /usr/local/bin/." >&2
|
||
rm -f "$temp_file"
|
||
return 1
|
||
fi
|
||
|
||
echo " 'disembark' installed successfully." >&2
|
||
DISEMBARK_CMD="/usr/local/bin/disembark"
|
||
return 0
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Checks for and installs Playwright and its browser dependencies.
|
||
# Sets a global variable PLAYWRIGHT_READY on success.
|
||
# ----------------------------------------------------
|
||
function setup_playwright() {
|
||
# Return if already checked and ready
|
||
if [[ -n "$PLAYWRIGHT_READY" ]]; then
|
||
return 0
|
||
fi
|
||
|
||
# --- Pre-flight Checks ---
|
||
if ! command -v node &>/dev/null; then
|
||
echo "❌ Error: Node.js is required for Playwright." >&2
|
||
return 1
|
||
fi
|
||
if ! command -v npm &>/dev/null; then
|
||
echo "❌ Error: npm is required to install Playwright." >&2
|
||
return 1
|
||
fi
|
||
|
||
# --- Check for Browser Executable ---
|
||
# This is a more robust check. require('playwright') can succeed,
|
||
# but executablePath() will fail if browsers aren't installed.
|
||
if node -e "require('playwright').chromium.executablePath()" >/dev/null 2>&1; then
|
||
echo " - ✅ Playwright and required browsers are already installed."
|
||
PLAYWRIGHT_READY=true
|
||
return 0
|
||
fi
|
||
|
||
# --- Installation ---
|
||
echo " - ⚠️ Playwright or its browsers are missing. Attempting to install now..."
|
||
echo " This may take a few minutes as it downloads the browser binaries."
|
||
|
||
# Step 1: Install the NPM package
|
||
if ! npm install playwright; then
|
||
echo "❌ Error: Failed to install the Playwright npm package." >&2
|
||
echo " Please try running 'npm install playwright' manually in this directory." >&2
|
||
return 1
|
||
fi
|
||
|
||
# Step 2: Install the browser binaries (specifically chromium)
|
||
if ! npx playwright install chromium; then
|
||
echo "❌ Error: Failed to download Playwright's browser binaries." >&2
|
||
echo " Please try running 'npx playwright install chromium' manually." >&2
|
||
return 1
|
||
fi
|
||
|
||
echo " - ✅ Playwright and its browsers installed successfully."
|
||
PLAYWRIGHT_READY=true
|
||
return 0
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Checks for and installs 'gum' if not present. Sets GUM_CMD on success.
|
||
# ----------------------------------------------------
|
||
function setup_gum() {
|
||
# Return if already found
|
||
if [[ -n "$GUM_CMD" ]]; then return 0; fi
|
||
|
||
# If gum is already in the PATH, we're good to go.
|
||
if command -v gum &> /dev/null; then
|
||
GUM_CMD="gum"
|
||
return 0
|
||
fi
|
||
|
||
# Find the private directory for storing tools
|
||
local private_dir
|
||
if ! private_dir=$(_get_private_dir); then
|
||
echo "Error: Cannot find a writable directory to install gum." >&2
|
||
return 1
|
||
fi
|
||
|
||
# Find the executable inside the private directory if it's already installed
|
||
local existing_executable
|
||
existing_executable=$(find "$private_dir" -name gum -type f 2>/dev/null | head -n 1)
|
||
if [ -n "$existing_executable" ] && [ -x "$existing_executable" ] && "$existing_executable" --version &> /dev/null; then
|
||
GUM_CMD="$existing_executable"
|
||
return 0
|
||
fi
|
||
|
||
echo "Required tool 'gum' not found. Installing to '${private_dir}'..." >&2
|
||
local original_dir; original_dir=$(pwd)
|
||
cd "$private_dir" || { echo "Error: Could not enter private directory '${private_dir}'." >&2; return 1; }
|
||
|
||
local gum_dir_name="gum_${GUM_VERSION}_Linux_x86_64"
|
||
local gum_tarball="${gum_dir_name}.tar.gz"
|
||
|
||
if ! curl -sSL "https://github.com/charmbracelet/gum/releases/download/v${GUM_VERSION}/${gum_tarball}" -o "${gum_tarball}"; then
|
||
echo "Error: Failed to download gum." >&2; cd "$original_dir" > /dev/null 2>&1; return 1;
|
||
fi
|
||
|
||
# Find the path of the 'gum' binary WITHIN the tarball before extracting
|
||
local gum_path_in_tar
|
||
gum_path_in_tar=$(tar -tf "${gum_tarball}" | grep '/gum$' | head -n 1)
|
||
|
||
if [ -z "$gum_path_in_tar" ]; then
|
||
echo "Error: Could not find 'gum' executable within the downloaded tarball." >&2
|
||
rm -f "${gum_tarball}"; cd "$original_dir" > /dev/null 2>&1; return 1;
|
||
fi
|
||
|
||
# Now extract the tarball
|
||
if ! tar -xf "${gum_tarball}"; then
|
||
echo "Error: Failed to extract gum from tarball." >&2
|
||
rm -f "${gum_tarball}"; cd "$original_dir" > /dev/null 2>&1; return 1;
|
||
fi
|
||
rm -f "${gum_tarball}"
|
||
|
||
# The full path to the executable is the private dir + the path from the tarball
|
||
local gum_executable="${private_dir}/${gum_path_in_tar}"
|
||
|
||
if [ -f "$gum_executable" ]; then
|
||
chmod +x "$gum_executable"
|
||
else
|
||
echo "Error: gum executable not found at expected path after extraction: ${gum_executable}" >&2
|
||
cd "$original_dir" > /dev/null 2>&1; return 1;
|
||
fi
|
||
|
||
# Final check
|
||
if [ -x "$gum_executable" ] && "$gum_executable" --version &> /dev/null; then
|
||
echo "'gum' installed successfully." >&2
|
||
GUM_CMD="$gum_executable"
|
||
else
|
||
echo "Error: gum installation failed. The binary at ${gum_executable} might not be executable or compatible." >&2
|
||
cd "$original_dir" > /dev/null 2>&1; return 1;
|
||
fi
|
||
|
||
cd "$original_dir" > /dev/null 2>&1; return 0;
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Checks for and installs 'cwebp' if not present. Sets CWEBP_CMD on success.
|
||
# ----------------------------------------------------
|
||
function setup_cwebp() {
|
||
# Return if already found
|
||
if [[ -n "$CWEBP_CMD" ]]; then return 0; fi
|
||
|
||
if command -v cwebp &> /dev/null; then CWEBP_CMD="cwebp"; return 0; fi
|
||
|
||
local private_dir
|
||
if ! private_dir=$(_get_private_dir); then
|
||
echo "Error: Cannot find a writable directory to install cwebp." >&2; return 1;
|
||
fi
|
||
|
||
local existing_executable
|
||
existing_executable=$(find "$private_dir" -name cwebp -type f 2>/dev/null | head -n 1)
|
||
if [ -n "$existing_executable" ] && [ -x "$existing_executable" ] && "$existing_executable" -version &> /dev/null; then
|
||
CWEBP_CMD="$existing_executable"; return 0;
|
||
fi
|
||
|
||
echo "Required tool 'cwebp' not found. Installing to '${private_dir}'..." >&2
|
||
local original_dir; original_dir=$(pwd)
|
||
cd "$private_dir" || { echo "Error: Could not enter private directory '${private_dir}'." >&2; return 1; }
|
||
|
||
local cwebp_dir_name="libwebp-${CWEBP_VERSION}-linux-x86-64"
|
||
local cwebp_tarball="${cwebp_dir_name}.tar.gz"
|
||
|
||
if ! curl -sSL "https://storage.googleapis.com/downloads.webmproject.org/releases/webp/${cwebp_tarball}" -o "${cwebp_tarball}"; then
|
||
echo "Error: Failed to download cwebp." >&2; cd "$original_dir" > /dev/null 2>&1; return 1;
|
||
fi
|
||
|
||
local cwebp_path_in_tar
|
||
cwebp_path_in_tar=$(tar -tf "${cwebp_tarball}" | grep '/bin/cwebp$' | head -n 1)
|
||
if [ -z "$cwebp_path_in_tar" ]; then
|
||
echo "Error: Could not find 'cwebp' executable within the downloaded tarball." >&2
|
||
rm -f "${cwebp_tarball}"; cd "$original_dir" > /dev/null 2>&1; return 1;
|
||
fi
|
||
|
||
if ! tar -xzf "${cwebp_tarball}"; then
|
||
echo "Error: Failed to extract cwebp." >&2; rm -f "${cwebp_tarball}"; cd "$original_dir" > /dev/null 2>&1; return 1;
|
||
fi
|
||
rm -f "${cwebp_tarball}"
|
||
|
||
local cwebp_executable="${private_dir}/${cwebp_path_in_tar}"
|
||
if [ -f "$cwebp_executable" ]; then
|
||
chmod +x "$cwebp_executable";
|
||
else
|
||
echo "Error: cwebp executable not found at expected path: ${cwebp_executable}" >&2; cd "$original_dir" > /dev/null 2>&1; return 1;
|
||
fi
|
||
|
||
if [ -x "$cwebp_executable" ] && "$cwebp_executable" -version &> /dev/null; then
|
||
echo "'cwebp' installed successfully." >&2; CWEBP_CMD="$cwebp_executable";
|
||
else
|
||
echo "Error: cwebp installation failed." >&2; cd "$original_dir" > /dev/null 2>&1; return 1;
|
||
fi
|
||
|
||
cd "$original_dir" > /dev/null 2>&1; return 0;
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Checks for and installs ImageMagick if not present. Sets IDENTIFY_CMD on success.
|
||
# ----------------------------------------------------
|
||
function setup_imagemagick() {
|
||
# Return if already found
|
||
if [[ -n "$IDENTIFY_CMD" ]]; then
|
||
return 0
|
||
fi
|
||
|
||
# If identify is already in the PATH, we're good to go.
|
||
if command -v identify &> /dev/null; then
|
||
IDENTIFY_CMD="identify"
|
||
return 0
|
||
fi
|
||
|
||
local private_dir
|
||
if ! private_dir=$(_get_private_dir); then
|
||
# Error message is handled by the helper function
|
||
return 1
|
||
fi
|
||
|
||
# Define the path where the extracted binary should be
|
||
local identify_executable="${private_dir}/squashfs-root/usr/bin/identify"
|
||
|
||
# Check if we have already extracted it
|
||
if [ -f "$identify_executable" ] && "$identify_executable" -version &> /dev/null; then
|
||
IDENTIFY_CMD="$identify_executable"
|
||
return 0
|
||
fi
|
||
|
||
# If not found, download and extract the AppImage
|
||
echo "Required tool 'identify' not found. Sideloading via AppImage extraction..." >&2
|
||
|
||
local imagemagick_appimage_path="${private_dir}/ImageMagick.AppImage"
|
||
|
||
# Let's use the 'gcc' version as it's a common compiler toolchain for Linux
|
||
local appimage_url="https://github.com/ImageMagick/ImageMagick/releases/download/7.1.1-47/ImageMagick-82572af-gcc-x86_64.AppImage"
|
||
|
||
echo "Downloading from ${appimage_url}..." >&2
|
||
if ! wget --quiet "$appimage_url" -O "$imagemagick_appimage_path"; then
|
||
echo "Error: Failed to download the ImageMagick AppImage." >&2
|
||
rm -f "$imagemagick_appimage_path" # Clean up partial download
|
||
return 1
|
||
fi
|
||
|
||
chmod +x "$imagemagick_appimage_path"
|
||
|
||
# --- EXTRACTION STEP ---
|
||
# This is the key change to work around the FUSE error.
|
||
echo "Extracting AppImage..." >&2
|
||
|
||
# Change into the private directory to contain the extraction
|
||
cd "$private_dir" || { echo "Error: Could not enter private directory." >&2; return 1; }
|
||
|
||
# Run the extraction. This creates a 'squashfs-root' directory.
|
||
if ! ./ImageMagick.AppImage --appimage-extract >/dev/null; then
|
||
echo "Error: Failed to extract the ImageMagick AppImage." >&2
|
||
# Clean up on failure
|
||
rm -f "ImageMagick.AppImage"
|
||
rm -rf "squashfs-root"
|
||
cd - > /dev/null
|
||
return 1
|
||
fi
|
||
|
||
# We don't need the AppImage file anymore after extraction
|
||
rm -f "ImageMagick.AppImage"
|
||
|
||
# Return to the original directory
|
||
cd - > /dev/null
|
||
|
||
# Final check
|
||
if [ -f "$identify_executable" ] && "$identify_executable" -version &> /dev/null; then
|
||
echo "'identify' binary extracted successfully to ${private_dir}/squashfs-root/" >&2
|
||
IDENTIFY_CMD="$identify_executable"
|
||
else
|
||
echo "Error: ImageMagick extraction failed. Could not find the 'identify' executable." >&2
|
||
return 1
|
||
fi
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Checks for and installs 'rclone' if not present. Sets RCLONE_CMD on success.
|
||
# ----------------------------------------------------
|
||
function setup_rclone() {
|
||
# Return if already found
|
||
if [[ -n "$RCLONE_CMD" ]]; then return 0; fi
|
||
|
||
if command -v rclone &> /dev/null; then RCLONE_CMD="rclone"; return 0; fi
|
||
if ! command -v unzip &>/dev/null; then echo "Error: 'unzip' command is required for rclone installation." >&2; return 1; fi
|
||
|
||
local private_dir
|
||
if ! private_dir=$(_get_private_dir); then
|
||
echo "Error: Cannot find a writable directory to install rclone." >&2; return 1;
|
||
fi
|
||
|
||
local existing_executable
|
||
existing_executable=$(find "$private_dir" -name rclone -type f 2>/dev/null | head -n 1)
|
||
if [ -n "$existing_executable" ] && [ -x "$existing_executable" ] && "$existing_executable" --version &> /dev/null; then
|
||
RCLONE_CMD="$existing_executable"; return 0;
|
||
fi
|
||
|
||
echo "Required tool 'rclone' not found. Installing to '${private_dir}'..." >&2
|
||
local original_dir; original_dir=$(pwd)
|
||
cd "$private_dir" || { echo "Error: Could not enter private directory '${private_dir}'." >&2; return 1; }
|
||
|
||
local rclone_zip="rclone-v${RCLONE_VERSION}-linux-amd64.zip"
|
||
if ! curl -sSL "https://github.com/rclone/rclone/releases/download/v${RCLONE_VERSION}/${rclone_zip}" -o "${rclone_zip}"; then
|
||
echo "Error: Failed to download rclone." >&2; cd "$original_dir" > /dev/null 2>&1; return 1;
|
||
fi
|
||
|
||
local rclone_path_in_zip
|
||
rclone_path_in_zip=$(unzip -l "${rclone_zip}" | grep '/rclone$' | awk '{print $4}' | head -n 1)
|
||
if [ -z "$rclone_path_in_zip" ]; then
|
||
echo "Error: Could not find 'rclone' executable within the downloaded zip." >&2
|
||
rm -f "${rclone_zip}"; cd "$original_dir" > /dev/null 2>&1; return 1;
|
||
fi
|
||
|
||
if ! unzip -q -o "${rclone_zip}"; then
|
||
echo "Error: Failed to extract rclone." >&2; rm -f "${rclone_zip}"; cd "$original_dir" > /dev/null 2>&1; return 1;
|
||
fi
|
||
rm -f "${rclone_zip}"
|
||
|
||
local rclone_executable="${private_dir}/${rclone_path_in_zip}"
|
||
if [ -f "$rclone_executable" ]; then
|
||
chmod +x "$rclone_executable";
|
||
else
|
||
echo "Error: rclone executable not found at expected path: ${rclone_executable}" >&2; cd "$original_dir" > /dev/null 2>&1; return 1;
|
||
fi
|
||
|
||
if [ -x "$rclone_executable" ] && "$rclone_executable" --version &> /dev/null; then
|
||
echo "'rclone' installed successfully." >&2; RCLONE_CMD="$rclone_executable";
|
||
else
|
||
echo "Error: rclone installation failed." >&2; cd "$original_dir" > /dev/null 2>&1; return 1;
|
||
fi
|
||
|
||
cd "$original_dir" > /dev/null 2>&1; return 0;
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Checks for and installs 'restic' if not present.
|
||
# Sets RESTIC_CMD on success.
|
||
# ----------------------------------------------------
|
||
function setup_restic() {
|
||
# Return if already found
|
||
if [[ -n "$RESTIC_CMD" ]]; then return 0; fi
|
||
|
||
# If restic is already in the PATH, we're good.
|
||
if command -v restic &> /dev/null; then
|
||
RESTIC_CMD="restic"
|
||
return 0
|
||
fi
|
||
|
||
# Check for local installation in private dir
|
||
local restic_executable="$HOME/private/restic"
|
||
if [ -f "$restic_executable" ] && "$restic_executable" version &> /dev/null; then
|
||
RESTIC_CMD="$restic_executable"
|
||
return 0
|
||
fi
|
||
|
||
# If not found, download it
|
||
echo "Required tool 'restic' not found. Installing..." >&2
|
||
if ! command -v bunzip2 &>/dev/null; then echo "Error: 'bunzip2' command is required for installation." >&2; return 1; fi
|
||
mkdir -p "$HOME/private"
|
||
cd "$HOME/private" || { echo "Error: Could not enter ~/private." >&2; return 1; }
|
||
|
||
local restic_version="0.18.0"
|
||
local restic_archive="restic_${restic_version}_linux_amd64.bz2"
|
||
if ! curl -sL "https://github.com/restic/restic/releases/download/v${restic_version}/${restic_archive}" -o "${restic_archive}"; then
|
||
echo "Error: Failed to download restic." >&2
|
||
cd - > /dev/null
|
||
return 1
|
||
fi
|
||
|
||
# Decompress and extract the binary
|
||
bunzip2 -c "${restic_archive}" > restic_temp && mv restic_temp restic
|
||
rm -f "${restic_archive}"
|
||
chmod +x restic
|
||
|
||
# Final check
|
||
if [ -f "$restic_executable" ] && "$restic_executable" version &> /dev/null; then
|
||
echo "'restic' installed successfully." >&2
|
||
RESTIC_CMD="$restic_executable"
|
||
else
|
||
echo "Error: restic installation failed." >&2
|
||
cd - > /dev/null
|
||
return 1
|
||
fi
|
||
cd - > /dev/null
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Checks for and installs 'git' if not present. Sets GIT_CMD on success.
|
||
# ----------------------------------------------------
|
||
function setup_git() {
|
||
# Return if already found
|
||
if [[ -n "$GIT_CMD" ]]; then
|
||
return 0
|
||
fi
|
||
|
||
# If git is already in the PATH, we're good to go.
|
||
if command -v git &> /dev/null; then
|
||
GIT_CMD="git"
|
||
return 0
|
||
fi
|
||
|
||
# --- Sideloading Logic ---
|
||
echo "Required tool 'git' not found. Attempting to sideload..." >&2
|
||
|
||
local private_dir
|
||
if ! private_dir=$(_get_private_dir); then
|
||
return 1
|
||
fi
|
||
|
||
local git_executable="${private_dir}/git/usr/bin/git"
|
||
|
||
# Check if git has already been sideloaded
|
||
if [ -f "$git_executable" ] && "$git_executable" --version &> /dev/null; then
|
||
echo "'git' found in private directory." >&2
|
||
GIT_CMD="$git_executable"
|
||
return 0
|
||
fi
|
||
|
||
# Check for wget and dpkg-deb, which are required for sideloading
|
||
if ! command -v wget &> /dev/null || ! command -v dpkg-deb &> /dev/null; then
|
||
echo "❌ Error: 'wget' and 'dpkg-deb' are required to sideload git." >&2
|
||
return 1
|
||
fi
|
||
|
||
# Determine OS distribution and version
|
||
if [ -f /etc/os-release ]; then
|
||
. /etc/os-release
|
||
else
|
||
echo "❌ Error: Cannot determine OS distribution. /etc/os-release not found." >&2
|
||
return 1
|
||
fi
|
||
|
||
if [[ "$ID" != "ubuntu" ]]; then
|
||
echo "❌ Error: Sideloading git is currently only supported on Ubuntu." >&2
|
||
return 1
|
||
fi
|
||
|
||
# Construct the download URL for the git package
|
||
# This example uses a recent stable version. You may need to update the version number periodically.
|
||
local git_version="2.47.1-0ppa1~ubuntu16.04.1"
|
||
local git_deb_url="https://launchpad.net/~git-core/+archive/ubuntu/candidate/+build/29298725/+files/git_${git_version}_amd64.deb"
|
||
local git_deb_file="${private_dir}/git_latest.deb"
|
||
|
||
echo "Downloading git from ${git_deb_url}..." >&2
|
||
if ! wget -q -O "$git_deb_file" "$git_deb_url"; then
|
||
echo "❌ Error: Failed to download git .deb package." >&2
|
||
rm -f "$git_deb_file"
|
||
return 1
|
||
fi
|
||
|
||
echo "Extracting git package..." >&2
|
||
local extract_dir="${private_dir}/git"
|
||
mkdir -p "$extract_dir"
|
||
if ! dpkg-deb -x "$git_deb_file" "$extract_dir"; then
|
||
echo "❌ Error: Failed to extract git .deb package." >&2
|
||
rm -rf "$extract_dir"
|
||
rm -f "$git_deb_file"
|
||
return 1
|
||
fi
|
||
|
||
# Clean up the downloaded .deb file
|
||
rm -f "$git_deb_file"
|
||
|
||
# Final check
|
||
if [ -f "$git_executable" ] && "$git_executable" --version &> /dev/null; then
|
||
echo "'git' sideloaded successfully." >&2
|
||
GIT_CMD="$git_executable"
|
||
return 0
|
||
else
|
||
echo "❌ Error: git sideloading failed. The git binary is not available after extraction." >&2
|
||
return 1
|
||
fi
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Checks for and finds the 'wp' command. Sets WP_CLI_CMD on success.
|
||
# ----------------------------------------------------
|
||
function setup_wp_cli() {
|
||
# Return if already found
|
||
if [[ -n "$WP_CLI_CMD" ]]; then return 0; fi
|
||
|
||
# 1. Check if 'wp' is already in the PATH (covers interactive shells)
|
||
if command -v wp &> /dev/null; then
|
||
WP_CLI_CMD="wp"
|
||
return 0
|
||
fi
|
||
|
||
# 2. If not in PATH, check common absolute paths for cron environments
|
||
local common_paths=(
|
||
"/usr/local/bin/wp"
|
||
"$HOME/bin/wp"
|
||
"/opt/wp-cli/wp"
|
||
)
|
||
for path in "${common_paths[@]}"; do
|
||
if [ -x "$path" ]; then
|
||
WP_CLI_CMD="$path"
|
||
return 0
|
||
fi
|
||
done
|
||
|
||
# 3. If still not found, error out
|
||
echo "❌ Error: 'wp' command not found. Please ensure WP-CLI is installed and in your PATH." >&2
|
||
return 1
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# (Helper) Uses PHP to check if a file is a WebP image.
|
||
# ----------------------------------------------------
|
||
function _is_webp_php() {
|
||
local file_path="$1"
|
||
if [ -z "$file_path" ]; then
|
||
return 1 # Return false if no file path is provided
|
||
fi
|
||
|
||
# IMAGETYPE_WEBP has a constant value of 18 in PHP.
|
||
# We will embed the file_path directly into the PHP string.
|
||
local php_code="
|
||
\$file_to_check = '${file_path}';
|
||
if (!file_exists(\$file_to_check)) {
|
||
// Silently exit if file doesn't exist, to avoid warnings.
|
||
exit(1);
|
||
}
|
||
if (function_exists('exif_imagetype')) {
|
||
// The @ suppresses warnings for unsupported file types.
|
||
\$image_type = @exif_imagetype(\$file_to_check);
|
||
if (\$image_type === 18) { // 18 is the constant for IMAGETYPE_WEBP
|
||
exit(0); // Exit with success code (true)
|
||
}
|
||
}
|
||
exit(1); // Exit with failure code (false)
|
||
"
|
||
|
||
if ! setup_wp_cli; then
|
||
if command -v php &> /dev/null; then
|
||
php -r "\$file_path='${file_path}'; ${php_code}"
|
||
return $?
|
||
fi
|
||
return 1
|
||
fi
|
||
|
||
# Execute 'wp eval' with the self-contained code. No extra arguments are needed.
|
||
"$WP_CLI_CMD" eval "$php_code"
|
||
return $?
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# (Primary Checker) Checks if a file is WebP, using identify or PHP fallback.
|
||
# ----------------------------------------------------
|
||
function _is_webp() {
|
||
# Determine which method to use, but only do it once.
|
||
if [[ -z "$IDENTIFY_METHOD" ]]; then
|
||
if command -v identify &> /dev/null; then
|
||
export IDENTIFY_METHOD="identify"
|
||
else
|
||
export IDENTIFY_METHOD="php"
|
||
fi
|
||
fi
|
||
|
||
# Execute the chosen method
|
||
if [[ "$IDENTIFY_METHOD" == "identify" ]]; then
|
||
# Return false if the file doesn't exist to prevent errors.
|
||
if [ ! -f "$1" ]; then return 1; fi
|
||
if [[ "$(identify -format "%m" "$1")" == "WEBP" ]]; then
|
||
return 0 # It is a WebP file
|
||
else
|
||
return 1 # It is not a WebP file
|
||
fi
|
||
else # Fallback to PHP
|
||
if _is_webp_php "$1"; then
|
||
return 0 # It is a WebP file
|
||
else
|
||
return 1 # It is not a WebP file
|
||
fi
|
||
fi
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Displays detailed help for a specific command.
|
||
# ----------------------------------------------------
|
||
function show_command_help() {
|
||
local cmd="$1"
|
||
# If no command is specified, show the general usage.
|
||
if [ -z "$cmd" ]; then
|
||
show_usage
|
||
return
|
||
fi
|
||
|
||
# Display help text based on the command provided.
|
||
case "$cmd" in
|
||
backup)
|
||
echo "Creates a full backup (files + DB) of a WordPress site."
|
||
echo
|
||
echo "Usage: _do backup <folder> [--quiet]"
|
||
echo
|
||
echo "Flags:"
|
||
echo " --exclude=<pattern> A file or folder pattern to exclude, relative to the backup folder."
|
||
echo " Can be used multiple times (e.g., --exclude=\"wp-content/uploads/\")."
|
||
echo " --quiet Suppress all informational output and print only the final backup URL."
|
||
;;
|
||
checkpoint)
|
||
echo "Manages versioned checkpoints of a WordPress installation's manifest."
|
||
echo
|
||
echo "Usage: _do checkpoint <subcommand> [arguments]"
|
||
echo
|
||
echo "Subcommands:"
|
||
echo " create Creates a new checkpoint of the current plugin/theme/core manifest."
|
||
echo " list Lists available checkpoints from the generated list to inspect."
|
||
echo " list-generate Generates a detailed list of all checkpoints for fast viewing."
|
||
echo " revert [<hash>] Reverts the site to the specified checkpoint hash."
|
||
echo " show <hash> Retrieves the details for a specific checkpoint hash."
|
||
echo " latest Gets the hash of the most recent checkpoint."
|
||
;;
|
||
clean)
|
||
echo "Cleans up unused WordPress components or analyzes disk usage."
|
||
echo
|
||
echo "Usage: _do clean <subcommand>"
|
||
echo
|
||
echo "Subcommands:"
|
||
echo " plugins Deletes all inactive plugins."
|
||
echo " themes Deletes all inactive themes except for the latest default WordPress theme."
|
||
echo " disk Provides an interactive disk usage analysis for the current directory."
|
||
;;
|
||
cron)
|
||
echo "Manages scheduled tasks (cron jobs) for this script."
|
||
echo
|
||
echo "Usage: _do cron <subcommand> [arguments]"
|
||
echo
|
||
echo "Subcommands:"
|
||
echo " enable Adds a job to the system crontab to run '_do cron run' every 10 minutes."
|
||
echo " list Lists all scheduled commands."
|
||
echo " run Executes any scheduled commands that are due."
|
||
echo " add \"<cmd>\" \"<time>\" \"<freq>\" Adds a new command to the schedule."
|
||
echo " delete <id> Deletes a command from the schedule."
|
||
echo
|
||
echo "Arguments for 'add':"
|
||
echo " <cmd> (Required) The _do command to run, in quotes (e.g., \"update all\")."
|
||
echo " <time> (Required) The next run time, in quotes (e.g., \"4am\", \"tomorrow 2pm\", \"+2 hours\")."
|
||
echo " <freq> (Required) The frequency, in quotes (e.g., \"1 day\", \"1 week\", \"12 hours\")."
|
||
echo
|
||
echo "Example:"
|
||
echo " _do cron add \"update all\" \"4am\" \"1 day\""
|
||
;;
|
||
db)
|
||
echo "Performs various database operations."
|
||
echo
|
||
echo "Usage: _do db <subcommand>"
|
||
echo
|
||
echo "Subcommands:"
|
||
echo " backup Performs a DB-only backup to a secure private directory."
|
||
echo " check-autoload Checks the size and top 25 largest autoloaded options in the DB."
|
||
echo " optimize Converts tables to InnoDB, reports large tables, and cleans transients."
|
||
echo " change-prefix Changes the database table prefix."
|
||
;;
|
||
disembark)
|
||
echo "Remotely installs the Disembark plugin, connects, and initiates a backup."
|
||
echo
|
||
echo "Usage: _do disembark <url> [--debug]"
|
||
echo
|
||
echo "Arguments:"
|
||
echo " <url> (Required) The full URL to the WordPress site."
|
||
echo
|
||
echo "Flags:"
|
||
echo " --debug Runs the browser automation in headed mode (not headless) for debugging."
|
||
echo
|
||
echo "You will be interactively prompted for an administrator username and password."
|
||
;;
|
||
dump)
|
||
echo "Dumps the content of files matching a pattern into a single text file."
|
||
echo
|
||
echo "Usage: _do dump \"<pattern>\" [-x <exclude_pattern_1>] [-x <exclude_pattern_2>]..."
|
||
echo
|
||
echo "Arguments:"
|
||
echo " <pattern> (Required) The path and file pattern to search for, enclosed in quotes."
|
||
echo
|
||
echo "Flags:"
|
||
echo " -x <pattern> (Optional) A file or directory pattern to exclude. Can be used multiple times."
|
||
echo " To exclude a directory, the pattern MUST end with a forward slash (e.g., 'my-dir/')."
|
||
echo
|
||
echo "Examples:"
|
||
echo " _do dump \"wp-content/plugins/my-plugin/**/*.php\""
|
||
echo " _do dump \"*\" -x \"*.log\" -x \"node_modules/\""
|
||
;;
|
||
email)
|
||
echo "Sends an email using wp_mail via WP-CLI."
|
||
echo
|
||
echo "Usage: _do email"
|
||
echo
|
||
echo "This command will interactively prompt for the recipient, subject, and content."
|
||
;;
|
||
find)
|
||
echo "Finds files or WordPress components based on specific criteria."
|
||
echo
|
||
echo "Usage: _do find <subcommand> [arguments]"
|
||
echo
|
||
echo "Subcommands:"
|
||
echo " recent-files [days] Finds files modified within the last <days>. Defaults to 1 day."
|
||
echo " slow-plugins [path] Identifies plugins slowing down WP-CLI. Optionally check a specific page path (e.g., \"/contact\")."
|
||
echo " hidden-plugins Detects active plugins that may be hidden from the standard list."
|
||
echo " malware Scans for malware and verifies core/plugin file integrity."
|
||
echo " php-tags [dir] Finds outdated PHP short tags ('<?'). Defaults to 'wp-content/'."
|
||
;;
|
||
https)
|
||
echo "Applies HTTPS to all site URLs."
|
||
echo
|
||
echo "Usage: _do https"
|
||
echo
|
||
echo "This command will interactively ask whether to use 'www.' or not in the final URL"
|
||
echo "and then perform a search-and-replace across the entire database."
|
||
;;
|
||
convert-to-webp)
|
||
echo "Finds and converts large images (JPG, PNG) to WebP format."
|
||
echo
|
||
echo "Usage: _do convert-to-webp [folder] [--all]"
|
||
echo
|
||
echo "Arguments:"
|
||
echo " [folder] (Optional) The folder to convert. Defaults to 'wp-content/uploads'."
|
||
echo
|
||
echo "Flags:"
|
||
echo " --all Convert all images, regardless of size. Defaults to images > 1MB."
|
||
;;
|
||
install)
|
||
echo "Installs helper or premium plugins."
|
||
echo
|
||
echo "Usage: _do install <subcommand> [--flags]"
|
||
echo
|
||
echo "Subcommands:"
|
||
echo " kinsta-mu Installs the Kinsta MU plugin. Use --force to install outside a Kinsta environment."
|
||
echo " helper Installs the CaptainCore Helper plugin."
|
||
echo " events-calendar-pro Installs The Events Calendar and its Pro version after prompting for a license."
|
||
;;
|
||
launch)
|
||
echo "Launches a site: updates URL from dev to live, enables search engines, and clears cache."
|
||
echo
|
||
echo "Usage: _do launch [--domain=<domain>]"
|
||
echo
|
||
echo "Flags:"
|
||
echo " --domain=<domain> (Optional) The new domain name. If omitted, you will be prompted interactively."
|
||
;;
|
||
migrate)
|
||
echo "Migrates a site from a backup snapshot."
|
||
echo
|
||
echo "Usage: _do migrate --url=<backup-url> [--update-urls]"
|
||
echo
|
||
echo " --update-urls Update urls to destination WordPress site. Default will keep source urls."
|
||
;;
|
||
monitor)
|
||
echo "Monitors server access logs or errors in real-time."
|
||
echo
|
||
echo "Usage: _do monitor <subcommand> [--flags]"
|
||
echo
|
||
echo "Subcommands:"
|
||
echo " traffic Analyzes and monitors top hits from access logs."
|
||
echo " errors Monitors logs for HTTP 500 and PHP fatal errors."
|
||
echo " access.log Provides a real-time stream of the access log."
|
||
echo " error.log Provides a real-time stream of the error log."
|
||
echo
|
||
echo "Flags for 'traffic':"
|
||
echo " --top=<number> The number of top IP/Status combinations to show. Default is 25."
|
||
echo " --now Start processing from the end of the log file instead of the beginning."
|
||
;;
|
||
php-tags)
|
||
echo "Finds outdated or invalid PHP opening tags in PHP files."
|
||
echo
|
||
echo "Usage: _do php-tags [directory]"
|
||
echo
|
||
echo "Arguments:"
|
||
echo " [directory] (Optional) The directory to search in. Defaults to 'wp-content/'."
|
||
;;
|
||
reset)
|
||
echo "Resets WordPress components or permissions."
|
||
echo
|
||
echo "Usage: _do reset <subcommand> [arguments]"
|
||
echo
|
||
echo "Subcommands:"
|
||
echo " wp Resets the WordPress installation to a default state."
|
||
echo " permissions Resets file and folder permissions to defaults (755 for dirs, 644 for files)."
|
||
;;
|
||
suspend)
|
||
echo "Activates or deactivates a suspend message shown to visitors."
|
||
echo
|
||
echo "Usage: _do suspend <subcommand> [flags]"
|
||
echo
|
||
echo "Subcommands:"
|
||
echo " activate Activates the suspend message. Requires --name and --link flags."
|
||
echo " deactivate Deactivates the suspend message."
|
||
echo
|
||
echo "Flags for 'activate':"
|
||
echo " --name=<business-name> (Required) The name of the business to display."
|
||
echo " --link=<business-link> (Required) The contact link for the business."
|
||
echo " --wp-content=<path> (Optional) Path to wp-content directory. Defaults to 'wp-content'."
|
||
echo
|
||
echo "Flags for 'deactivate':"
|
||
echo " --wp-content=<path> (Optional) Path to wp-content directory. Defaults to 'wp-content'."
|
||
;;
|
||
update)
|
||
echo "Handles WordPress core, theme, and plugin updates."
|
||
echo
|
||
echo "Usage: _do update <subcommand>"
|
||
echo
|
||
echo "Subcommands:"
|
||
echo " all Creates a 'before' checkpoint, runs all updates, creates an"
|
||
echo " 'after' checkpoint, and logs the changes."
|
||
echo " list Shows a list of past updates to inspect from the generated list."
|
||
echo " list-generate Generates a detailed list of all updates for fast viewing."
|
||
;;
|
||
upgrade)
|
||
echo "Upgrades the _do script to the latest version."
|
||
echo
|
||
echo "Usage: _do upgrade"
|
||
;;
|
||
vault)
|
||
echo "Manages secure, full site snapshots in a remote Restic repository."
|
||
echo
|
||
echo "Usage: _do vault <subcommand> [arguments]"
|
||
echo
|
||
echo "Subcommands:"
|
||
echo " create Creates a new snapshot of the current site."
|
||
echo " snapshots [--output] Lists available snapshots. Use --output for a non-interactive list."
|
||
echo " snapshot-info <id> Displays detailed information for a single snapshot."
|
||
echo " delete <id> Deletes a specific snapshot by its ID."
|
||
echo " mount Mounts the entire repository to a local folder for Browse."
|
||
echo " info Displays statistics about the repository."
|
||
echo " prune Removes unnecessary data from the repository."
|
||
echo
|
||
echo "Authentication:"
|
||
echo " This command requires B2 and Restic credentials, provided either by"
|
||
echo " environment variables (B2_ACCOUNT_ID, B2_ACCOUNT_KEY, RESTIC_PASSWORD,"
|
||
echo " B2_BUCKET, B2_PATH) or by piping a 5-line secrets file via stdin."
|
||
echo
|
||
echo "Example (stdin):"
|
||
echo " cat secrets.txt | _do vault snapshots"
|
||
;;
|
||
version)
|
||
echo "Displays the current version of the _do script."
|
||
echo
|
||
echo "Usage: _do version"
|
||
;;
|
||
wpcli)
|
||
echo "Checks for and identifies sources of WP-CLI warnings."
|
||
echo
|
||
echo "Usage: _do wpcli <subcommand>"
|
||
echo
|
||
echo "Subcommands:"
|
||
echo " check Runs a check to find themes or plugins causing WP-CLI warnings."
|
||
;;
|
||
zip)
|
||
echo "Creates a zip archive of a specified folder."
|
||
echo
|
||
echo "Usage: _do zip \"<folder>\""
|
||
echo
|
||
echo "Arguments:"
|
||
echo " <folder> (Required) The folder to be archived."
|
||
echo
|
||
echo "If the folder is a WordPress installation, a public URL to the zip file will be provided."
|
||
echo "Otherwise, the local file path and size will be displayed."
|
||
;;
|
||
*)
|
||
echo "Error: Unknown command '$cmd' for help." >&2
|
||
echo ""
|
||
show_usage
|
||
exit 1
|
||
;;
|
||
esac
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Displays the main help and usage information.
|
||
# ----------------------------------------------------
|
||
function show_usage() {
|
||
echo "CaptainCore _do (v$CAPTAINCORE_DO_VERSION)"
|
||
echo "--------------------------"
|
||
echo "A collection of useful command-line utilities for managing WordPress sites."
|
||
echo ""
|
||
echo "Usage:"
|
||
echo " _do <command> [arguments] [--flags]"
|
||
echo ""
|
||
echo "Available Commands:"
|
||
echo " backup Creates a full backup (files + DB) of a WordPress site."
|
||
echo " checkpoint Manages versioned checkpoints of the site's manifest."
|
||
echo " clean Removes unused items like inactive themes or analyzes disk usage."
|
||
echo " convert-to-webp Finds and converts large images (JPG, PNG) to WebP format."
|
||
echo " cron Manages cron jobs and schedules tasks to run at specific times."
|
||
echo " db Performs various database operations (backup, check-autoload, optimize)."
|
||
echo " disembark Remotely connects to a site to generate a backup."
|
||
echo " dump Dumps the content of files matching a pattern into a single text file."
|
||
echo " email Sends an email using wp_mail via WP-CLI."
|
||
echo " find Finds files, slow plugins, hidden plugins or outdated PHP tags."
|
||
echo " https Applies HTTPS to all site URLs, with an option for www/non-www."
|
||
echo " install Installs helper plugins or premium plugins."
|
||
echo " launch Launches a site to a new domain, using a flag or interactively."
|
||
echo " migrate Migrates a site from a backup URL or local file."
|
||
echo " monitor Monitors server logs or errors in real-time."
|
||
echo " reset Resets WordPress components or permissions."
|
||
echo " suspend Activates or deactivates a suspend message shown to visitors."
|
||
echo " update Runs WordPress updates and logs the changes."
|
||
echo " upgrade Upgrades this script to the latest version."
|
||
echo " vault Manages secure snapshots in a remote Restic repository."
|
||
echo " version Displays the current version of the _do script."
|
||
echo " wpcli Checks for and identifies sources of WP-CLI warnings."
|
||
echo " zip Creates a zip archive of a specified folder."
|
||
echo ""
|
||
echo "Run '_do help <command>' for more information on a specific command."
|
||
}
|
||
|
||
# --- Main Entry Point and Argument Parser ---
|
||
|
||
function main() {
|
||
# If no arguments are provided, show usage and exit.
|
||
if [ $# -eq 0 ]; then
|
||
show_usage
|
||
exit 0
|
||
fi
|
||
|
||
# --- Help Flag Handling ---
|
||
# Detect 'help <command>' pattern
|
||
if [[ "$1" == "help" ]]; then
|
||
show_command_help "$2"
|
||
exit 0
|
||
fi
|
||
|
||
# Detect '<command> --help' pattern
|
||
for arg in "$@"; do
|
||
if [[ "$arg" == "--help" || "$arg" == "-h" ]]; then
|
||
# The first non-flag argument is the command we need help for.
|
||
local help_for_cmd=""
|
||
for inner_arg in "$@"; do
|
||
# Find the first argument that doesn't start with a hyphen.
|
||
if [[ ! "$inner_arg" =~ ^- ]]; then
|
||
help_for_cmd="$inner_arg"
|
||
break
|
||
fi
|
||
done
|
||
show_command_help "$help_for_cmd"
|
||
exit 0
|
||
fi
|
||
done
|
||
|
||
# --- Centralized Argument Parser ---
|
||
# This loop separates flags from commands.
|
||
local url_flag=""
|
||
local top_flag=""
|
||
local name_flag=""
|
||
local link_flag=""
|
||
local wp_content_flag=""
|
||
local update_urls_flag=""
|
||
local now_flag=""
|
||
local admin_user_flag=""
|
||
local path_flag=""
|
||
local all_files_flag=""
|
||
local force_flag=""
|
||
local format_flag=""
|
||
local domain_flag=""
|
||
local output_flag=""
|
||
local exclude_patterns=()
|
||
local backup_exclude_patterns=()
|
||
local positional_args=()
|
||
local quiet_flag=""
|
||
local debug_flag=""
|
||
|
||
while [[ $# -gt 0 ]]; do
|
||
case $1 in
|
||
--url=*)
|
||
url_flag="${1#*=}"
|
||
shift
|
||
;;
|
||
--domain=*)
|
||
domain_flag="${1#*=}"
|
||
shift
|
||
;;
|
||
--top=*)
|
||
top_flag="${1#*=}"
|
||
shift
|
||
;;
|
||
--now)
|
||
now_flag=true
|
||
shift
|
||
;;
|
||
--name=*)
|
||
name_flag="${1#*=}"
|
||
shift
|
||
;;
|
||
--link=*)
|
||
link_flag="${1#*=}"
|
||
shift
|
||
;;
|
||
--wp-content=*)
|
||
wp_content_flag="${1#*=}"
|
||
shift
|
||
;;
|
||
--update-urls)
|
||
update_urls_flag=true
|
||
shift
|
||
;;
|
||
--admin_user=*)
|
||
admin_user_flag="${1#*=}"
|
||
shift
|
||
;;
|
||
--all)
|
||
all_files_flag=true
|
||
shift
|
||
;;
|
||
--force)
|
||
force_flag=true
|
||
shift
|
||
;;
|
||
--format=*)
|
||
format_flag="${1#*=}"
|
||
shift
|
||
;;
|
||
--output)
|
||
output_flag=true
|
||
shift
|
||
;;
|
||
--path=*)
|
||
path_flag="${1#*=}"
|
||
shift
|
||
;;
|
||
-x) # Exclude flag
|
||
if [[ -n "$2" ]]; then
|
||
exclude_patterns+=("$2")
|
||
shift 2 # past flag and value
|
||
else
|
||
echo "Error: -x flag requires an argument." >&2
|
||
exit 1
|
||
fi
|
||
;;
|
||
--exclude=*)
|
||
backup_exclude_patterns+=("${1#*=}")
|
||
shift
|
||
;;
|
||
--quiet)
|
||
quiet_flag=true
|
||
shift
|
||
;;
|
||
--debug)
|
||
debug_flag=true
|
||
shift
|
||
;;
|
||
-*)
|
||
# This will catch unknown flags like --foo
|
||
echo "Error: Unknown flag: $1" >&2
|
||
show_usage
|
||
exit 1
|
||
;;
|
||
*)
|
||
# It's a command or a positional argument
|
||
positional_args+=("$1")
|
||
shift # past argument
|
||
;;
|
||
esac
|
||
done
|
||
|
||
# --- Global Path Handling ---
|
||
# If a path is provided, change to that directory first.
|
||
# This allows commands to be run from anywhere for a specific site.
|
||
if [[ -n "$path_flag" ]]; then
|
||
if [ -d "$path_flag" ]; then
|
||
cd "$path_flag" || { echo "❌ Error: Could not change directory to '$path_flag'." >&2; exit 1; }
|
||
else
|
||
echo "❌ Error: Provided path '$path_flag' does not exist." >&2
|
||
exit 1
|
||
fi
|
||
fi
|
||
|
||
# The first positional argument is the main command.
|
||
local command="${positional_args[0]}"
|
||
|
||
# --- Command Router ---
|
||
# This routes to the correct function based on the parsed command.
|
||
case "$command" in
|
||
backup)
|
||
full_backup "${positional_args[1]}" "$quiet_flag" "$format_flag" "${backup_exclude_patterns[@]}"
|
||
;;
|
||
checkpoint)
|
||
local subcommand="${positional_args[1]}"
|
||
case "$subcommand" in
|
||
create)
|
||
checkpoint_create
|
||
;;
|
||
list)
|
||
checkpoint_list
|
||
;;
|
||
list-generate)
|
||
checkpoint_list_generate
|
||
;;
|
||
revert)
|
||
local hash="${positional_args[2]}"
|
||
checkpoint_revert "$hash"
|
||
;;
|
||
show)
|
||
local hash="${positional_args[2]}"
|
||
checkpoint_show "$hash"
|
||
;;
|
||
latest)
|
||
checkpoint_latest
|
||
;;
|
||
*)
|
||
show_command_help "checkpoint"
|
||
exit 0
|
||
;;
|
||
esac
|
||
;;
|
||
clean)
|
||
local arg1="${positional_args[1]}"
|
||
case "$arg1" in
|
||
plugins)
|
||
clean_plugins
|
||
;;
|
||
themes)
|
||
clean_themes
|
||
;;
|
||
disk)
|
||
clean_disk
|
||
;;
|
||
*)
|
||
show_command_help "clean"
|
||
exit 0
|
||
;;
|
||
esac
|
||
;;
|
||
cron)
|
||
local subcommand="${positional_args[1]}"
|
||
case "$subcommand" in
|
||
enable)
|
||
cron_enable
|
||
;;
|
||
list)
|
||
cron_list
|
||
;;
|
||
run)
|
||
cron_run
|
||
;;
|
||
add)
|
||
cron_add "${positional_args[2]}" "${positional_args[3]}" "${positional_args[4]}"
|
||
;;
|
||
delete)
|
||
cron_delete "${positional_args[2]}"
|
||
;;
|
||
*)
|
||
show_command_help "cron"
|
||
exit 0
|
||
;;
|
||
esac
|
||
;;
|
||
convert-to-webp)
|
||
# Pass the optional folder (positional_args[1]) and the --all flag
|
||
convert_to_webp "${positional_args[1]}" "$all_files_flag"
|
||
;;
|
||
db)
|
||
local arg1="${positional_args[1]}"
|
||
case "$arg1" in
|
||
backup)
|
||
db_backup # Originally from backup-db command
|
||
;;
|
||
check-autoload)
|
||
db_check_autoload # Originally from db-check-autoload command
|
||
;;
|
||
optimize)
|
||
db_optimize # Originally from db-optimize command
|
||
;;
|
||
change-prefix)
|
||
db_change_prefix
|
||
;;
|
||
*)
|
||
show_command_help "db"
|
||
exit 0
|
||
;;
|
||
esac
|
||
;;
|
||
disembark)
|
||
run_disembark "${positional_args[1]}" "$debug_flag"
|
||
;;
|
||
dump)
|
||
# There should be exactly 2 positional args total: 'dump' and the pattern.
|
||
if [ ${#positional_args[@]} -ne 2 ]; then
|
||
echo -e "Error: Incorrect number of arguments for 'dump'. It's likely your pattern was expanded by the shell." >&2
|
||
echo "Please wrap the input pattern in double quotes." >&2
|
||
echo -e "\n Usage: _do dump \"<pattern>\" [-x <exclude1>...]" >&2
|
||
return 1
|
||
fi
|
||
run_dump "${positional_args[1]}" "${exclude_patterns[@]}"
|
||
;;
|
||
email)
|
||
run_email
|
||
;;
|
||
find)
|
||
local subcommand="${positional_args[1]}"
|
||
case "$subcommand" in
|
||
recent-files)
|
||
find_recent_files "${positional_args[2]}"
|
||
;;
|
||
slow-plugins)
|
||
find_slow_plugins "${positional_args[2]}"
|
||
;;
|
||
hidden-plugins)
|
||
find_hidden_plugins
|
||
;;
|
||
malware)
|
||
find_malware
|
||
;;
|
||
php-tags)
|
||
find_outdated_php_tags "${positional_args[2]}"
|
||
;;
|
||
*)
|
||
show_command_help "find"
|
||
exit 0
|
||
;;
|
||
esac
|
||
;;
|
||
https)
|
||
run_https
|
||
;;
|
||
install)
|
||
local subcommand="${positional_args[1]}"
|
||
case "$subcommand" in
|
||
kinsta-mu)
|
||
install_kinsta_mu "$force_flag"
|
||
;;
|
||
helper)
|
||
install_helper
|
||
;;
|
||
events-calendar-pro)
|
||
install_events_calendar_pro
|
||
;;
|
||
*)
|
||
show_command_help "install"
|
||
exit 0
|
||
;;
|
||
esac
|
||
;;
|
||
launch)
|
||
run_launch "$domain_flag"
|
||
;;
|
||
migrate)
|
||
if [[ -z "$url_flag" ]]; then
|
||
echo "Error: The 'migrate' command requires the --url=<...> flag." >&2
|
||
show_command_help "migrate"
|
||
exit 1
|
||
fi
|
||
migrate_site "$url_flag" "$update_urls_flag"
|
||
;;
|
||
monitor)
|
||
local arg1="${positional_args[1]}"
|
||
case "$arg1" in
|
||
traffic)
|
||
monitor_traffic "$top_flag" "$now_flag"
|
||
;;
|
||
errors)
|
||
monitor_errors
|
||
;;
|
||
access.log)
|
||
monitor_access_log
|
||
;;
|
||
error.log)
|
||
monitor_error_log
|
||
;;
|
||
*)
|
||
show_command_help "monitor"
|
||
exit 0
|
||
;;
|
||
esac
|
||
;;
|
||
php-tags)
|
||
find_outdated_php_tags "${positional_args[1]}"
|
||
;;
|
||
reset)
|
||
local subcommand="${positional_args[1]}"
|
||
case "$subcommand" in
|
||
wp)
|
||
reset_wp "$admin_user_flag"
|
||
;;
|
||
permissions)
|
||
reset_permissions
|
||
;;
|
||
*)
|
||
show_command_help "reset"
|
||
exit 0
|
||
;;
|
||
esac
|
||
;;
|
||
suspend)
|
||
local arg1="${positional_args[1]}"
|
||
case "$arg1" in
|
||
activate)
|
||
suspend_activate "$name_flag" "$link_flag" "$wp_content_flag"
|
||
;;
|
||
deactivate)
|
||
suspend_deactivate "$wp_content_flag"
|
||
;;
|
||
*)
|
||
show_command_help "suspend"
|
||
exit 0
|
||
;;
|
||
esac
|
||
;;
|
||
update)
|
||
local subcommand="${positional_args[1]}"
|
||
case "$subcommand" in
|
||
all)
|
||
run_update_all
|
||
;;
|
||
list)
|
||
update_list
|
||
;;
|
||
list-generate)
|
||
update_list_generate
|
||
;;
|
||
*)
|
||
show_command_help "update"
|
||
exit 1
|
||
;;
|
||
esac
|
||
;;
|
||
upgrade)
|
||
run_upgrade
|
||
;;
|
||
vault)
|
||
local subcommand="${positional_args[1]}" # Default to snapshots
|
||
case "$subcommand" in
|
||
create)
|
||
vault_create
|
||
;;
|
||
delete)
|
||
local snapshot_id_to_delete="${positional_args[2]}"
|
||
vault_delete "$snapshot_id_to_delete"
|
||
;;
|
||
snapshot-info)
|
||
local snapshot_id_to_show="${positional_args[2]}"
|
||
vault_snapshot_info "$snapshot_id_to_show"
|
||
;;
|
||
snapshots)
|
||
vault_snapshots "$output_flag"
|
||
;;
|
||
mount)
|
||
vault_mount
|
||
;;
|
||
info)
|
||
vault_info
|
||
;;
|
||
prune)
|
||
vault_prune
|
||
;;
|
||
*)
|
||
show_command_help "vault" >&2
|
||
exit 0
|
||
;;
|
||
esac
|
||
;;
|
||
version|--version|-v)
|
||
show_version
|
||
;;
|
||
wpcli)
|
||
local subcommand="${positional_args[1]}"
|
||
case "$subcommand" in
|
||
check)
|
||
wpcli_check
|
||
;;
|
||
*)
|
||
show_command_help "wpcli"
|
||
exit 0
|
||
;;
|
||
esac
|
||
;;
|
||
zip)
|
||
run_zip "${positional_args[1]}"
|
||
;;
|
||
*)
|
||
echo "Error: Unknown command '$command'." >&2
|
||
show_usage
|
||
exit 1
|
||
;;
|
||
esac
|
||
}
|
||
|
||
# Pass all script arguments to the main function.
|
||
|
||
# --- Sourced Command Functions ---
|
||
# The following functions are sourced from the 'commands/' directory.
|
||
|
||
# ----------------------------------------------------
|
||
# Creates a full backup of a WordPress site (files + database).
|
||
# ----------------------------------------------------
|
||
function full_backup() {
|
||
# --- 1. Argument Parsing ---
|
||
local target_folder="$1"
|
||
local quiet_flag="$2"
|
||
local format_flag="$3"
|
||
shift 3 # Move past the first two arguments
|
||
local exclude_patterns=("$@") # The rest of the arguments are the exclude patterns
|
||
|
||
# --- 2. Validation ---
|
||
if [ -z "$target_folder" ]
|
||
then echo "Error: Please provide a folder path." >&2; echo "Usage: _do backup <folder>" >&2; return 1;
|
||
fi
|
||
if ! command -v realpath &> /dev/null; then echo "Error: 'realpath' command not found. Please install it." >&2; return 1; fi
|
||
if [ ! -d "$target_folder" ]; then echo "Error: Folder '$target_folder' not found." >&2; return 1; fi
|
||
|
||
# --- 3. Setup Paths and Filenames ---
|
||
# Resolve the absolute path to handle cases like "."
|
||
local full_target_path; full_target_path=$(realpath "$target_folder")
|
||
local parent_dir; parent_dir=$(dirname "$full_target_path")
|
||
local site_dir_name; site_dir_name=$(basename "$full_target_path")
|
||
|
||
local today; today=$(date +"%Y-%m-%d")
|
||
local random; random=$(openssl rand -hex 4 | head -c 7)
|
||
local backup_filename="${today}_${random}.zip"
|
||
local original_dir; original_dir=$(pwd)
|
||
|
||
# Change to the parent directory for consistent relative paths in the zip
|
||
cd "$parent_dir" || return 1
|
||
|
||
# --- 4. Database Export ---
|
||
if ! setup_wp_cli; then echo "Error: wp-cli is not installed." >&2; cd "$original_dir"; return 1; fi
|
||
local home_url; home_url=$("$WP_CLI_CMD" option get home --path="$site_dir_name" --skip-plugins --skip-themes)
|
||
local name; name=$("$WP_CLI_CMD" option get blogname --path="$site_dir_name" --skip-plugins --skip-themes)
|
||
local database_file="db_export.sql"
|
||
|
||
if [[ "$quiet_flag" != "true" ]]; then
|
||
echo "Exporting database for '$name'...";
|
||
fi
|
||
if ! "$WP_CLI_CMD" db export "$site_dir_name/$database_file" --path="$site_dir_name" --add-drop-table --default-character-set=utf8mb4 > /dev/null; then
|
||
echo "Error: Database export failed." >&2
|
||
cd "$original_dir"
|
||
return 1
|
||
fi
|
||
if [[ "$quiet_flag" != "true" ]]; then
|
||
echo "Creating zip archive...";
|
||
if [ ${#exclude_patterns[@]} -gt 0 ]; then
|
||
echo "Excluding the following patterns:"
|
||
for pattern in "${exclude_patterns[@]}"; do
|
||
echo " - $pattern"
|
||
done
|
||
fi
|
||
fi
|
||
|
||
# --- 5. Zip Archive Creation ---
|
||
local zip_exclude_args=()
|
||
zip_exclude_args+=(-x "$site_dir_name/wp-content/updraft/*") # Add default exclude
|
||
for pattern in "${exclude_patterns[@]}"; do
|
||
zip_exclude_args+=(-x "$site_dir_name/$pattern*") # Add user-defined excludes
|
||
done
|
||
# Create the zip in the parent directory, zipping the site directory
|
||
if ! zip -r "$backup_filename" "$site_dir_name" "${zip_exclude_args[@]}" > /dev/null; then
|
||
echo "Error: Failed to zip files." >&2
|
||
rm -f "$site_dir_name/$database_file"
|
||
cd "$original_dir"
|
||
return 1
|
||
fi
|
||
|
||
# Add wp-config.php if it exists in the site directory
|
||
if [ -f "$site_dir_name/wp-config.php" ]; then
|
||
zip "$backup_filename" "$site_dir_name/wp-config.php" > /dev/null
|
||
fi
|
||
|
||
# --- 6. Cleanup and Final Report ---
|
||
local size
|
||
size=$(ls -lh "$backup_filename" | awk '{print $5}')
|
||
rm -f "$site_dir_name/$database_file"
|
||
mv "$backup_filename" "$site_dir_name/"
|
||
|
||
local final_backup_location="$site_dir_name/$backup_filename"
|
||
|
||
cd "$original_dir"
|
||
local final_backup_location="$full_target_path/$backup_filename"
|
||
local final_url="${home_url}/${backup_filename}"
|
||
|
||
if [[ "$format_flag" == "filename" ]]; then
|
||
echo "$backup_filename"
|
||
return 0
|
||
fi
|
||
if [[ "$quiet_flag" == "true" ]]; then
|
||
echo "$final_url"
|
||
return 0
|
||
fi
|
||
|
||
echo "-----------------------------------------------------"
|
||
echo "✅ Full site backup complete!"
|
||
echo " Name: $name"
|
||
echo " Location: $final_backup_location"
|
||
echo " Size: $size"
|
||
echo " URL: $final_url"
|
||
echo "-----------------------------------------------------"
|
||
echo "When done, remember to remove the backup file."
|
||
echo "rm -f \"$final_backup_location\""
|
||
}
|
||
# ----------------------------------------------------
|
||
# Checkpoint Commands
|
||
# Manages versioned checkpoints of the site's manifest.
|
||
# ----------------------------------------------------
|
||
|
||
# --- Checkpoint Base Directory ---
|
||
CHECKPOINT_BASE_DIR=""
|
||
CHECKPOINT_REPO_DIR=""
|
||
CHECKPOINT_LIST_FILE=""
|
||
|
||
# ----------------------------------------------------
|
||
# (Helper) Reverts a specific item's files to a given checkpoint hash.
|
||
# ----------------------------------------------------
|
||
function _revert_item_to_hash() {
|
||
local item_type="$1" # "plugin" or "theme"
|
||
local item_name="$2" # e.g., "akismet"
|
||
local target_hash="$3" # The git hash to revert to
|
||
local wp_content_dir="$4" # The live wp-content directory
|
||
local repo_dir="$5" # The path to the checkpoint git repo
|
||
local current_hash="$6" # The hash we are reverting FROM (for cleanup)
|
||
|
||
# Define paths
|
||
local item_path_in_repo="${item_type}s/${item_name}"
|
||
local restored_source_path="${repo_dir}/${item_path_in_repo}/"
|
||
local live_item_path="${wp_content_dir}/${item_type}s/${item_name}"
|
||
|
||
echo "Reverting '$item_name' files to state from checkpoint ${target_hash:0:7}..."
|
||
|
||
# Use git to restore the files *within the checkpoint repo*
|
||
"$GIT_CMD" -C "$repo_dir" checkout "$target_hash" -- "$item_path_in_repo" &>/dev/null
|
||
if [ $? -ne 0 ]; then
|
||
echo "❌ Error: git checkout failed. Could not restore files from checkpoint." >&2
|
||
# Clean up by checking out the original state before we messed with it
|
||
"$GIT_CMD" -C "$repo_dir" checkout "$current_hash" -- "$item_path_in_repo" &>/dev/null
|
||
return 1
|
||
fi
|
||
|
||
# Sync the restored files from the repo back to the live site
|
||
echo "Syncing restored files to the live site..."
|
||
|
||
# If the path no longer exists in the reverted repo state, it should be deleted from the live site.
|
||
if [ ! -e "${repo_dir}/${item_path_in_repo}" ]; then
|
||
echo " - Item did not exist in target checkpoint. Removing from live site..."
|
||
if [ -e "$live_item_path" ]; then
|
||
rm -rf "$live_item_path"
|
||
echo " ✅ Removed '$live_item_path'."
|
||
else
|
||
echo " - Already absent from live site. No action needed."
|
||
fi
|
||
else
|
||
# The item existed. Sync it to the live site. This handles both updates and re-additions.
|
||
echo " - Item existed in target checkpoint. Syncing files..."
|
||
rsync -a --delete "$restored_source_path" "$live_item_path/"
|
||
echo " ✅ Synced files to '$live_item_path/'."
|
||
fi
|
||
|
||
# IMPORTANT: Revert the repo back to the original hash so it remains consistent.
|
||
# This resets the state of the repo, leaving only the live files changed.
|
||
"$GIT_CMD" -C "$repo_dir" checkout "$current_hash" -- "$item_path_in_repo" &>/dev/null
|
||
|
||
echo "✅ Revert complete for '$item_name'."
|
||
echo "💡 Note: This action reverts files only. Database or activation status changes are not affected."
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Ensures checkpoint directories and lists exist.
|
||
# ----------------------------------------------------
|
||
function _ensure_checkpoint_setup() {
|
||
# Exit if already initialized
|
||
if [[ -n "$CHECKPOINT_BASE_DIR" ]]; then return 0; fi
|
||
|
||
local private_dir
|
||
if ! private_dir=$(_get_private_dir); then
|
||
return 1
|
||
fi
|
||
|
||
CHECKPOINT_BASE_DIR="${private_dir}/checkpoints"
|
||
CHECKPOINT_REPO_DIR="$CHECKPOINT_BASE_DIR/repo"
|
||
CHECKPOINT_LIST_FILE="$CHECKPOINT_BASE_DIR/list.json"
|
||
|
||
mkdir -p "$CHECKPOINT_REPO_DIR"
|
||
if [ ! -f "$CHECKPOINT_LIST_FILE" ]; then
|
||
echo "[]" > "$CHECKPOINT_LIST_FILE"
|
||
fi
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Generates a JSON manifest of the current WP state and saves it to a file.
|
||
# ----------------------------------------------------
|
||
function _generate_manifest() {
|
||
local output_file="$1"
|
||
if [ -z "$output_file" ]; then
|
||
echo "Error: No output file provided to _generate_manifest." >&2
|
||
return 1
|
||
fi
|
||
|
||
local core_version; core_version=$("$WP_CLI_CMD" core version --skip-plugins --skip-themes)
|
||
local plugins; plugins=$("$WP_CLI_CMD" plugin list --fields=name,title,status,version,auto_update --format=json --skip-plugins --skip-themes)
|
||
local themes; themes=$("$WP_CLI_CMD" theme list --fields=name,title,status,version,auto_update --format=json --skip-plugins --skip-themes)
|
||
|
||
# Manually create JSON to avoid extra dependencies
|
||
cat <<EOF > "$output_file"
|
||
{
|
||
"core": "$core_version",
|
||
"plugins": $plugins,
|
||
"themes": $themes
|
||
}
|
||
EOF
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Creates a new checkpoint.
|
||
# ----------------------------------------------------
|
||
function checkpoint_create() {
|
||
if ! setup_git; then return 1; fi
|
||
if ! setup_wp_cli; then echo "❌ Error: WP-CLI not found." >&2; return 1; fi
|
||
if ! command -v rsync &>/dev/null; then echo "❌ Error: rsync command not found." >&2; return 1; fi
|
||
|
||
_ensure_checkpoint_setup
|
||
|
||
echo "🚀 Creating new checkpoint..."
|
||
|
||
# Get wp-content path
|
||
local wp_content_dir
|
||
wp_content_dir=$("$WP_CLI_CMD" eval "echo rtrim(WP_CONTENT_DIR, '/');" --skip-plugins --skip-themes 2>/dev/null)
|
||
if [ -z "$wp_content_dir" ] || [ ! -d "$wp_content_dir" ]; then
|
||
echo "❌ Error: Could not determine wp-content directory." >&2
|
||
return 1
|
||
fi
|
||
echo " - Found wp-content at: $wp_content_dir"
|
||
|
||
# Sync files
|
||
echo " - Syncing themes, plugins, and mu-plugins..."
|
||
mkdir -p "$CHECKPOINT_REPO_DIR/themes" "$CHECKPOINT_REPO_DIR/plugins" "$CHECKPOINT_REPO_DIR/mu-plugins"
|
||
|
||
# Use rsync to copy directories. The trailing slashes are important.
|
||
rsync -a --delete --exclude='*.zip' --exclude='logs/' --exclude='.git/' "$wp_content_dir/themes/" "$CHECKPOINT_REPO_DIR/themes/"
|
||
rsync -a --delete --exclude='*.zip' --exclude='logs/' --exclude='.git/' "$wp_content_dir/plugins/" "$CHECKPOINT_REPO_DIR/plugins/"
|
||
if [ -d "$wp_content_dir/mu-plugins" ]; then
|
||
rsync -a --delete --exclude='*.zip' --exclude='logs/' --exclude='.git/' "$wp_content_dir/mu-plugins/" "$CHECKPOINT_REPO_DIR/mu-plugins/"
|
||
fi
|
||
|
||
local manifest_file="$CHECKPOINT_REPO_DIR/manifest.json"
|
||
|
||
echo " - Generating manifest..."
|
||
if ! _generate_manifest "$manifest_file"; then
|
||
echo "❌ Error: Failed to generate manifest file." >&2
|
||
return 1
|
||
fi
|
||
|
||
# Initialize git repo if it doesn't exist
|
||
if [ ! -d "$CHECKPOINT_REPO_DIR/.git" ]; then
|
||
echo " - Initializing checkpoint repository..."
|
||
"$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" init -b main > /dev/null
|
||
fi
|
||
|
||
echo " - Committing changes to repository..."
|
||
# Add all changes (manifest + files)
|
||
"$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" add .
|
||
# Check if there are changes to commit
|
||
if "$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" diff --staged --quiet; then
|
||
echo "✅ No changes detected. Checkpoint is up-to-date."
|
||
local latest_hash; latest_hash=$("$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" rev-parse HEAD 2>/dev/null)
|
||
if [ -n "$latest_hash" ]; then
|
||
echo " Latest Hash: $latest_hash"
|
||
fi
|
||
return 0
|
||
fi
|
||
|
||
# Set a default author identity for the commit to prevent errors on remote systems
|
||
# where git might not be configured. This is a local config for this repo only.
|
||
"$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" config user.email "script@captaincore.io"
|
||
"$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" config user.name "_do Script"
|
||
|
||
local timestamp; timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
|
||
"$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" commit -m "Checkpoint $timestamp" > /dev/null
|
||
if [ $? -ne 0 ]; then
|
||
echo "❌ Error: Failed to commit checkpoint changes." >&2
|
||
return 1
|
||
fi
|
||
|
||
local commit_hash; commit_hash=$("$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" rev-parse HEAD)
|
||
if [ -z "$commit_hash" ]; then
|
||
echo "❌ Error: Could not retrieve commit hash after creating checkpoint." >&2
|
||
return 1
|
||
fi
|
||
|
||
local checkpoint_file="$CHECKPOINT_BASE_DIR/$commit_hash.json"
|
||
|
||
echo " - Saving checkpoint details..."
|
||
printf '{\n "hash": "%s",\n "timestamp": "%s"\n}\n' "$commit_hash" "$timestamp" > "$checkpoint_file"
|
||
|
||
# Safely update the JSON list file using a PHP script
|
||
local php_code_template='
|
||
<?php
|
||
$list_file = "%s";
|
||
$hash = "%s";
|
||
$timestamp = "%s";
|
||
$list = file_exists($list_file) ? json_decode(file_get_contents($list_file), true) : [];
|
||
if (!is_array($list)) { $list = []; }
|
||
$new_entry = ["hash" => $hash, "timestamp" => $timestamp];
|
||
array_unshift($list, $new_entry);
|
||
echo json_encode($list, JSON_PRETTY_PRINT);
|
||
'
|
||
local php_script; php_script=$(printf "$php_code_template" "$CHECKPOINT_LIST_FILE" "$commit_hash" "$timestamp")
|
||
|
||
local temp_list_file; temp_list_file=$(mktemp)
|
||
if echo "$php_script" | "$WP_CLI_CMD" eval-file - > "$temp_list_file"; then
|
||
mv "$temp_list_file" "$CHECKPOINT_LIST_FILE"
|
||
else
|
||
echo "❌ Error: Failed to update checkpoint list." >&2
|
||
rm "$temp_list_file"
|
||
fi
|
||
|
||
echo "✅ Checkpoint created successfully."
|
||
echo " Hash: $commit_hash"
|
||
|
||
# Automatically regenerate the detailed checkpoint list
|
||
echo " - Regenerating detailed checkpoint list..."
|
||
checkpoint_list_generate > /dev/null
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Generates a detailed list of checkpoints for faster access.
|
||
# ----------------------------------------------------
|
||
function checkpoint_list_generate() {
|
||
if ! setup_gum || ! setup_git; then return 1; fi
|
||
if ! setup_wp_cli; then return 1; fi
|
||
_ensure_checkpoint_setup
|
||
|
||
# Read the potentially simple list created by `checkpoint create`
|
||
local php_script_read_list='
|
||
<?php
|
||
$list_file = "%s";
|
||
if (!file_exists($list_file)) { return; }
|
||
$list = json_decode(file_get_contents($list_file), true);
|
||
if (!is_array($list) || empty($list)) { return; }
|
||
foreach($list as $item) {
|
||
if (isset($item["timestamp"]) && isset($item["hash"])) {
|
||
echo $item["timestamp"] . "|" . $item["hash"] . "\n";
|
||
}
|
||
}
|
||
'
|
||
local php_script; php_script=$(printf "$php_script_read_list" "$CHECKPOINT_LIST_FILE")
|
||
local checkpoint_entries; checkpoint_entries=$(echo "$php_script" | "$WP_CLI_CMD" eval-file -)
|
||
|
||
if [ -z "$checkpoint_entries" ]; then
|
||
echo "ℹ️ No checkpoints found to generate a list from."
|
||
return 0
|
||
fi
|
||
|
||
echo "🔎 Generating detailed checkpoint list... (This may take a moment)"
|
||
local detailed_items=()
|
||
|
||
while IFS='|' read -r timestamp hash; do
|
||
hash=$(echo "$hash" | tr -d '[:space:]')
|
||
if [ -z "$hash" ]; then continue; fi
|
||
|
||
local parent_hash=$("$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" log -n 1 --pretty=format:%P "$hash" 2>/dev/null)
|
||
local manifest_current; manifest_current=$("$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" show "$hash:manifest.json" 2>/dev/null)
|
||
if [ -z "$manifest_current" ]; then continue; fi
|
||
|
||
local php_get_counts='
|
||
<?php
|
||
$manifest_json = <<<'EOT'
|
||
%s
|
||
EOT;
|
||
$data = json_decode($manifest_json, true);
|
||
$theme_count = isset($data["themes"]) && is_array($data["themes"]) ? count($data["themes"]) : 0;
|
||
$plugin_count = isset($data["plugins"]) && is_array($data["plugins"]) ? count($data["plugins"]) : 0;
|
||
echo "$theme_count Themes, $plugin_count Plugins";
|
||
'
|
||
local counts_script; counts_script=$(printf "$php_get_counts" "$manifest_current")
|
||
local counts_str; counts_str=$(echo "$counts_script" | "$WP_CLI_CMD" eval-file -)
|
||
|
||
local diff_stats="Initial checkpoint"
|
||
if [ -n "$parent_hash" ]; then
|
||
diff_stats=$("$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" diff --shortstat "$parent_hash" "$hash" -- 'plugins/' 'themes/' 'mu-plugins/' | sed 's/^[ \t]*//')
|
||
if [ -z "$diff_stats" ]; then diff_stats="No file changes"; fi
|
||
fi
|
||
|
||
local formatted_timestamp
|
||
if [[ "$(uname)" == "Darwin" ]]; then
|
||
formatted_timestamp=$(date -j -f "%Y-%m-%dT%H:%M:%SZ" -u "$timestamp" "+%a, %b %d, %Y, %-I:%M %p")
|
||
else
|
||
formatted_timestamp=$(date -d "$timestamp" "+%a, %b %d, %Y, %-I:%M %p")
|
||
fi
|
||
|
||
# Create a JSON object for this item
|
||
local json_item
|
||
json_item=$(printf '{"hash": "%s", "timestamp": "%s", "formatted_timestamp": "%s", "counts_str": "%s", "diff_stats": "%s"}' \
|
||
"$hash" "$timestamp" "$formatted_timestamp" "$counts_str" "$diff_stats")
|
||
|
||
detailed_items+=("$json_item")
|
||
|
||
done <<< "$checkpoint_entries"
|
||
|
||
# Write the detailed list back to the file
|
||
local full_json="["
|
||
full_json+=$(IFS=,; echo "${detailed_items[*]}")
|
||
full_json+="]"
|
||
|
||
# Use PHP to pretty-print the JSON to the file
|
||
local php_write_script='
|
||
<?php
|
||
$list_file = "%s";
|
||
$json_data = <<<'EOT'
|
||
%s
|
||
EOT;
|
||
$data = json_decode($json_data, true);
|
||
file_put_contents($list_file, json_encode($data, JSON_PRETTY_PRINT));
|
||
'
|
||
local write_script; write_script=$(printf "$php_write_script" "$CHECKPOINT_LIST_FILE" "$full_json")
|
||
if echo "$write_script" | "$WP_CLI_CMD" eval-file -; then
|
||
echo "✅ Detailed checkpoint list saved to $CHECKPOINT_LIST_FILE"
|
||
else
|
||
echo "❌ Error: Failed to write detailed list."
|
||
fi
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# (Helper) Lets the user select a checkpoint hash from the list.
|
||
# ----------------------------------------------------
|
||
function _select_checkpoint_hash() {
|
||
_ensure_checkpoint_setup
|
||
if ! setup_wp_cli; then return 1; fi
|
||
|
||
if [ ! -s "$CHECKPOINT_LIST_FILE" ]; then
|
||
echo "ℹ️ No checkpoints found. Run '_do checkpoint create' to make one." >&2
|
||
exit 1
|
||
fi
|
||
|
||
# Use PHP to read the detailed list and check if it's in the new format
|
||
local php_script_read_list='
|
||
<?php
|
||
$list_file = "%s";
|
||
$list = json_decode(file_get_contents($list_file), true);
|
||
|
||
if (!is_array($list) || empty($list)) {
|
||
echo "EMPTY";
|
||
return;
|
||
}
|
||
|
||
// Check if the first item has the detailed format.
|
||
if (!isset($list[0]["formatted_timestamp"])) {
|
||
echo "NEEDS_GENERATE";
|
||
return;
|
||
}
|
||
|
||
foreach($list as $item) {
|
||
if (isset($item["formatted_timestamp"]) && isset($item["hash"]) && isset($item["counts_str"]) && isset($item["diff_stats"])) {
|
||
// Output format: formatted_timestamp|hash|counts_str|diff_stats
|
||
echo $item["formatted_timestamp"] . "|" . $item["hash"] . "|" . $item["counts_str"] . "|" . $item["diff_stats"] . "\n";
|
||
}
|
||
}
|
||
'
|
||
local php_script; php_script=$(printf "$php_script_read_list" "$CHECKPOINT_LIST_FILE")
|
||
local checkpoint_entries; checkpoint_entries=$(echo "$php_script" | "$WP_CLI_CMD" eval-file -)
|
||
|
||
if [[ "$checkpoint_entries" == "EMPTY" ]]; then
|
||
echo "ℹ️ No checkpoints available to select." >&2
|
||
exit 1 # Use exit 1 to guarantee a non-zero exit code from the subshell
|
||
elif [[ "$checkpoint_entries" == "NEEDS_GENERATE" ]]; then
|
||
echo "⚠️ The checkpoint list needs to be generated for faster display." >&2
|
||
echo "Please run: _do checkpoint list-generate" >&2
|
||
exit 1 # Use exit 1
|
||
fi
|
||
|
||
local display_items=()
|
||
local data_items=()
|
||
|
||
# Get terminal width for dynamic padding
|
||
local term_width; term_width=$(tput cols)
|
||
local hash_col_width=9 # "xxxxxxx |"
|
||
local counts_col_width=20 # "xx Themes, xx Plugins |"
|
||
|
||
# Calculate available width for the timestamp column
|
||
local timestamp_col_width=$((term_width - hash_col_width - counts_col_width - 5)) # 5 for buffers
|
||
# Set a reasonable minimum and maximum
|
||
if [ "$timestamp_col_width" -lt 20 ]; then timestamp_col_width=20; fi
|
||
if [ "$timestamp_col_width" -gt 30 ]; then timestamp_col_width=30; fi
|
||
|
||
while IFS='|' read -r formatted_timestamp hash counts_str diff_stats; do
|
||
hash=$(echo "$hash" | tr -d '[:space:]')
|
||
if [ -z "$hash" ]; then continue; fi
|
||
|
||
# Use the new dynamic width for the timestamp
|
||
local display_string
|
||
display_string=$(printf "%-${timestamp_col_width}s | %s | %-18s | %s" \
|
||
"$formatted_timestamp" "${hash:0:7}" "$counts_str" "$diff_stats")
|
||
|
||
display_items+=("$display_string")
|
||
data_items+=("$hash")
|
||
done <<< "$checkpoint_entries"
|
||
|
||
if [ ${#display_items[@]} -eq 0 ]; then
|
||
echo "❌ No valid checkpoints to display." >&2
|
||
exit 1
|
||
fi
|
||
|
||
local prompt_text="${1:-Select a checkpoint to inspect}"
|
||
local selected_display
|
||
selected_display=$(printf "%s\n" "${display_items[@]}" | "$GUM_CMD" filter --height=20 --prompt="👇 $prompt_text" --indicator="→" --placeholder="")
|
||
|
||
if [ -z "$selected_display" ]; then
|
||
echo "" # Return empty for cancellation
|
||
return 0
|
||
fi
|
||
|
||
local selected_index=-1
|
||
for i in "${!display_items[@]}"; do
|
||
if [[ "${display_items[$i]}" == "$selected_display" ]]; then
|
||
selected_index=$i
|
||
break
|
||
fi
|
||
done
|
||
|
||
if [ "$selected_index" -ne -1 ]; then
|
||
echo "${data_items[$selected_index]}"
|
||
return 0
|
||
else
|
||
echo "❌ Error: Could not find selected checkpoint." >&2
|
||
exit 1
|
||
fi
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Lists all checkpoints from the pre-generated list and allows selection.
|
||
# ----------------------------------------------------
|
||
function checkpoint_list() {
|
||
if ! setup_gum || ! setup_git; then return 1; fi
|
||
|
||
local selected_hash
|
||
selected_hash=$(_select_checkpoint_hash "Select a checkpoint to inspect")
|
||
local exit_code=$?
|
||
|
||
if [ $exit_code -ne 0 ]; then
|
||
return 1
|
||
fi
|
||
|
||
if [ -z "$selected_hash" ]; then
|
||
echo "No checkpoint selected."
|
||
return 0
|
||
fi
|
||
|
||
checkpoint_show "$selected_hash"
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Reverts all files to a specific checkpoint hash.
|
||
# ----------------------------------------------------
|
||
function checkpoint_revert() {
|
||
local target_hash="$1"
|
||
|
||
if ! setup_gum || ! setup_git; then return 1; fi
|
||
if ! setup_wp_cli; then return 1; fi
|
||
|
||
# If no hash is provided, let the user pick one from a detailed list.
|
||
if [ -z "$target_hash" ]; then
|
||
target_hash=$(_select_checkpoint_hash "Select a checkpoint to revert to")
|
||
|
||
if [ -z "$target_hash" ]; then
|
||
echo "Revert cancelled."
|
||
return 0
|
||
fi
|
||
# Check the exit code of the helper
|
||
if [ $? -ne 0 ]; then
|
||
return 1 # Error was already printed by the helper
|
||
fi
|
||
fi
|
||
|
||
_ensure_checkpoint_setup
|
||
|
||
# Validate the hash to ensure it exists in the repo before proceeding
|
||
if ! "$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" cat-file -e "${target_hash}^{commit}" &>/dev/null; then
|
||
echo "❌ Error: Checkpoint hash '$target_hash' not found." >&2
|
||
return 1
|
||
fi
|
||
|
||
# Final confirmation before the revert
|
||
echo "🚨 You are about to revert ALL themes, plugins, and mu-plugins to the state from checkpoint ${target_hash:0:7}."
|
||
echo "This will overwrite any changes made since that checkpoint was created."
|
||
"$GUM_CMD" confirm "Are you sure you want to proceed?" || { echo "Revert cancelled."; return 0; }
|
||
|
||
# Get wp-content path for rsync destination
|
||
local wp_content_dir
|
||
wp_content_dir=$("$WP_CLI_CMD" eval "echo rtrim(WP_CONTENT_DIR, '/');" --skip-plugins --skip-themes 2>/dev/null)
|
||
if [ -z "$wp_content_dir" ] || [ ! -d "$wp_content_dir" ]; then
|
||
echo "❌ Error: Could not determine wp-content directory." >&2
|
||
return 1
|
||
fi
|
||
|
||
local current_hash=$("$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" rev-parse HEAD)
|
||
|
||
# Revert all three directories within the git repo
|
||
echo "Reverting all tracked files to checkpoint ${target_hash:0:7}..."
|
||
"$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" checkout "$target_hash" -- 'plugins/' 'themes/' 'mu-plugins/' &>/dev/null
|
||
|
||
# Sync the reverted files from the repo to the live site directories
|
||
echo "Syncing restored files to the live site..."
|
||
rsync -a --delete "$CHECKPOINT_REPO_DIR/plugins/" "$wp_content_dir/plugins/"
|
||
rsync -a --delete "$CHECKPOINT_REPO_DIR/themes/" "$wp_content_dir/themes/"
|
||
rsync -a --delete "$CHECKPOINT_REPO_DIR/mu-plugins/" "$wp_content_dir/mu-plugins/"
|
||
|
||
# IMPORTANT: Reset the repo's state back to the original `HEAD`
|
||
"$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" checkout "$current_hash" -- 'plugins/' 'themes/' 'mu-plugins/' &>/dev/null
|
||
|
||
echo "✅ Full file revert to checkpoint ${target_hash:0:7} is complete."
|
||
echo "💡 Note: This action reverts files only. Database changes, plugin/theme activation status, and WordPress core version are not affected."
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Shows the diff between two checkpoints or one checkpoint and its parent.
|
||
# ----------------------------------------------------
|
||
function checkpoint_show() {
|
||
local hash_after="$1"
|
||
local hash_before="$2"
|
||
|
||
if [ -z "$hash_after" ]; then
|
||
echo "❌ Error: No hash provided." >&2
|
||
show_command_help "checkpoint"
|
||
return 1
|
||
fi
|
||
|
||
if ! setup_gum || ! setup_git; then return 1; fi
|
||
if ! setup_wp_cli; then return 1; fi
|
||
_ensure_checkpoint_setup
|
||
|
||
# If 'before' hash is not provided, find the parent of the 'after' hash.
|
||
if [ -z "$hash_before" ]; then
|
||
hash_before=$("$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" log -n 1 --pretty=format:%P "$hash_after" 2>/dev/null)
|
||
fi
|
||
|
||
local manifest_after
|
||
manifest_after=$("$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" show "$hash_after:manifest.json" 2>/dev/null)
|
||
if [ -z "$manifest_after" ]; then
|
||
echo "❌ Error: Could not find manifest for 'after' hash '$hash_after'." >&2
|
||
return 1
|
||
fi
|
||
|
||
local manifest_before="{}"
|
||
if [ -n "$hash_before" ]; then
|
||
manifest_before=$("$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" show "$hash_before:manifest.json" 2>/dev/null)
|
||
if [ -z "$manifest_before" ]; then
|
||
echo "⚠️ Warning: Could not find manifest for 'before' hash '$hash_before'. Comparing against an empty state." >&2
|
||
manifest_before="{}"
|
||
fi
|
||
fi
|
||
|
||
# Get a list of themes and plugins that have actual file changes.
|
||
local changed_files_list
|
||
if [ -z "$hash_before" ]; then
|
||
# This is the initial commit, compare against the empty tree.
|
||
changed_files_list=$("$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" diff-tree --no-commit-id --name-only -r "$hash_after" -- 'plugins/' 'themes/' 'mu-plugins/')
|
||
else
|
||
changed_files_list=$("$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" diff --name-only "$hash_before" "$hash_after" -- 'plugins/' 'themes/' 'mu-plugins/')
|
||
fi
|
||
|
||
local items_with_file_changes=()
|
||
while IFS= read -r file_path; do
|
||
if [[ -n "$file_path" ]]; then
|
||
local item_name
|
||
item_name=$(echo "$file_path" | cut -d'/' -f2)
|
||
items_with_file_changes+=("$item_name")
|
||
fi
|
||
done <<< "$changed_files_list"
|
||
local changed_items_str
|
||
changed_items_str=$(printf "%s\n" "${items_with_file_changes[@]}" | sort -u | tr '\n' ',' | sed 's/,$//')
|
||
|
||
# --- 1. Generate list of ALL items from PHP ---
|
||
export MANIFEST_AFTER_JSON="$manifest_after"
|
||
export MANIFEST_BEFORE_JSON="$manifest_before"
|
||
export CHANGED_ITEMS_STR="$changed_items_str"
|
||
|
||
local php_script
|
||
read -r -d '' php_script <<'PHP'
|
||
<?php
|
||
// This PHP script compares two manifest files and outputs pipe-delimited data for shell processing.
|
||
|
||
$manifest_after_json = getenv('MANIFEST_AFTER_JSON');
|
||
$manifest_before_json = getenv('MANIFEST_BEFORE_JSON');
|
||
$changed_items_str = getenv('CHANGED_ITEMS_STR');
|
||
|
||
$after_data = json_decode($manifest_after_json, true);
|
||
$before_data = json_decode($manifest_before_json, true);
|
||
$items_with_file_changes = !empty($changed_items_str) ? explode(',', $changed_items_str) : [];
|
||
|
||
function process_item_diff($item_type, $after_items, $before_items, $items_with_file_changes) {
|
||
$after_map = [];
|
||
if (is_array($after_items)) { foreach ($after_items as $item) { if(isset($item["name"])) $after_map[$item["name"]] = $item; } }
|
||
|
||
$before_map = [];
|
||
if (is_array($before_items)) { foreach ($before_items as $item) { if(isset($item["name"])) $before_map[$item["name"]] = $item; } }
|
||
|
||
$all_names = array_unique(array_merge(array_keys($after_map), array_keys($before_map)));
|
||
sort($all_names);
|
||
|
||
$output_lines = [];
|
||
|
||
foreach ($all_names as $name) {
|
||
if(empty($name)) continue;
|
||
|
||
$has_changed = false;
|
||
$change_parts = [];
|
||
$after_item = $after_map[$name] ?? null;
|
||
$before_item = $before_map[$name] ?? null;
|
||
|
||
if ($after_item && $before_item) {
|
||
// Check for status changes first for correct ordering
|
||
if (($after_item["status"] ?? null) !== ($before_item["status"] ?? null)) {
|
||
$change_parts[] = "status " . ($before_item["status"] ?? 'N/A') . " -> " . ($after_item["status"] ?? 'N/A');
|
||
$has_changed = true;
|
||
}
|
||
if (($after_item["version"] ?? null) !== ($before_item["version"] ?? null)) {
|
||
$change_parts[] = "version " . ($before_item["version"] ?? 'N/A') . " -> " . ($after_item["version"] ?? 'N/A');
|
||
$has_changed = true;
|
||
}
|
||
if (in_array($name, $items_with_file_changes, true)) {
|
||
$change_parts[] = "files changed";
|
||
$has_changed = true;
|
||
}
|
||
} elseif ($after_item) {
|
||
$change_parts[] = "installed";
|
||
if(isset($after_item["version"])) $change_parts[] = "v" . $after_item["version"];
|
||
$has_changed = true;
|
||
} else {
|
||
$change_parts[] = "deleted";
|
||
$has_changed = true;
|
||
}
|
||
|
||
$item_for_details = $after_item ?: $before_item;
|
||
$title = $item_for_details["title"] ?? $name;
|
||
|
||
if ($has_changed) {
|
||
$details_string = implode(", ", array_unique($change_parts));
|
||
} else {
|
||
$version = $item_for_details["version"] ?? 'N/A';
|
||
$status = $item_for_details["status"] ?? 'N/A';
|
||
// Format with status first, then version
|
||
$details_string = "$status, v$version";
|
||
}
|
||
|
||
$output_lines[] = [
|
||
'has_changed' => $has_changed,
|
||
'type' => $item_type,
|
||
'slug' => $name,
|
||
'title' => $title,
|
||
'details' => $details_string,
|
||
];
|
||
}
|
||
|
||
// Sort to show changed items first
|
||
usort($output_lines, function ($a, $b) {
|
||
if ($a['has_changed'] !== $b['has_changed']) {
|
||
return $b['has_changed'] <=> $a['has_changed'];
|
||
}
|
||
return strcmp($a['slug'], $b['slug']);
|
||
});
|
||
|
||
// Output as pipe-delimited data
|
||
foreach ($output_lines as $line) {
|
||
echo implode("|", [
|
||
$line['has_changed'] ? 'true' : 'false',
|
||
$line['type'],
|
||
$line['slug'],
|
||
$line['title'],
|
||
$line['details']
|
||
]) . "\n";
|
||
}
|
||
}
|
||
|
||
process_item_diff('Theme', $after_data['themes'] ?? [], $before_data['themes'] ?? [], $items_with_file_changes);
|
||
process_item_diff('Plugin', $after_data['plugins'] ?? [], $before_data['plugins'] ?? [], $items_with_file_changes);
|
||
PHP
|
||
|
||
local php_output
|
||
php_output=$(echo "$php_script" | "$WP_CLI_CMD" eval-file - 2>/dev/null)
|
||
|
||
# Unset the environment variables
|
||
unset MANIFEST_AFTER_JSON
|
||
unset MANIFEST_BEFORE_JSON
|
||
unset CHANGED_ITEMS_STR
|
||
|
||
if [ -z "$php_output" ]; then
|
||
echo "✅ No manifest changes found between checkpoints ${hash_before:0:7} and ${hash_after:0:7}."
|
||
return 0
|
||
fi
|
||
|
||
local display_items=()
|
||
local data_items=()
|
||
|
||
# Use fixed-width columns for consistent alignment
|
||
local slug_width=30
|
||
local title_width=42
|
||
|
||
# Read the pipe-delimited output from PHP and format it for display
|
||
while IFS='|' read -r has_changed item_type slug title details; do
|
||
local icon
|
||
if [[ "$has_changed" == "true" ]];
|
||
then
|
||
icon="+"
|
||
else
|
||
icon=$(printf '\xE2\xA0\x80\xE2\xA0\x80')
|
||
fi
|
||
|
||
# Use "%-2s" to create a 2-character wide column for the icon.
|
||
# This ensures consistent padding for both the "+" and " " cases.
|
||
# Note the space between "%-2s" and "%-8s" is preserved.
|
||
local display_line
|
||
display_line=$(printf "%-2s%-8s %-*.*s %-*.*s %s" "$icon" "$item_type" "$slug_width" "$slug_width" "$slug" "$title_width" "$title_width" "$title" "$details")
|
||
|
||
display_items+=("$display_line")
|
||
data_items+=("$item_type|$slug")
|
||
done <<< "$php_output"
|
||
|
||
# Start a loop to allow returning to the item selection.
|
||
while true; do
|
||
# --- 2. Interactive Item Selection ---
|
||
local selected_display_text
|
||
selected_display_text=$(printf "%s\n" "${display_items[@]}" | "$GUM_CMD" filter --prompt="? Select item to inspect (checkpoints ${hash_before:0:7} -> ${hash_after:0:7}). Press Esc to exit." --height=20 --indicator="→" --placeholder="")
|
||
|
||
if [ -z "$selected_display_text" ]; then
|
||
# User pressed Esc, so break the loop and exit the function.
|
||
break
|
||
fi
|
||
|
||
local selected_index=-1
|
||
for i in "${!display_items[@]}"; do
|
||
if [[ "${display_items[$i]}" == "$selected_display_text" ]]; then
|
||
selected_index=$i
|
||
break
|
||
fi
|
||
done
|
||
|
||
if [ "$selected_index" -eq -1 ]; then
|
||
# Should not happen, but as a safeguard
|
||
continue
|
||
fi
|
||
|
||
local item_data="${data_items[$selected_index]}"
|
||
local item_type; item_type=$(echo "$item_data" | cut -d'|' -f1)
|
||
local item_name; item_name=$(echo "$item_data" | cut -d'|' -f2)
|
||
|
||
# --- 3. Get wp-content Path ---
|
||
local wp_content_dir
|
||
wp_content_dir=$("$WP_CLI_CMD" eval "echo rtrim(WP_CONTENT_DIR, '/');" --skip-plugins --skip-themes 2>/dev/null)
|
||
if [ -z "$wp_content_dir" ] || [ ! -d "$wp_content_dir" ]; then
|
||
echo "❌ Error: Could not determine wp-content directory." >&2
|
||
return 1
|
||
fi
|
||
|
||
# --- 4. Interactive Action Selection ---
|
||
local choices=("Show File Changes" "Revert Files to 'After' State (${hash_after:0:7})")
|
||
if [ -n "$hash_before" ]; then
|
||
choices+=("Revert Files to 'Before' State (${hash_before:0:7})")
|
||
fi
|
||
choices+=("Back to item list")
|
||
|
||
local action; action=$("$GUM_CMD" choose "${choices[@]}")
|
||
|
||
# --- 5. Execute Action ---
|
||
case "$action" in
|
||
"Show File Changes")
|
||
local item_path_in_repo
|
||
case "$item_type" in
|
||
"Theme")
|
||
item_path_in_repo="themes/${item_name}"
|
||
;;
|
||
"Plugin")
|
||
item_path_in_repo="plugins/${item_name}"
|
||
;;
|
||
esac
|
||
|
||
# Get the list of files that have changed for the selected item.
|
||
local changed_files
|
||
if [ -z "$hash_before" ]; then
|
||
changed_files=$("$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" diff-tree --no-commit-id --name-only -r "$hash_after" -- "$item_path_in_repo")
|
||
else
|
||
changed_files=$("$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" diff --name-only "$hash_before" "$hash_after" -- "$item_path_in_repo")
|
||
fi
|
||
|
||
if [ -z "$changed_files" ]; then
|
||
"$GUM_CMD" spin --spinner dot --title "No file changes found for '$item_name'." -- sleep 3
|
||
else
|
||
echo "Showing file changes for '$item_name' between ${hash_before:0:7} and ${hash_after:0:7}."
|
||
|
||
# Loop to allow viewing multiple diffs
|
||
while true; do
|
||
clear
|
||
local selected_file
|
||
selected_file=$(echo "$changed_files" | "$GUM_CMD" filter --prompt="? Select a file to view its diff (Press Esc to exit)" --height=20 --indicator="→" --placeholder="")
|
||
|
||
if [ -z "$selected_file" ]; then
|
||
break
|
||
fi
|
||
|
||
# Show the diff for the selected file, piped to `less`.
|
||
if [ -z "$hash_before" ]; then
|
||
# For the initial commit, just show the file content as it was added.
|
||
"$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" --no-pager show --color=always "$hash_after" -- "$selected_file" | less -RX
|
||
else
|
||
"$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" --no-pager diff --color=always "$hash_before" "$hash_after" -- "$selected_file" | less -RX
|
||
fi
|
||
done
|
||
fi
|
||
;;
|
||
"Revert Files to 'After' State ("*)
|
||
_revert_item_to_hash "$item_type" "$item_name" "$hash_after" "$wp_content_dir" "$CHECKPOINT_REPO_DIR" "$hash_after"
|
||
;;
|
||
"Revert Files to 'Before' State ("*)
|
||
if [ -z "$hash_before" ]; then
|
||
echo "❌ Cannot revert: 'Before' state does not exist (likely the first checkpoint)." >&2
|
||
return 1
|
||
fi
|
||
_revert_item_to_hash "$item_type" "$item_name" "$hash_before" "$wp_content_dir" "$CHECKPOINT_REPO_DIR" "$hash_after"
|
||
;;
|
||
"Back to item list"|*)
|
||
# Do nothing, the loop will continue to the next iteration.
|
||
continue
|
||
;;
|
||
esac
|
||
done
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Gets the latest checkpoint hash.
|
||
# ----------------------------------------------------
|
||
function checkpoint_latest() {
|
||
_ensure_checkpoint_setup
|
||
if ! setup_wp_cli; then return 1; fi
|
||
if [ ! -s "$CHECKPOINT_LIST_FILE" ]; then
|
||
echo "ℹ️ No checkpoints found."
|
||
return
|
||
fi
|
||
|
||
local php_code_template='
|
||
<?php
|
||
$list_file = "%s";
|
||
if (!file_exists($list_file)) { return; }
|
||
$list = json_decode(file_get_contents($list_file));
|
||
if (!empty($list) && isset($list[0]->hash)) {
|
||
echo $list[0]->hash;
|
||
}
|
||
'
|
||
local php_script; php_script=$(printf "$php_code_template" "$CHECKPOINT_LIST_FILE")
|
||
local latest_hash
|
||
latest_hash=$(echo "$php_script" | "$WP_CLI_CMD" eval-file -)
|
||
|
||
if [ -z "$latest_hash" ]; then
|
||
echo "ℹ️ No checkpoints found."
|
||
else
|
||
echo "$latest_hash"
|
||
fi
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Cleans up inactive themes.
|
||
# ----------------------------------------------------
|
||
function clean_themes() {
|
||
# --- Pre-flight checks ---
|
||
if ! setup_wp_cli; then echo "❌ Error: WP-CLI not found." >&2; return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then echo "❌ Error: This does not appear to be a WordPress installation." >&2; return 1; fi
|
||
|
||
echo "🔎 Finding the latest default WordPress theme to preserve..."
|
||
latest_default_theme=$("$WP_CLI_CMD" theme search twenty --field=slug --per-page=1 --quiet --skip-plugins --skip-themes)
|
||
|
||
if [ $? -ne 0 ] || [ -z "$latest_default_theme" ]; then
|
||
echo "❌ Error: Could not determine the latest default theme. Aborting." >&2
|
||
return 1
|
||
fi
|
||
echo "✅ The latest default theme is '$latest_default_theme'. This will be preserved."
|
||
inactive_themes=($("$WP_CLI_CMD" theme list --status=inactive --field=name --skip-plugins --skip-themes))
|
||
if [ ${#inactive_themes[@]} -eq 0 ]; then
|
||
echo "👍 No inactive themes found to process. All done!"
|
||
return 0
|
||
fi
|
||
|
||
echo "🚀 Processing ${#inactive_themes[@]} inactive themes..."
|
||
for theme in "${inactive_themes[@]}"; do
|
||
# Check if the current inactive theme is the one we want to keep
|
||
if [[ "$theme" == "$latest_default_theme" ]]; then
|
||
echo "⚪️ Keeping inactive default theme: $theme"
|
||
else
|
||
echo "❌ Deleting inactive theme: $theme"
|
||
"$WP_CLI_CMD" theme delete "$theme"
|
||
fi
|
||
done
|
||
|
||
echo "✨ Cleanup complete."
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Deletes inactive plugins.
|
||
# On multisite, only deletes plugins not active on any site.
|
||
# ----------------------------------------------------
|
||
function clean_plugins() {
|
||
# --- Pre-flight checks ---
|
||
if ! setup_wp_cli; then echo "❌ Error: WP-CLI not found." >&2; return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then echo "❌ Error: This does not appear to be a WordPress installation." >&2; return 1; fi
|
||
if ! setup_gum; then return 1; fi
|
||
|
||
echo "🚀 Cleaning inactive plugins..."
|
||
|
||
# --- Multisite vs. Single Site Logic ---
|
||
if "$WP_CLI_CMD" core is-installed --network --quiet; then
|
||
echo "ℹ️ Multisite installation detected. Finding plugins that are not active on any site..."
|
||
|
||
# Get all installed plugins (slugs)
|
||
local all_installed_plugins
|
||
all_installed_plugins=$("$WP_CLI_CMD" plugin list --field=name)
|
||
|
||
# Get all network-activated plugins
|
||
local network_active_plugins
|
||
network_active_plugins=$("$WP_CLI_CMD" plugin list --network --status=active --field=name)
|
||
|
||
# Get all plugins active on individual sites
|
||
local site_active_plugins
|
||
site_active_plugins=$("$WP_CLI_CMD" site list --field=url --format=ids | xargs -I % "$WP_CLI_CMD" plugin list --url=% --status=active --field=name)
|
||
|
||
# Combine all active plugins (network + site-specific) and get a unique, sorted list
|
||
local all_active_plugins
|
||
all_active_plugins=$(echo -e "${network_active_plugins}\n${site_active_plugins}" | sort -u | grep -v '^$')
|
||
|
||
# Find plugins that are in the installed list but not in the combined active list
|
||
local plugins_to_delete
|
||
plugins_to_delete=$(comm -23 <(echo "$all_installed_plugins" | sort) <(echo "$all_active_plugins" | sort))
|
||
|
||
else
|
||
echo "ℹ️ Single site installation detected. Finding inactive plugins..."
|
||
# On a single site, 'inactive' is sufficient
|
||
local plugins_to_delete
|
||
plugins_to_delete=$("$WP_CLI_CMD" plugin list --status=inactive --field=name)
|
||
fi
|
||
|
||
if [ -z "$plugins_to_delete" ]; then
|
||
echo "✅ No inactive plugins found to delete."
|
||
return 0
|
||
fi
|
||
|
||
local plugins_to_delete_count
|
||
plugins_to_delete_count=$(echo "$plugins_to_delete" | wc -l | xargs)
|
||
|
||
echo "🔎 Found ${plugins_to_delete_count} plugin(s) to delete:"
|
||
echo "$plugins_to_delete"
|
||
echo
|
||
|
||
if ! "$GUM_CMD" confirm "Proceed with deletion?"; then
|
||
echo "Operation cancelled by user."
|
||
return 0
|
||
fi
|
||
|
||
while IFS= read -r plugin; do
|
||
if [ -n "$plugin" ]; then
|
||
echo " - Deleting '$plugin'..."
|
||
"$WP_CLI_CMD" plugin delete "$plugin"
|
||
fi
|
||
done <<< "$plugins_to_delete"
|
||
|
||
echo "✨ Plugin cleanup complete."
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Analyzes disk usage using rclone.
|
||
# ----------------------------------------------------
|
||
function clean_disk() {
|
||
echo "🚀 Launching interactive disk usage analysis..."
|
||
if ! setup_rclone; then
|
||
echo "Aborting analysis: rclone setup failed." >&2
|
||
return 1
|
||
fi
|
||
"$RCLONE_CMD" ncdu .
|
||
}
|
||
# ----------------------------------------------------
|
||
# Finds large images and converts them to the
|
||
# WebP format.
|
||
# ----------------------------------------------------
|
||
function convert_to_webp() {
|
||
# The target directory is the first positional argument.
|
||
# The --all flag is passed as the second argument from main.
|
||
local target_dir_arg="$1"
|
||
local all_files_flag="$2"
|
||
echo "🚀 Starting WebP Conversion Process 🚀"
|
||
|
||
# --- Pre-flight Checks ---
|
||
if ! setup_cwebp; then
|
||
echo "Aborting conversion: cwebp setup failed." >&2
|
||
return 1
|
||
fi
|
||
|
||
# --- Initialize and Report Identify Method ---
|
||
# Prime the _is_webp function to determine the method and export the choice.
|
||
_is_webp ""
|
||
# Now that IDENTIFY_METHOD is set, report the choice to the user once.
|
||
if [[ "$IDENTIFY_METHOD" == "identify" ]]; then
|
||
echo "Using 'identify' command for image type checking."
|
||
else
|
||
echo "Warning: 'identify' command not found. Falling back to PHP check."
|
||
fi
|
||
|
||
# --- Determine target directory ---
|
||
local target_dir="wp-content/uploads"
|
||
if [ -n "$target_dir_arg" ]; then
|
||
target_dir="$target_dir_arg"
|
||
echo "Targeting custom directory: $target_dir"
|
||
else
|
||
echo "Targeting default directory: $target_dir"
|
||
fi
|
||
|
||
if [ ! -d "$target_dir" ]; then
|
||
echo "❌ Error: Cannot find '$target_dir' directory." >&2
|
||
return 1
|
||
fi
|
||
|
||
# --- Size and File Discovery ---
|
||
local before_size
|
||
before_size="$(du -sh "$target_dir" | awk '{print $1}')"
|
||
echo "Current directory size: $before_size"
|
||
|
||
local size_limit_mb=1
|
||
local message="larger than ${size_limit_mb}MB"
|
||
local find_args=("$target_dir" -type f)
|
||
|
||
if [[ "$all_files_flag" == "true" ]]; then
|
||
message="of all sizes"
|
||
else
|
||
find_args+=(-size "+${size_limit_mb}M")
|
||
fi
|
||
find_args+=(\( -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.png" -o -iname "*.webp" \))
|
||
|
||
local files
|
||
files=$(find "${find_args[@]}")
|
||
|
||
if [[ -z "$files" ]]; then
|
||
echo "✅ No images ${message} found to convert."
|
||
return 0
|
||
fi
|
||
local count
|
||
count=$(echo "$files" | wc -l | xargs)
|
||
echo "Found $count image(s) ${message} to process using up to 5 concurrent threads..."
|
||
echo ""
|
||
|
||
# --- Helper function for processing a single image ---
|
||
# This function will be run in the background for each image.
|
||
_process_single_image() {
|
||
local file="$1"
|
||
local current_num="$2"
|
||
local total_num="$3"
|
||
|
||
# The _is_webp function checks if the file is already in WebP format.
|
||
if _is_webp "$file"; then
|
||
echo "⚪️ Skipping ${current_num}/${total_num} (already WebP): $file"
|
||
return
|
||
fi
|
||
|
||
local temp_file="${file}.temp.webp"
|
||
local before_file_size
|
||
before_file_size=$(ls -lh "$file" | awk '{print $5}')
|
||
|
||
# The actual conversion command, output is suppressed for a cleaner log.
|
||
"$CWEBP_CMD" -q 80 "$file" -o "$temp_file" > /dev/null 2>&1
|
||
|
||
# Check if the conversion was successful and the new file has content.
|
||
if [ -s "$temp_file" ]; then
|
||
mv "$temp_file" "$file"
|
||
local after_file_size
|
||
after_file_size=$(ls -lh "$file" | awk '{print $5}')
|
||
echo "✅ Converted ${current_num}/${total_num} ($before_file_size -> $after_file_size): $file"
|
||
else
|
||
# Cleanup failed temporary file and report the failure.
|
||
rm -f "$temp_file"
|
||
echo "❌ Failed ${current_num}/${total_num}: $file"
|
||
fi
|
||
}
|
||
|
||
# Export the helper function and its dependencies so they are available to the subshells.
|
||
export -f _process_single_image
|
||
export -f _is_webp
|
||
export -f _is_webp_php
|
||
export -f setup_wp_cli
|
||
|
||
# --- Concurrent Processing Loop ---
|
||
local max_jobs=5
|
||
local job_count=0
|
||
local processed_count=0
|
||
|
||
# Use process substitution to avoid creating a subshell for the while loop.
|
||
# This ensures the main script's 'wait' command can see all background jobs.
|
||
while IFS= read -r file; do
|
||
processed_count=$((processed_count + 1))
|
||
|
||
# Run the processing function in the background.
|
||
_process_single_image "$file" "$processed_count" "$count" &
|
||
|
||
# On Linux, use 'wait -n' for a sliding window of jobs.
|
||
# On macOS, bash doesn't support 'wait -n', so we skip this
|
||
# and let the final 'wait' handle all jobs at once.
|
||
if [[ "$(uname)" != "Darwin" ]]; then
|
||
job_count=$((job_count + 1))
|
||
if (( job_count >= max_jobs )); then
|
||
wait -n
|
||
job_count=$((job_count - 1))
|
||
fi
|
||
fi
|
||
done < <(echo "$files")
|
||
|
||
# Wait for all remaining background jobs to complete before proceeding.
|
||
wait
|
||
|
||
# --- Final Summary ---
|
||
echo ""
|
||
local after_size
|
||
after_size="$(du -sh "$target_dir" | awk '{print $1}')"
|
||
echo "✅ Bulk conversion complete!"
|
||
echo "-----------------------------------------------------"
|
||
echo " Directory size reduced from $before_size to $after_size."
|
||
echo "-----------------------------------------------------"
|
||
}
|
||
# ----------------------------------------------------
|
||
# Cron Commands
|
||
# Manages scheduled tasks for the _do script.
|
||
# ----------------------------------------------------
|
||
|
||
# ----------------------------------------------------
|
||
# (Helper) PHP script to manage cron events.
|
||
# ----------------------------------------------------
|
||
function _get_cron_manager_php_script() {
|
||
read -r -d '' php_script <<'PHP'
|
||
<?php
|
||
|
||
$argv = WP_CLI::get_runner()->arguments;
|
||
array_shift( $argv );
|
||
// This script is a self-contained manager for cron events stored in a WP option.
|
||
// It is designed to be called with specific actions and arguments.
|
||
|
||
// Prevent direct execution.
|
||
if (empty($argv) || !isset($argv[1])) {
|
||
return;
|
||
}
|
||
|
||
$action = $argv[1] ?? null;
|
||
// The main function for this script is to get the option, unserialize it,
|
||
// perform an action, then serialize and save the result.
|
||
function get_events() {
|
||
// get_option will return the value of the option, already unserialized.
|
||
// The second argument is the default value if the option does not exist.
|
||
$events = get_option("captaincore_do_cron", []);
|
||
return is_array($events) ? $events : [];
|
||
}
|
||
|
||
function save_events($events) {
|
||
// update_option will create the option if it does not exist.
|
||
// The third argument 'no' sets autoload to false.
|
||
update_option( "captaincore_do_cron", $events, 'no');
|
||
}
|
||
|
||
// --- Action Router ---
|
||
|
||
if ($action === 'list_all') {
|
||
$events = get_events();
|
||
if (empty($events)) {
|
||
return;
|
||
}
|
||
// Sort events by the next_run timestamp to show the soonest first.
|
||
usort($events, function($a, $b) {
|
||
return ($a['next_run'] ?? 0) <=> ($b['next_run'] ?? 0);
|
||
});
|
||
|
||
// MODIFICATION: Get the WordPress timezone once before the loop.
|
||
$wp_timezone = wp_timezone();
|
||
|
||
foreach ($events as $event) {
|
||
|
||
// MODIFICATION: Convert the stored UTC timestamp to the WP timezone for display.
|
||
$next_run_formatted = 'N/A';
|
||
if (isset($event['next_run'])) {
|
||
// Create a DateTime object from the UTC timestamp
|
||
$next_run_dt = new DateTime("@" . $event['next_run']);
|
||
// Set the object's timezone to the WordPress configured timezone
|
||
$next_run_dt->setTimezone($wp_timezone);
|
||
// Format for output
|
||
$next_run_formatted = $next_run_dt->format('Y-m-d H:i:s T');
|
||
}
|
||
|
||
// Output in CSV format for gum table
|
||
echo implode(',', [
|
||
$event['id'] ?? 'N/A',
|
||
'"' . ($event['command'] ?? 'N/A') . '"', // Quote command in case it has spaces
|
||
$next_run_formatted,
|
||
$event['frequency'] ?? 'N/A'
|
||
]) . "\n";
|
||
}
|
||
}
|
||
|
||
elseif ($action === 'list_due') {
|
||
$now = time();
|
||
$due_events = [];
|
||
foreach (get_events() as $event) {
|
||
if (isset($event['next_run']) && $event['next_run'] <= $now) {
|
||
$due_events[] = $event;
|
||
}
|
||
}
|
||
echo json_encode($due_events);
|
||
}
|
||
|
||
elseif ($action === 'add') {
|
||
$id = uniqid('event_');
|
||
$command = $argv[2] ?? null;
|
||
$next_run_str = $argv[3] ?? null;
|
||
$frequency = $argv[4] ?? null;
|
||
|
||
if (!$command || !$next_run_str || !$frequency) {
|
||
error_log('Error: Missing arguments for add action.');
|
||
return;
|
||
}
|
||
|
||
// --- Frequency Translation ---
|
||
$freq_lower = strtolower($frequency);
|
||
if ($freq_lower === 'weekly') {
|
||
$frequency = '1 week';
|
||
} elseif ($freq_lower === 'daily') {
|
||
$frequency = '1 day';
|
||
} elseif ($freq_lower === 'monthly') {
|
||
$frequency = '1 month';
|
||
} elseif ($freq_lower === 'hourly') {
|
||
$frequency = '1 hour';
|
||
}
|
||
// --- End Translation ---
|
||
|
||
try {
|
||
// Use the WordPress configured timezone for parsing the date string.
|
||
$wp_timezone = wp_timezone();
|
||
$next_run_dt = new DateTime($next_run_str, $wp_timezone);
|
||
$next_run_timestamp = $next_run_dt->getTimestamp();
|
||
} catch (Exception $e) {
|
||
error_log('Error: Invalid date/time string for next_run: ' . $e->getMessage());
|
||
return;
|
||
}
|
||
|
||
$events = get_events();
|
||
$events[] = [
|
||
'id' => $id,
|
||
'command' => $command,
|
||
'next_run' => $next_run_timestamp,
|
||
'frequency' => $frequency,
|
||
];
|
||
save_events($events);
|
||
echo "✅ Event '$id' added. Input '{$next_run_str}' interpreted using WordPress timezone ({$wp_timezone->getName()}). Next run: " . date('Y-m-d H:i:s T', $next_run_timestamp) . "\n";
|
||
}
|
||
|
||
elseif ($action === 'delete') {
|
||
$id_to_delete = $argv[2] ?? null;
|
||
if (!$id_to_delete) {
|
||
error_log('Error: No ID provided for delete action.');
|
||
return;
|
||
}
|
||
|
||
$events = get_events();
|
||
$updated_events = [];
|
||
$found = false;
|
||
foreach ($events as $event) {
|
||
if (isset($event['id']) && $event['id'] === $id_to_delete) {
|
||
$found = true;
|
||
} else {
|
||
$updated_events[] = $event;
|
||
}
|
||
}
|
||
|
||
if ($found) {
|
||
save_events($updated_events);
|
||
echo "✅ Event '$id_to_delete' deleted successfully.\n";
|
||
} else {
|
||
echo "❌ Error: Event with ID '$id_to_delete' not found.\n";
|
||
}
|
||
}
|
||
|
||
elseif ($action === 'update_next_run') {
|
||
$id = $argv[2] ?? null;
|
||
if (!$id) {
|
||
error_log('Error: No ID provided to update_next_run.');
|
||
return;
|
||
}
|
||
|
||
$events = get_events();
|
||
$found = false;
|
||
foreach ($events as &$event) {
|
||
if (isset($event['id']) && $event['id'] === $id) {
|
||
try {
|
||
$last_run_ts = $event['next_run'] ??
|
||
time();
|
||
$next_run_dt = new DateTime("@{$last_run_ts}", new DateTimeZone('UTC'));
|
||
|
||
do {
|
||
$next_run_dt->modify('+ ' . $event['frequency']);
|
||
} while ($next_run_dt->getTimestamp() <= time());
|
||
|
||
$event['next_run'] = $next_run_dt->getTimestamp();
|
||
$found = true;
|
||
break;
|
||
} catch (Exception $e) {
|
||
error_log('Error: Invalid frequency string "' . ($event['frequency'] ?? '') . '": ' . $e->getMessage());
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
if ($found) {
|
||
save_events($events);
|
||
}
|
||
}
|
||
PHP
|
||
echo "$php_script"
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Configures the global cron runner by installing the latest script.
|
||
# ----------------------------------------------------
|
||
function cron_enable() {
|
||
echo "Attempting to configure cron runner..."
|
||
|
||
if ! setup_wp_cli || ! "$WP_CLI_CMD" core is-installed --quiet; then
|
||
echo "❌ Error: This command must be run from within a WordPress directory." >&2
|
||
return 1
|
||
fi
|
||
if ! command -v realpath &> /dev/null || ! command -v md5sum &> /dev/null; then
|
||
echo "❌ Error: 'realpath' and 'md5sum' commands are required." >&2
|
||
return 1
|
||
fi
|
||
|
||
# Determine the absolute path of the WordPress installation
|
||
local wp_path
|
||
wp_path=$(realpath ".")
|
||
if [[ ! -f "$wp_path/wp-load.php" ]]; then
|
||
echo "❌ Error: Could not confirm WordPress root at '$wp_path'." >&2
|
||
return 1
|
||
fi
|
||
|
||
local private_dir
|
||
if ! private_dir=$(_get_private_dir); then return 1; fi
|
||
local script_path="$private_dir/_do.sh"
|
||
|
||
echo "ℹ️ Downloading the latest version of the _do script..."
|
||
if ! command -v curl &> /dev/null; then
|
||
echo "❌ Error: 'curl' is required to download the script." >&2; return 1;
|
||
fi
|
||
if ! curl -sL "https://captaincore.io/do" -o "$script_path"; then
|
||
echo "❌ Error: Failed to download the _do script." >&2; return 1;
|
||
fi
|
||
chmod +x "$script_path"
|
||
echo "✅ Script installed/updated at: $script_path"
|
||
|
||
# Make the marker unique to the path to allow multiple cron jobs
|
||
local path_hash
|
||
path_hash=$(echo "$wp_path" | md5sum | cut -d' ' -f1)
|
||
local cron_marker="#_DO_CRON_RUNNER_$path_hash"
|
||
local cron_command="bash \"$script_path\" cron run --path=\"$wp_path\""
|
||
local cron_job="*/10 * * * * $cron_command $cron_marker"
|
||
|
||
# Atomically update the crontab
|
||
local current_crontab
|
||
current_crontab=$(crontab -l 2>/dev/null | grep -v "$cron_marker")
|
||
(echo "$current_crontab"; echo "$cron_job") | crontab -
|
||
|
||
if [ $? -eq 0 ]; then
|
||
local site_url
|
||
site_url=$("$WP_CLI_CMD" option get home --skip-plugins --skip-themes 2>/dev/null)
|
||
echo "✅ Cron runner enabled for site: $site_url ($wp_path)"
|
||
else
|
||
echo "❌ Error: Could not modify crontab. Please check your permissions." >&2
|
||
return 1
|
||
fi
|
||
|
||
echo "Current crontab:"
|
||
crontab -l
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Runs the cron process, executing any due events.
|
||
# ----------------------------------------------------
|
||
function cron_run() {
|
||
# If a path is provided, change to that directory first.
|
||
if [[ -n "$path_flag" ]]; then
|
||
if [ -d "$path_flag" ]; then
|
||
cd "$path_flag" || { echo "[$(date)] Cron Error: Could not change directory to '$path_flag'." >> /tmp/_do_cron.log; return 1; }
|
||
else
|
||
echo "[$(date)] Cron Error: Provided path '$path_flag' does not exist." >> /tmp/_do_cron.log;
|
||
return 1
|
||
fi
|
||
fi
|
||
|
||
# Call the setup function to ensure the wp command path is known.
|
||
if ! setup_wp_cli; then
|
||
echo "[$(date)] Cron Error: WP-CLI setup failed." >> /tmp/_do_cron.log
|
||
return 1
|
||
fi
|
||
|
||
# Check if this is a WordPress installation using the full command path.
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then
|
||
return 1
|
||
fi
|
||
|
||
local php_script;
|
||
php_script=$(_get_cron_manager_php_script)
|
||
|
||
local due_events_json;
|
||
# Use the full command path for all wp-cli calls.
|
||
due_events_json=$(echo "$php_script" | "$WP_CLI_CMD" eval-file - 'list_due' 2>&1)
|
||
if [ $? -ne 0 ];
|
||
then
|
||
echo "[$(date)] Cron run failed: $due_events_json" >> /tmp/_do_cron.log
|
||
return 1
|
||
fi
|
||
|
||
if [ -z "$due_events_json" ] || [[ "$due_events_json" == "[]" ]];
|
||
then
|
||
return 0
|
||
fi
|
||
|
||
local php_parser='
|
||
$json = file_get_contents("php://stdin");
|
||
$events = json_decode($json, true);
|
||
if (is_array($events)) {
|
||
foreach($events as $event) {
|
||
echo $event["id"] . "|" . $event["command"] . "\n";
|
||
}
|
||
}
|
||
'
|
||
local due_events_list;
|
||
due_events_list=$(echo "$due_events_json" | php -r "$php_parser")
|
||
|
||
if [ -z "$due_events_list" ];
|
||
then
|
||
return 0
|
||
fi
|
||
|
||
echo "Found due events, processing..."
|
||
while IFS='|' read -r id command; do
|
||
if [ -z "$id" ] || [ -z "$command" ]; then
|
||
continue
|
||
fi
|
||
echo "-> Running event '$id': _do $command"
|
||
local script_path
|
||
script_path=$(realpath "$0")
|
||
bash "$script_path" $command
|
||
echo "-> Updating next run time for event '$id'"
|
||
# Use the full command path here as well.
|
||
echo "$php_script" | "$WP_CLI_CMD" eval-file - 'update_next_run' "$id"
|
||
done <<< "$due_events_list"
|
||
echo "Cron run complete."
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Adds a new command to the cron schedule.
|
||
# ----------------------------------------------------
|
||
function cron_add() {
|
||
local command="$1"
|
||
local next_run="$2"
|
||
local frequency="$3"
|
||
|
||
if [ -z "$command" ] || [ -z "$next_run" ] || [ -z "$frequency" ]; then
|
||
echo "❌ Error: Missing arguments." >&2
|
||
show_command_help "cron"
|
||
return 1
|
||
fi
|
||
|
||
if ! setup_wp_cli; then echo "❌ Error: WP-CLI not found." >&2; return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then echo "❌ Error: Not in a WordPress installation." >&2; return 1; fi
|
||
|
||
echo "Adding new cron event..."
|
||
local php_script; php_script=$(_get_cron_manager_php_script)
|
||
|
||
# Capture both stdout and stderr to a variable
|
||
local output; output=$(echo "$php_script" | "$WP_CLI_CMD" eval-file - "add" "$command" "$next_run" "$frequency" 2>&1)
|
||
|
||
# Check the exit code of the wp-cli command
|
||
if [ $? -ne 0 ]; then
|
||
echo "❌ Error: The wp-cli command failed to execute."
|
||
echo " Output:"
|
||
# Indent the output for readability
|
||
echo "$output" | sed 's/^/ /'
|
||
else
|
||
# Print the success message from the PHP script
|
||
echo "$output"
|
||
fi
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Deletes a scheduled cron event by its ID.
|
||
# ----------------------------------------------------
|
||
function cron_delete() {
|
||
local event_id="$1"
|
||
|
||
if [ -z "$event_id" ]; then
|
||
echo "❌ Error: No event ID provided." >&2
|
||
show_command_help "cron"
|
||
return 1
|
||
fi
|
||
|
||
if ! setup_wp_cli; then echo "❌ Error: WP-CLI not found." >&2; return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then echo "❌ Error: Not in a WordPress installation." >&2; return 1; fi
|
||
|
||
echo "Attempting to delete event '$event_id'..."
|
||
local php_script
|
||
php_script=$(_get_cron_manager_php_script)
|
||
|
||
# Capture and display output from the PHP script
|
||
local output
|
||
output=$(echo "$php_script" | "$WP_CLI_CMD" eval-file - "delete" "$event_id" 2>&1)
|
||
|
||
# The PHP script now prints success or error, so just display it.
|
||
echo "$output"
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Lists all scheduled cron events in a table.
|
||
# ----------------------------------------------------
|
||
function cron_list() {
|
||
if ! setup_wp_cli; then echo "❌ Error: WP-CLI not found." >&2; return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then echo "❌ Error: Not in a WordPress installation." >&2; return 1; fi
|
||
if ! setup_gum; then return 1; fi
|
||
|
||
echo "🔎 Fetching scheduled events..."
|
||
|
||
local php_script; php_script=$(_get_cron_manager_php_script)
|
||
|
||
# Capture stdout and stderr
|
||
local events_csv; events_csv=$(echo "$php_script" | "$WP_CLI_CMD" eval-file - 'list_all' 2>&1)
|
||
|
||
# Check exit code
|
||
if [ $? -ne 0 ]; then
|
||
echo "❌ Error: The wp-cli command failed while listing events."
|
||
echo " Output:"
|
||
echo "$events_csv" | sed 's/^/ /'
|
||
return 1
|
||
fi
|
||
|
||
if [ -z "$events_csv" ]; then
|
||
echo "ℹ️ No scheduled cron events found."
|
||
return 0
|
||
fi
|
||
|
||
local table_header="ID,Command,Next Run,Frequency"
|
||
|
||
# Prepend the header and pipe to gum table for a formatted view
|
||
(echo "$table_header"; echo "$events_csv") | "$GUM_CMD" table --print --separator ","
|
||
}
|
||
# ----------------------------------------------------
|
||
# Performs a WordPress database-only backup to a secure, private directory.
|
||
# ----------------------------------------------------
|
||
function db_backup() {
|
||
echo "Starting database-only backup..."
|
||
local home_directory; home_directory=$(pwd);
|
||
local private_directory
|
||
if ! private_directory=$(_get_private_dir); then
|
||
return 1
|
||
fi
|
||
if ! setup_wp_cli; then echo "Error: wp-cli is not installed." >&2; return 1; fi
|
||
local database_name; database_name=$("$WP_CLI_CMD" config get DB_NAME --skip-plugins --skip-themes --quiet); local database_username; database_username=$("$WP_CLI_CMD" config get DB_USER --skip-plugins --skip-themes --quiet); local database_password; database_password=$("$WP_CLI_CMD" config get DB_PASSWORD --skip-plugins --skip-themes --quiet);
|
||
local dump_command; if command -v mariadb-dump &> /dev/null; then dump_command="mariadb-dump"; elif command -v mysqldump &> /dev/null; then dump_command="mysqldump"; else echo "Error: Neither mariadb-dump nor mysqldump could be found." >&2; return 1; fi
|
||
echo "Using ${dump_command} for the backup."
|
||
local backup_file="${private_directory}/database-backup-$(date +"%Y-%m-%d").sql"
|
||
if ! "${dump_command}" -u"${database_username}" -p"${database_password}" --max_allowed_packet=512M --default-character-set=utf8mb4 --add-drop-table --single-transaction --quick --lock-tables=false "${database_name}" > "${backup_file}"; then echo "Error: Database dump failed." >&2; rm -f "${backup_file}"; return 1; fi
|
||
chmod 600 "${backup_file}"; echo "✅ Database backup complete!"; echo " Backup file located at: ${backup_file}"
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Checks the size and contents of autoloaded options in the WordPress database.
|
||
# ----------------------------------------------------
|
||
function db_check_autoload() {
|
||
echo "Checking autoloaded options in the database..."
|
||
# Ensure the 'gum' utility is available for formatting
|
||
if ! setup_gum; then
|
||
echo "Aborting check: gum setup failed." >&2
|
||
return 1
|
||
fi
|
||
if ! setup_wp_cli; then echo "Error: wp-cli is not installed." >&2; return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then echo "Error: This does not appear to be a WordPress installation." >&2; return 1; fi
|
||
|
||
echo
|
||
echo "--- Total Autoloaded Size ---"
|
||
"$WP_CLI_CMD" db query "SELECT ROUND(SUM(LENGTH(option_value))/1024/1024, 2) as 'Autoload MB', COUNT(*) as 'Count' FROM $($WP_CLI_CMD db prefix)options WHERE autoload IN ('yes', 'on');" | "$GUM_CMD" table --print --separator $'\t'
|
||
echo
|
||
echo "--- Top 25 Autoloaded Options & Totals ---"
|
||
"$WP_CLI_CMD" db query "SELECT option_name, round(length(option_value) / 1024 / 1024, 2) as 'Size (MB)' FROM $($WP_CLI_CMD db prefix)options WHERE autoload IN ('yes', 'on') ORDER BY length(option_value) DESC LIMIT 25" | "$GUM_CMD" table --print --separator $'\t'
|
||
echo
|
||
echo "✅ Autoload check complete."
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Optimizes the database by converting tables to InnoDB, reporting large tables, and cleaning transients.
|
||
# ----------------------------------------------------
|
||
function db_optimize() {
|
||
# --- Pre-flight checks ---
|
||
if ! setup_gum; then
|
||
echo "Aborting optimization: gum setup failed." >&2
|
||
return 1
|
||
fi
|
||
if ! setup_wp_cli; then echo "Error: WP-CLI not found." >&2; return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then echo "Error: This does not appear to be a WordPress installation." >&2; return 1; fi
|
||
|
||
echo "🚀 Starting database optimization..."
|
||
echo ""
|
||
|
||
# --- Step 1: Convert MyISAM to InnoDB ---
|
||
echo "--- Step 1: Checking for MyISAM tables to convert to InnoDB ---"
|
||
local myisam_tables
|
||
myisam_tables=$("$WP_CLI_CMD" db query "SELECT TABLE_NAME FROM information_schema.TABLES WHERE ENGINE = 'MyISAM' AND TABLE_SCHEMA = DATABASE()" --skip-column-names)
|
||
|
||
if [[ -z "$myisam_tables" ]]; then
|
||
echo "✅ All tables are already using the InnoDB engine. No conversion needed."
|
||
else
|
||
echo "Found the following MyISAM tables to convert:"
|
||
# Use gum to format the list of tables
|
||
"$WP_CLI_CMD" db query "SELECT TABLE_NAME AS 'MyISAM Tables' FROM information_schema.TABLES WHERE ENGINE = 'MyISAM' AND TABLE_SCHEMA = DATABASE()" | "$GUM_CMD" table --print --separator $'\t'
|
||
|
||
echo "Converting tables to InnoDB..."
|
||
"$WP_CLI_CMD" db query "SELECT CONCAT('ALTER TABLE \`', TABLE_NAME, '\` ENGINE=InnoDB;') FROM information_schema.TABLES WHERE ENGINE = 'MyISAM' AND TABLE_SCHEMA = DATABASE()" --skip-column-names | "$WP_CLI_CMD" db query
|
||
|
||
if [ $? -eq 0 ]; then
|
||
echo "✅ Successfully converted tables to InnoDB."
|
||
else
|
||
echo "❌ An error occurred during the conversion."
|
||
return 1
|
||
fi
|
||
fi
|
||
|
||
# --- Step 2: List Top 10 Largest Tables ---
|
||
echo ""
|
||
echo "--- Step 2: Top 10 Tables Larger Than 1MB ---"
|
||
# Use gum to format the table of large tables
|
||
"$WP_CLI_CMD" db query "
|
||
SELECT
|
||
TABLE_NAME,
|
||
CASE
|
||
WHEN (data_length + index_length) >= 1073741824 THEN CONCAT(ROUND((data_length + index_length) / 1073741824, 2), ' GB')
|
||
WHEN (data_length + index_length) >= 1048576 THEN CONCAT(ROUND((data_length + index_length) / 1048576, 2), ' MB')
|
||
WHEN (data_length + index_length) >= 1024 THEN CONCAT(ROUND((data_length + index_length) / 1024, 2), ' KB')
|
||
ELSE CONCAT((data_length + index_length), ' B')
|
||
END AS Size
|
||
FROM
|
||
information_schema.TABLES
|
||
WHERE
|
||
TABLE_SCHEMA = DATABASE() AND (data_length + index_length) > 1048576
|
||
ORDER BY
|
||
(data_length + index_length) DESC
|
||
LIMIT 10;
|
||
" | "$GUM_CMD" table --print --separator $'\t'
|
||
|
||
# --- Step 3: Delete Expired Transients ---
|
||
echo ""
|
||
echo "--- Step 3: Deleting Expired Transients ---"
|
||
"$WP_CLI_CMD" transient delete --expired
|
||
|
||
echo ""
|
||
echo "✅ Database optimization complete."
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Changes the database table prefix for a WordPress installation.
|
||
# ----------------------------------------------------
|
||
function db_change_prefix() {
|
||
echo "🚀 Starting Database Prefix Change 🚀"
|
||
|
||
# --- Pre-flight Checks ---
|
||
if ! setup_wp_cli; then echo "❌ Error: WP-CLI not found." >&2; return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then echo "❌ Error: This does not appear to be a WordPress installation." >&2; return 1; fi
|
||
if ! setup_gum; then echo "❌ Error: gum is required for interactive prompts." >&2; return 1; fi
|
||
if ! command -v sed &>/dev/null; then echo "❌ Error: sed command not found." >&2; return 1; fi
|
||
|
||
# --- Get Current and New Prefix ---
|
||
local db_prefix
|
||
db_prefix=$("$WP_CLI_CMD" db prefix)
|
||
echo "Current database prefix is: $db_prefix"
|
||
|
||
local random_string
|
||
# Use a more portable random string generator to avoid locale issues.
|
||
if command -v openssl &>/dev/null; then
|
||
random_string=$(openssl rand -hex 3) # 6 hex characters
|
||
elif command -v md5sum &>/dev/null; then
|
||
random_string=$(date +%s | md5sum | head -c 5)
|
||
elif command -v sha1sum &>/dev/null; then
|
||
random_string=$(date +%s | sha1sum | head -c 5)
|
||
else
|
||
# A simpler fallback if no hashing tool is found
|
||
random_string=$(date +%s | cut -c 6-10) # last 5 digits of timestamp
|
||
fi
|
||
local db_prefix_new
|
||
db_prefix_new=$("$GUM_CMD" input --value="wp_${random_string}_" --prompt="Enter the new database prefix: ")
|
||
|
||
if [ -z "$db_prefix_new" ]; then
|
||
echo "❌ No new prefix entered. Aborting."
|
||
return 1
|
||
fi
|
||
|
||
if [ "$db_prefix" == "$db_prefix_new" ]; then
|
||
echo "❌ The new prefix is the same as the current prefix. Aborting."
|
||
return 1
|
||
fi
|
||
|
||
echo "You are about to change the database prefix from '${db_prefix}' to '${db_prefix_new}'."
|
||
"$GUM_CMD" confirm "This is a potentially destructive operation. Are you sure you want to continue?" || { echo "Operation cancelled."; return 0; }
|
||
|
||
# --- Backup Database ---
|
||
local private_dir
|
||
if ! private_dir=$(_get_private_dir); then
|
||
return 1
|
||
fi
|
||
local db_file="${private_dir}/prefix-change-backup-$(date +"%Y-%m-%d-%H%M%S").sql"
|
||
echo "Step 1/5: Backing up database to a temporary file..."
|
||
if ! "$WP_CLI_CMD" db export "$db_file" --add-drop-table; then
|
||
echo "❌ Error: Failed to create database backup. Aborting."
|
||
return 1
|
||
fi
|
||
echo "✅ Database backup created at: $db_file"
|
||
|
||
# --- Modify SQL File ---
|
||
echo "Step 2/5: Modifying the database backup with the new prefix..."
|
||
# The -i flag for sed behaves differently on macOS/BSD vs Linux.
|
||
# Providing a backup extension (e.g., -i.bak) makes it work on both.
|
||
sed -i.bak "s#\`${db_prefix}#\`${db_prefix_new}#g" "$db_file"
|
||
sed -i.bak "s#'${db_prefix}user_roles#'${db_prefix_new}user_roles#g" "$db_file"
|
||
sed -i.bak "s#'${db_prefix}capabilities#'${db_prefix_new}capabilities#g" "$db_file"
|
||
sed -i.bak "s#'${db_prefix}user_level#'${db_prefix_new}user_level#g" "$db_file"
|
||
echo "✅ SQL file modified."
|
||
|
||
# --- Reset and Import ---
|
||
echo "Step 3/5: Resetting the database (dropping all tables)..."
|
||
"$WP_CLI_CMD" db reset --yes
|
||
|
||
echo "Step 4/5: Importing the modified database..."
|
||
if ! "$WP_CLI_CMD" db import "$db_file"; then
|
||
echo "❌ Error: Failed to import the modified database."
|
||
echo " Your original database is backed up at: $db_file"
|
||
echo " You may need to manually restore it."
|
||
# Clean up the .bak file
|
||
rm -f "${db_file}.bak"
|
||
return 1
|
||
fi
|
||
echo "✅ Database imported successfully."
|
||
# Clean up the .bak file created by sed
|
||
rm -f "${db_file}.bak"
|
||
|
||
# --- Update wp-config.php ---
|
||
echo "Step 5/5: Updating wp-config.php with the new prefix..."
|
||
if ! "$WP_CLI_CMD" config set table_prefix "$db_prefix_new" --skip-plugins --skip-themes; then
|
||
echo "❌ Error: Failed to update the table_prefix in your wp-config.php file."
|
||
echo " Please update it manually to: \$table_prefix = '$db_prefix_new';"
|
||
return 1
|
||
fi
|
||
echo "✅ wp-config.php updated."
|
||
|
||
echo ""
|
||
echo "✨ Database prefix change complete!"
|
||
echo " The backup file from before the change is still available at: $db_file"
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Remotely installs the Disembark plugin, connects, and initiates a backup using an embedded Playwright script.
|
||
# ----------------------------------------------------
|
||
function run_disembark() {
|
||
local target_url_input="$1"
|
||
local debug_flag="$2"
|
||
|
||
echo "🚀 Starting Disembark process for ${target_url_input}..."
|
||
|
||
# --- 1. Pre-flight Checks for disembark-cli ---
|
||
if [ -z "$target_url_input" ];then
|
||
echo "❌ Error: Missing required URL argument." >&2
|
||
show_command_help "disembark"
|
||
return 1
|
||
fi
|
||
|
||
if ! setup_disembark; then return 1; fi
|
||
|
||
# --- 2. Smart URL Parsing ---
|
||
local base_url
|
||
local login_path
|
||
|
||
# Check if the input URL contains /wp-admin or /wp-login.php
|
||
if [[ "$target_url_input" == *"/wp-admin"* || "$target_url_input" == *"/wp-login.php"* ]]; then
|
||
# If it's a backend URL, extract the base and the path
|
||
base_url=$(echo "$target_url_input" | sed -E 's#(https?://[^/]+).*#\1#')
|
||
login_path=$(echo "$target_url_input" | sed -E "s#$base_url##")
|
||
echo " - Detected backend URL. Base: '$base_url', Path: '$login_path'"
|
||
# Handle URLs with a path component that don't end in a slash (potential custom login)
|
||
elif [[ "$target_url_input" == *"/"* && "${target_url_input: -1}" != "/" ]]; then
|
||
local path_part
|
||
# Use sed -n with 'p' to ensure it only outputs on a successful match
|
||
path_part=$(echo "$target_url_input" | sed -n -E 's#https?://[^/]+(/.*)#\1#p')
|
||
|
||
# If path_part is empty, it means there was no path after the domain (e.g., https://example.com)
|
||
if [ -z "$path_part" ]; then
|
||
base_url="${target_url_input%/}"
|
||
login_path="/wp-login.php"
|
||
echo " - Homepage URL detected. Assuming default login path: '$login_path'"
|
||
# Check for deep links inside WordPress content directories
|
||
elif [[ "$path_part" == *"/wp-content"* || "$path_part" == *"/wp-includes"* ]]; then
|
||
base_url="$target_url_input"
|
||
login_path="/wp-login.php"
|
||
echo " - Deep link detected. Assuming default login for base URL."
|
||
# Otherwise, assume it's a custom login path
|
||
else
|
||
base_url=$(echo "$target_url_input" | sed -E 's#(https?://[^/]+).*#\1#')
|
||
login_path="$path_part"
|
||
echo " - Custom login path detected. Base: '$base_url', Path: '$login_path'"
|
||
fi
|
||
# Handle homepage URLs that might end with a slash
|
||
else
|
||
base_url="${target_url_input%/}" # Remove trailing slash if present
|
||
login_path="/wp-login.php"
|
||
echo " - Homepage URL detected. Assuming default login path: '$login_path'"
|
||
fi
|
||
|
||
|
||
# --- 3. Attempt backup with a potentially stored token ---
|
||
echo "✅ Attempting backup using a stored token..."
|
||
if "$DISEMBARK_CMD" backup "$base_url"; then
|
||
echo "✨ Backup successful using a pre-existing token."
|
||
return 0
|
||
fi
|
||
|
||
# --- 4. If backup fails, proceed to full browser authentication ---
|
||
echo "⚠️ Backup with stored token failed. A new connection token is likely required."
|
||
echo "Proceeding with browser authentication..."
|
||
|
||
# --- Pre-flight Checks for browser automation ---
|
||
if ! setup_playwright; then return 1; fi
|
||
if ! setup_gum; then return 1; fi
|
||
|
||
# --- Define the Playwright script using a Heredoc ---
|
||
local PLAYWRIGHT_SCRIPT
|
||
PLAYWRIGHT_SCRIPT=$(cat <<'EOF'
|
||
// --- Embedded Playwright Script ---
|
||
const { chromium } = require('playwright');
|
||
const https = require('https');
|
||
const fs = require('fs');
|
||
const os = require('os');
|
||
const path = require('path');
|
||
|
||
const PLUGIN_ZIP_URL = 'https://github.com/DisembarkHost/disembark-connector/releases/latest/download/disembark-connector.zip';
|
||
|
||
async function main() {
|
||
const [, , baseUrl, loginPath, username, password, debugFlag] = process.argv;
|
||
|
||
if (!baseUrl || !loginPath || !username || !password) {
|
||
console.error('Usage: node disembark-browser.js <baseUrl> <loginPath> <username> <password> [debug]');
|
||
process.exit(1);
|
||
}
|
||
|
||
const loginUrl = baseUrl + loginPath;
|
||
const adminUrl = baseUrl + '/wp-admin/';
|
||
|
||
const isHeadless = debugFlag !== 'true';
|
||
const browser = await chromium.launch({ headless: isHeadless });
|
||
|
||
const context = await browser.newContext({
|
||
userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36'
|
||
});
|
||
const page = await context.newPage();
|
||
try {
|
||
// 1. LOGIN
|
||
process.stdout.write(` - Step 1/5: Authenticating with WordPress at ${loginUrl}...`);
|
||
await page.goto(loginUrl, { waitUntil: 'domcontentloaded' });
|
||
|
||
if (!(await page.isVisible('#user_login'))) {
|
||
console.log(' Failed.');
|
||
console.error('LOGIN_URL_INVALID');
|
||
process.exit(2);
|
||
}
|
||
|
||
await page.fill('#user_login', username);
|
||
await page.fill('#user_pass', password);
|
||
await page.click('#wp-submit');
|
||
|
||
try {
|
||
await page.waitForSelector('#wpadminbar, #login_error, #correct-admin-email', { timeout: 60000 });
|
||
} catch (e) {
|
||
throw new Error('Authentication timed out. The page did not load the admin bar, a login error, or the admin email confirmation screen.');
|
||
}
|
||
|
||
if (await page.isVisible('#login_error')) {
|
||
const errorText = await page.locator('#login_error').textContent();
|
||
console.error(`LOGIN_FAILED: ${errorText.trim()}`);
|
||
process.exit(3);
|
||
}
|
||
|
||
if (await page.isVisible('#correct-admin-email')) {
|
||
process.stdout.write(' Admin email confirmation required. Submitting...');
|
||
await page.click('#correct-admin-email');
|
||
await page.waitForSelector('#wpadminbar', { timeout: 60000 });
|
||
}
|
||
|
||
if (!(await page.isVisible('#wpadminbar'))) {
|
||
throw new Error('Authentication failed. Admin bar not found after login.');
|
||
}
|
||
|
||
// --- Recovery Step: Navigate to the main dashboard to bypass any welcome/update screens ---
|
||
if (!page.url().startsWith(adminUrl)) {
|
||
process.stdout.write(' Navigating to main dashboard to bypass intermediate pages...');
|
||
await page.goto(adminUrl, { waitUntil: 'networkidle' });
|
||
await page.waitForSelector('#wpadminbar'); // Re-confirm we are in the admin area
|
||
process.stdout.write(' Done.');
|
||
}
|
||
|
||
console.log(' Success!');
|
||
|
||
// 2. CHECK IF PLUGIN EXISTS & ACTIVATE IF NEEDED
|
||
process.stdout.write(' - Step 2/5: Checking plugin status...');
|
||
await page.goto(`${adminUrl}plugins.php`, { waitUntil: 'networkidle' });
|
||
|
||
const pluginRow = page.locator('tr[data-slug="disembark-connector"]');
|
||
if (await pluginRow.count() > 0) {
|
||
console.log(' Plugin found.');
|
||
const activateLink = pluginRow.locator('a.edit:has-text("Activate")');
|
||
if (await activateLink.count() > 0) {
|
||
process.stdout.write(' - Activating existing plugin...');
|
||
await Promise.all([
|
||
page.waitForNavigation({ waitUntil: 'networkidle' }),
|
||
activateLink.click()
|
||
]);
|
||
console.log(' Activated!');
|
||
} else {
|
||
console.log(' - Plugin already active.');
|
||
}
|
||
} else {
|
||
// 3. UPLOAD AND INSTALL PLUGIN
|
||
console.log(' Plugin not found, proceeding with installation.');
|
||
process.stdout.write(' - Step 3/5: Downloading plugin...');
|
||
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'disembark-'));
|
||
const pluginZipPath = path.join(tempDir, 'disembark-connector.zip');
|
||
await new Promise((resolve, reject) => {
|
||
const file = fs.createWriteStream(pluginZipPath);
|
||
const request = (url) => {
|
||
https.get(url, (response) => {
|
||
if (response.statusCode > 300 && response.statusCode < 400 && response.headers.location) {
|
||
request(response.headers.location);
|
||
} else {
|
||
response.pipe(file);
|
||
file.on('finish', () => file.close(resolve));
|
||
}
|
||
}).on('error', (err) => {
|
||
fs.unlinkSync(pluginZipPath);
|
||
reject(err);
|
||
});
|
||
};
|
||
request(PLUGIN_ZIP_URL);
|
||
});
|
||
|
||
console.log(' Download complete.');
|
||
process.stdout.write(' - Uploading and installing...');
|
||
await page.goto(`${adminUrl}plugin-install.php?tab=upload`);
|
||
await page.setInputFiles('input#pluginzip', pluginZipPath);
|
||
await page.waitForSelector('input#install-plugin-submit:not([disabled])', { timeout: 10000 });
|
||
|
||
await page.click('input#install-plugin-submit');
|
||
|
||
const activationLinkSelector = 'a:has-text("Activate Plugin"), a.activate-now, .button.activate-now';
|
||
const alreadyInstalledSelector = 'body:has-text("Destination folder already exists.")';
|
||
const mixedSuccessSelector = 'body:has-text("Plugin installed successfully.")';
|
||
const genericErrorSelector = '.wrap > .error, .wrap > #message.error';
|
||
|
||
try {
|
||
await page.waitForSelector(
|
||
`${activationLinkSelector}, ${alreadyInstalledSelector}, ${mixedSuccessSelector}, ${genericErrorSelector}`,
|
||
{ timeout: 90000 }
|
||
);
|
||
} catch (e) {
|
||
throw new Error('Timed out waiting for a response after clicking "Install Now".');
|
||
}
|
||
|
||
if (await page.locator(activationLinkSelector).count() > 0) {
|
||
const activateButton = page.locator(activationLinkSelector);
|
||
await Promise.all([
|
||
page.waitForNavigation({ waitUntil: 'networkidle' }),
|
||
activateButton.first().click(),
|
||
]);
|
||
console.log(' Installed & Activated!');
|
||
} else if (await page.locator(alreadyInstalledSelector).count() > 0) {
|
||
console.log(' Plugin already installed.');
|
||
} else if (await page.locator(mixedSuccessSelector).count() > 0) {
|
||
console.log(' Install succeeded, but page reported an error. Navigating to plugins page to activate...');
|
||
await page.goto(`${adminUrl}plugins.php`, { waitUntil: 'networkidle' });
|
||
const pluginRow = page.locator('tr[data-slug="disembark-connector"]');
|
||
const activateLink = pluginRow.locator('a.edit:has-text("Activate")');
|
||
if (await activateLink.count() > 0) {
|
||
await Promise.all([
|
||
page.waitForNavigation({ waitUntil: 'networkidle' }),
|
||
activateLink.click()
|
||
]);
|
||
console.log(' Activated!');
|
||
} else {
|
||
console.log(' - Plugin was already active on the plugins page.');
|
||
}
|
||
} else {
|
||
const errorText = await page.locator(genericErrorSelector).first().textContent();
|
||
throw new Error(`Plugin installation failed with a WordPress error: ${errorText.trim()}`);
|
||
}
|
||
|
||
fs.unlinkSync(pluginZipPath);
|
||
fs.rmdirSync(tempDir);
|
||
}
|
||
|
||
// 4. RETRIEVE TOKEN
|
||
process.stdout.write(' - Step 4/5: Retrieving connection token...');
|
||
const tokenPageUrl = `${adminUrl}plugin-install.php?tab=plugin-information&plugin=disembark-connector`;
|
||
await page.goto(tokenPageUrl, { waitUntil: 'networkidle' });
|
||
|
||
const tokenElement = page.locator('div#section-description > code');
|
||
if (await tokenElement.count() === 0) {
|
||
throw new Error('Could not find the connection token element on the page.');
|
||
}
|
||
const token = await tokenElement.first().textContent();
|
||
console.log(' Token found!');
|
||
// 5. OUTPUT TOKEN FOR BASH SCRIPT
|
||
process.stdout.write(' - Step 5/5: Sending token back to script...');
|
||
console.log(token.trim());
|
||
|
||
} catch (error) {
|
||
console.error(`\nError: ${error.message}`);
|
||
process.exit(1);
|
||
} finally {
|
||
await browser.close();
|
||
}
|
||
}
|
||
|
||
main();
|
||
EOF
|
||
)
|
||
# --- Helper function for getting credentials ---
|
||
_get_credentials() {
|
||
echo "Please provide WordPress administrator credentials:"
|
||
username=$("$GUM_CMD" input --placeholder="Enter WordPress username...")
|
||
if [ -z "$username" ]; then
|
||
echo "No username provided. Aborting." >&2
|
||
return 1
|
||
fi
|
||
|
||
password=$("$GUM_CMD" input --placeholder="Enter WordPress password..." --password)
|
||
if [ -z "$password" ]; then
|
||
echo "No password provided. Aborting." >&2
|
||
return 1
|
||
fi
|
||
return 0
|
||
}
|
||
|
||
# --- Helper for running playwright ---
|
||
run_playwright_and_get_token() {
|
||
local url_to_run="$1"
|
||
local path_to_run="$2"
|
||
local user_to_run="$3"
|
||
local pass_to_run="$4"
|
||
|
||
echo "🤖 Launching browser to automate login and plugin setup..."
|
||
echo " - Attempting login at: ${url_to_run}${path_to_run}"
|
||
|
||
set -o pipefail
|
||
local full_output
|
||
full_output=$(echo "$PLAYWRIGHT_SCRIPT" | node - "$url_to_run" "$path_to_run" "$user_to_run" "$pass_to_run" "$debug_flag" | tee /dev/tty)
|
||
local exit_code=$?
|
||
set +o pipefail
|
||
|
||
if [ $exit_code -eq 3 ]; then
|
||
return 3 # Bad credentials
|
||
elif [ $exit_code -eq 2 ]; then
|
||
return 2 # Invalid URL
|
||
elif [ $exit_code -ne 0 ]; then
|
||
return 1 # General failure
|
||
fi
|
||
|
||
echo "$full_output" | tail -n 1 | tr -d '[:space:]'
|
||
return 0
|
||
}
|
||
|
||
# --- Authentication Loop ---
|
||
local token
|
||
local playwright_exit_code
|
||
|
||
# Initial credential prompt
|
||
if ! _get_credentials; then return 1; fi
|
||
|
||
while true; do
|
||
token=$(run_playwright_and_get_token "$base_url" "$login_path" "$username" "$password")
|
||
playwright_exit_code=$?
|
||
|
||
if [ $playwright_exit_code -eq 0 ]; then
|
||
break # Success
|
||
elif [ $playwright_exit_code -eq 2 ]; then # Invalid URL
|
||
echo "⚠️ The login URL '${base_url}${login_path}' appears to be incorrect."
|
||
local new_login_url
|
||
new_login_url=$("$GUM_CMD" input --placeholder="Enter the full, correct WordPress Admin URL...")
|
||
|
||
if [ -z "$new_login_url" ]; then
|
||
echo "No URL provided. Aborting." >&2; return 1;
|
||
fi
|
||
base_url=$(echo "$new_login_url" | sed -E 's#(https?://[^/]+).*#\1#')
|
||
login_path=$(echo "$new_login_url" | sed -E "s#$base_url##")
|
||
continue # Retry loop with new URL
|
||
elif [ $playwright_exit_code -eq 3 ]; then # Bad credentials
|
||
echo "⚠️ Login failed. The credentials may be incorrect."
|
||
if "$GUM_CMD" confirm "Re-enter credentials and try again?"; then
|
||
if ! _get_credentials; then return 1; fi
|
||
continue # Retry loop with new credentials
|
||
else
|
||
echo "Authentication cancelled." >&2; return 1;
|
||
fi
|
||
else # General failure
|
||
echo "❌ Browser automation failed. Please check errors above." >&2
|
||
return 1
|
||
fi
|
||
done
|
||
|
||
# --- Final Check and Backup ---
|
||
if [ $playwright_exit_code -ne 0 ] || [ -z "$token" ]; then
|
||
echo "❌ Could not retrieve a token. Aborting." >&2
|
||
return 1
|
||
fi
|
||
|
||
echo "✅ Browser automation successful. Token retrieved."
|
||
echo "📞 Connecting and starting backup with disembark-cli..."
|
||
if ! "$DISEMBARK_CMD" connect "${base_url}" "${token}"; then
|
||
echo "❌ Error: Failed to connect using the retrieved token." >&2
|
||
return 1
|
||
fi
|
||
|
||
if ! "$DISEMBARK_CMD" backup "${base_url}"; then
|
||
echo "❌ Error: Backup command failed after connecting." >&2
|
||
return 1
|
||
fi
|
||
|
||
echo "✨ Disembark process complete!"
|
||
}
|
||
# ----------------------------------------------------
|
||
# Dumps the content of files matching a pattern into a single text file.
|
||
# ----------------------------------------------------
|
||
function run_dump() {
|
||
# --- 1. Validate Input ---
|
||
local INPUT_PATTERN="$1"
|
||
shift
|
||
local exclude_patterns=("$@")
|
||
|
||
if [ -z "$INPUT_PATTERN" ];
|
||
then
|
||
echo "Error: No input pattern provided." >&2
|
||
echo "Usage: _do dump \"<path/to/folder/*.extension>\" [-x <exclude_pattern>]..." >&2
|
||
return 1
|
||
fi
|
||
|
||
# --- 2. Determine Paths and Names ---
|
||
local SEARCH_DIR
|
||
SEARCH_DIR=$(dirname "$INPUT_PATTERN")
|
||
local FILE_PATTERN
|
||
FILE_PATTERN=$(basename "$INPUT_PATTERN")
|
||
|
||
local OUTPUT_BASENAME
|
||
OUTPUT_BASENAME=$(basename "$SEARCH_DIR")
|
||
local OUTPUT_FILE
|
||
if [ "$OUTPUT_BASENAME" == "." ]; then
|
||
# If searching in the current dir, use the folder's name for the output file.
|
||
OUTPUT_BASENAME=$(basename "$(pwd)")
|
||
OUTPUT_FILE="${OUTPUT_BASENAME}-dump.txt"
|
||
else
|
||
OUTPUT_FILE="${OUTPUT_BASENAME}.txt"
|
||
fi
|
||
|
||
# --- 3. Process Files ---
|
||
> "$OUTPUT_FILE"
|
||
|
||
echo "Searching in '$SEARCH_DIR' for files matching '$FILE_PATTERN'..."
|
||
if [ ${#exclude_patterns[@]} -gt 0 ]; then
|
||
echo "Excluding user-defined patterns: ${exclude_patterns[*]}"
|
||
fi
|
||
echo "Automatically excluding: .git directory contents"
|
||
|
||
# Dynamically build the find command
|
||
local find_cmd=("find" "$SEARCH_DIR" "-type" "f" "-name" "$FILE_PATTERN")
|
||
|
||
# Add user-defined exclusions
|
||
for pattern in "${exclude_patterns[@]}"; do
|
||
if [[ "$pattern" == */ ]]; then
|
||
# For directories (pattern ends with /), use -path
|
||
local dir_pattern=${pattern%/} # remove trailing slash
|
||
find_cmd+=("-not" "-path" "*/$dir_pattern/*")
|
||
else
|
||
# For files, use -name
|
||
find_cmd+=("-not" "-name" "$pattern")
|
||
fi
|
||
done
|
||
|
||
# Add automatic exclusions for the output file and .git directory
|
||
find_cmd+=("-not" "-name" "$OUTPUT_FILE")
|
||
find_cmd+=("-not" "-path" "*/.git/*")
|
||
|
||
# Execute the find command
|
||
"${find_cmd[@]}" -print0 | while IFS= read -r -d '' file; do
|
||
echo "--- File: $file ---" >> "$OUTPUT_FILE"
|
||
cat "$file" >> "$OUTPUT_FILE"
|
||
echo -e "\n" >> "$OUTPUT_FILE"
|
||
done
|
||
|
||
# --- 4. Final Report ---
|
||
if [ ! -s "$OUTPUT_FILE" ]; then
|
||
echo "Warning: No files found matching the pattern. No dump file created."
|
||
rm "$OUTPUT_FILE"
|
||
return 0
|
||
fi
|
||
|
||
local FILE_SIZE
|
||
FILE_SIZE=$(du -h "$OUTPUT_FILE" | cut -f1 | xargs)
|
||
|
||
# --- WordPress URL Logic ---
|
||
local dump_url=""
|
||
# Silently check if WP-CLI is available and we're in a WordPress installation.
|
||
if setup_wp_cli &>/dev/null && "$WP_CLI_CMD" core is-installed --quiet 2>/dev/null; then
|
||
local wp_home
|
||
wp_home=$("$WP_CLI_CMD" option get home --skip-plugins --skip-themes 2>/dev/null)
|
||
|
||
# We need `realpath` for this to work reliably
|
||
if [ -n "$wp_home" ] && command -v realpath &>/dev/null; then
|
||
local wp_root_path
|
||
# Use `wp config path` to get the wp-config.php path, which is more reliable.
|
||
wp_root_path=$("$WP_CLI_CMD" config path --quiet 2>/dev/null)
|
||
|
||
# Only proceed if we found a valid wp-config.php path.
|
||
if [ -n "$wp_root_path" ] && [ -f "$wp_root_path" ]; then
|
||
wp_root_path=$(dirname "$wp_root_path")
|
||
|
||
local current_path
|
||
current_path=$(realpath ".")
|
||
|
||
# Get the path of the current directory relative to the WordPress root
|
||
local relative_path
|
||
relative_path=${current_path#"$wp_root_path"}
|
||
|
||
# Construct the final URL
|
||
# This ensures no double slashes and correctly handles the root directory case
|
||
dump_url="${wp_home%/}${relative_path}/${OUTPUT_FILE}"
|
||
fi
|
||
fi
|
||
fi
|
||
# --- End WordPress URL Logic ---
|
||
|
||
echo "Generated $OUTPUT_FILE ($FILE_SIZE)"
|
||
if [ -n "$dump_url" ]; then
|
||
echo "URL: $dump_url"
|
||
fi
|
||
}
|
||
# ----------------------------------------------------
|
||
# Sends an email using wp_mail.
|
||
# ----------------------------------------------------
|
||
function run_email() {
|
||
echo "🚀 Preparing to send an email via WP-CLI..."
|
||
|
||
# --- Pre-flight Checks ---
|
||
if ! setup_wp_cli; then echo "❌ Error: WP-CLI not found." >&2; return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then echo "❌ Error: This does not appear to be a WordPress installation." >&2; return 1; fi
|
||
if ! setup_gum; then echo "Aborting: gum setup failed." >&2; return 1; fi
|
||
|
||
# --- Gather Email Details with Gum ---
|
||
local to_email
|
||
to_email=$("$GUM_CMD" input --placeholder="Recipient email address...")
|
||
if [ -z "$to_email" ]; then echo "❌ No email address provided. Aborting."; return 1; fi
|
||
|
||
local subject
|
||
subject=$("$GUM_CMD" input --placeholder="Email subject...")
|
||
if [ -z "$subject" ]; then echo "❌ No subject provided. Aborting."; return 1; fi
|
||
|
||
local content
|
||
echo "Enter email content (press Ctrl+D when finished):"
|
||
content=$("$GUM_CMD" write)
|
||
if [ -z "$content" ]; then echo "❌ No content provided. Aborting."; return 1; fi
|
||
|
||
# --- Construct and Execute Command ---
|
||
echo "Sending email..."
|
||
|
||
# Escape single quotes in the variables to prevent breaking the wp eval command
|
||
local escaped_to_email; escaped_to_email=$(printf "%s" "$to_email" | sed "s/'/\\\'/g")
|
||
local escaped_subject; escaped_subject=$(printf "%s" "$subject" | sed "s/'/\\\'/g")
|
||
local escaped_content; escaped_content=$(printf "%s" "$content" | sed "s/'/\\\'/g")
|
||
|
||
local wp_command="wp_mail( '$escaped_to_email', '$escaped_subject', '$escaped_content', ['Content-Type: text/html; charset=UTF-8'] );"
|
||
|
||
# Use a temporary variable to capture the output from wp eval
|
||
local eval_output
|
||
eval_output=$("$WP_CLI_CMD" eval "$wp_command" 2>&1)
|
||
local exit_code=$?
|
||
|
||
# The `wp_mail` function in WordPress returns `true` on success and `false` on failure.
|
||
# However, `wp eval` doesn't directly translate this boolean to an exit code.
|
||
# We can check the output. A successful `wp_mail` call via `wp eval` usually produces no output.
|
||
# A failure might produce a PHP error or warning.
|
||
if [ $exit_code -eq 0 ]; then
|
||
echo "✅ Email command sent successfully to $to_email."
|
||
echo " Please check the recipient's inbox and the mail server logs to confirm delivery."
|
||
else
|
||
echo "❌ Error: The 'wp eval' command failed. Please check your WordPress email configuration."
|
||
echo " WP-CLI output:"
|
||
echo "$eval_output"
|
||
return 1
|
||
fi
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Finds files that have been recently modified.
|
||
# ----------------------------------------------------
|
||
function find_recent_files() {
|
||
local days="${1:-1}" # Default to 1 day if no argument is provided
|
||
|
||
# Validate that the input is a number
|
||
if ! [[ "$days" =~ ^[0-9]+$ ]]; then
|
||
echo "❌ Error: Please provide a valid number of days." >&2
|
||
echo "Usage: _do find recent-files <days>" >&2
|
||
return 1
|
||
fi
|
||
|
||
echo "🔎 Searching for files modified in the last $days day(s)..."
|
||
echo
|
||
|
||
# Check the operating system to use the correct `find` command syntax.
|
||
# The `-printf` option is not available on macOS/BSD `find`.
|
||
if [[ "$(uname)" == "Darwin" ]]; then
|
||
# On macOS, use -exec with `stat` for formatted, sortable output.
|
||
# -f "%Sm %N" formats the output: Modification time, then file name.
|
||
# -t "%Y-%m-%d %H:%M:%S" specifies the timestamp format for sorting.
|
||
find . -type f -mtime "-${days}" -exec stat -f "%Sm %N" -t "%Y-%m-%d %H:%M:%S" {} + | sort -r
|
||
else
|
||
# On Linux, the more efficient -printf option is available.
|
||
find . -type f -mtime "-${days}" -printf "%TY-%Tm-%Td %TH:%M:%S %p\n" | sort -r
|
||
fi
|
||
|
||
if [ $? -ne 0 ]; then
|
||
echo "❌ Error: The 'find' command failed to execute." >&2
|
||
return 1
|
||
fi
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Identifies plugins that may be slowing down WP-CLI command execution.
|
||
# ----------------------------------------------------
|
||
function find_slow_plugins() {
|
||
local page_to_check="${1}"
|
||
|
||
_get_wp_execution_time() {
|
||
local output
|
||
output=$("$WP_CLI_CMD" "$@" --debug 2>&1)
|
||
echo "$output" | perl -ne '/Debug \(bootstrap\): Running command: .+\(([^s]+s)/ && print $1'
|
||
}
|
||
if ! setup_wp_cli; then echo "❌ Error: WP-CLI (wp command) not found." >&2; return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then echo "❌ Error: This does not appear to be a WordPress installation." >&2; return 1; fi
|
||
|
||
local base_command_args=("plugin" "list")
|
||
local skip_argument="--skip-plugins"
|
||
local description="wp plugin list --debug"
|
||
|
||
if [ -n "$page_to_check" ]; then
|
||
echo "🚀 WordPress Plugin Performance Test for page: '$page_to_check' 🚀"
|
||
description="wp render \"$page_to_check\" --debug"
|
||
|
||
# Check for wp render and install if missing
|
||
if ! "$WP_CLI_CMD" help render &> /dev/null; then
|
||
echo "ℹ️ 'wp render' command not found. Installing 'render-command' plugin..."
|
||
if ! "$WP_CLI_CMD" plugin install https://github.com/austinginder/render-command/releases/latest/download/render-command.zip --activate --force; then
|
||
echo "❌ Error: Failed to install 'render-command' plugin. Aborting." >&2
|
||
return 1
|
||
fi
|
||
echo "✅ 'render-command' plugin installed successfully."
|
||
fi
|
||
|
||
# Update command variables to use 'wp render'
|
||
base_command_args=("render" "$page_to_check")
|
||
skip_argument="--without-plugin"
|
||
else
|
||
echo "🚀 WordPress Plugin Performance Test 🚀"
|
||
fi
|
||
|
||
echo "This script measures the execution time of '$description' under various conditions."
|
||
echo ""
|
||
echo "📋 Initial Baseline Measurements for '$description':"
|
||
|
||
local base_time_s
|
||
printf " ⏳ Measuring base time (ALL plugins & theme active)... "
|
||
base_time_s=$(_get_wp_execution_time "${base_command_args[@]}")
|
||
if [[ -z "$base_time_s" ]]; then
|
||
echo "❌ Error: Could not measure base execution time." >&2
|
||
return 1
|
||
fi
|
||
echo "Base time: $base_time_s"
|
||
echo ""
|
||
|
||
local active_plugins=()
|
||
while IFS= read -r line; do
|
||
active_plugins+=("$line")
|
||
done < <("$WP_CLI_CMD" plugin list --field=name --status=active)
|
||
|
||
if [[ ${#active_plugins[@]} -eq 0 ]]; then
|
||
echo "ℹ️ No active plugins found to test."
|
||
return 0
|
||
fi
|
||
|
||
echo "📊 Measuring impact of individual plugins (compared to '${base_time_s}' base time):"
|
||
echo "A larger positive 'Impact' suggests the plugin contributes more to the load time of this specific WP-CLI command."
|
||
echo "---------------------------------------------------------------------------------"
|
||
printf "%-40s | %-15s | %-15s\n" "Plugin Skipped" "Time w/ Skip" "Impact (Base-Skip)"
|
||
echo "---------------------------------------------------------------------------------"
|
||
local results=()
|
||
for plugin in "${active_plugins[@]}"; do
|
||
# Skip the render-command plugin itself when using the render method
|
||
if [[ -n "$page_to_check" && "$plugin" == "render-command" ]]; then
|
||
continue
|
||
fi
|
||
|
||
local time_with_skip_s
|
||
time_with_skip_s=$(_get_wp_execution_time "${base_command_args[@]}" "${skip_argument}=$plugin")
|
||
|
||
if [[ -n "$time_with_skip_s" ]]; then
|
||
local diff_s
|
||
diff_s=$(awk -v base="${base_time_s%s}" -v skip="${time_with_skip_s%s}" 'BEGIN { printf "%.3f", base - skip }')
|
||
local impact_sign=""
|
||
if [[ $(awk -v diff="$diff_s" 'BEGIN { print (diff > 0) }') -eq 1 ]]; then
|
||
impact_sign="+"
|
||
fi
|
||
results+=("$(printf "%.3f" "$diff_s")|$plugin|$time_with_skip_s|${impact_sign}${diff_s}s")
|
||
else
|
||
results+=("0.000|$plugin|Error|Error measuring")
|
||
fi
|
||
done
|
||
|
||
local sorted_results=()
|
||
while IFS= read -r line; do
|
||
sorted_results+=("$line")
|
||
done < <(printf "%s\n" "${results[@]}" | sort -t'|' -k1,1nr)
|
||
|
||
for result_line in "${sorted_results[@]}"; do
|
||
local p_name
|
||
p_name=$(echo "$result_line" | cut -d'|' -f2)
|
||
local t_skip
|
||
t_skip=$(echo "$result_line" | cut -d'|' -f3)
|
||
local i_str
|
||
i_str=$(echo "$result_line" | cut -d'|' -f4)
|
||
printf "%-40s | %-15s | %-15s\n" "$p_name" "$t_skip" "$i_str"
|
||
done
|
||
echo "---------------------------------------------------------------------------------"
|
||
echo ""
|
||
echo "✅ Test Complete"
|
||
echo "💡 Note: This measures impact on a specific WP-CLI command. For front-end or"
|
||
echo " admin profiling, consider using a plugin like Query Monitor or New Relic."
|
||
echo ""
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Detects plugins that are active but hidden from the standard plugin list.
|
||
# ----------------------------------------------------
|
||
function find_hidden_plugins() {
|
||
# --- Pre-flight Checks ---
|
||
if ! setup_wp_cli; then echo "❌ Error: WP-CLI not found." >&2; return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then echo "❌ Error: This does not appear to be a WordPress installation." >&2; return 1; fi
|
||
if ! setup_gum; then return 1; fi
|
||
|
||
echo "🚀 Checking for hidden WordPress plugins..."
|
||
|
||
# Get the standard list of active plugins
|
||
local active_plugins
|
||
active_plugins=$("$WP_CLI_CMD" plugin list --field=name --status=active)
|
||
|
||
# Get the "raw" list of active plugins by skipping themes and other plugins
|
||
local active_plugins_raw
|
||
active_plugins_raw=$("$WP_CLI_CMD" plugin list --field=name --status=active --skip-themes --skip-plugins)
|
||
|
||
local regular_count
|
||
regular_count=$(echo "$active_plugins" | wc -l | xargs)
|
||
local raw_count
|
||
raw_count=$(echo "$active_plugins_raw" | wc -l | xargs)
|
||
|
||
|
||
# Compare the counts of the two lists.
|
||
if [[ "$regular_count" == "$raw_count" ]]; then
|
||
echo "✅ No hidden plugins detected. The standard and raw plugin lists match ($regular_count plugins)."
|
||
return 0
|
||
fi
|
||
|
||
# If the counts differ, find the plugins that are in the raw list but not the standard one.
|
||
echo "⚠️ Found a discrepancy between plugin lists!"
|
||
echo " - Standard list shows: $regular_count active plugins."
|
||
echo " - Raw list shows: $raw_count active plugins."
|
||
echo
|
||
|
||
# Use 'comm' to find lines unique to the raw list.
|
||
local hidden_plugins
|
||
hidden_plugins=$(comm -13 <(echo "$active_plugins" | sort) <(echo "$active_plugins_raw" | sort))
|
||
|
||
if [ -z "$hidden_plugins" ]; then
|
||
echo "ℹ️ Could not isolate the specific hidden plugins, but a discrepancy exists."
|
||
else
|
||
echo "--- Found Hidden Plugin(s) ---"
|
||
# Loop through each hidden plugin and get its details
|
||
while IFS= read -r plugin; do
|
||
if [ -z "$plugin" ]; then continue; fi
|
||
|
||
"$GUM_CMD" log --level warn "Details for: $plugin"
|
||
|
||
# Get plugin details in CSV format and pipe to gum for a clean table printout.
|
||
"$WP_CLI_CMD" plugin get "$plugin" --skip-plugins --skip-themes --format=csv | \
|
||
"$GUM_CMD" table --separator "," --widths=15,0 --print
|
||
|
||
echo
|
||
done <<< "$hidden_plugins"
|
||
echo "💡 These plugins are active but may be hidden from the admin view or standard WP-CLI list."
|
||
echo " Common offenders are management plugins (like ManageWP's 'worker') or potentially malicious code."
|
||
fi
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Scans for potential malware and verifies WordPress core/plugin integrity.
|
||
# ----------------------------------------------------
|
||
function find_malware() {
|
||
# --- Pre-flight Checks ---
|
||
if ! setup_wp_cli; then echo "❌ Error: WP-CLI not found." >&2; return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then echo "❌ Error: This does not appear to be a WordPress installation." >&2; return 1; fi
|
||
if ! command -v grep &> /dev/null; then echo "❌ Error: 'grep' command not found." >&2; return 1; fi
|
||
if ! setup_gum; then return 1; fi
|
||
|
||
echo "🚀 Starting malware scan..."
|
||
echo "This process will check for suspicious code patterns and verify core/plugin file integrity."
|
||
echo
|
||
|
||
# --- 1. Hunt for suspicious PHP code ---
|
||
echo "--- Step 1/3: Searching for suspicious PHP code patterns... ---"
|
||
local suspicious_patterns=(
|
||
'eval(base64_decode('
|
||
'eval(gzinflate('
|
||
'eval(gzuncompress('
|
||
'eval(str_rot13('
|
||
'preg_replace.*\/e'
|
||
'create_function'
|
||
'FilesMan'
|
||
'c99shell'
|
||
'r57shell'
|
||
'shell_exec('
|
||
'passthru('
|
||
'system('
|
||
'phpinfo('
|
||
'assert('
|
||
)
|
||
|
||
local found_suspicious_files=false
|
||
local combined_pattern
|
||
combined_pattern=$(IFS='|'; echo "${suspicious_patterns[*]}")
|
||
local search_results
|
||
search_results=$(grep -rn --include='*.php' -iE "$combined_pattern" . 2>/dev/null)
|
||
|
||
if [ -n "$search_results" ]; then
|
||
echo "⚠️ Found potentially malicious code in the following files:"
|
||
echo "-----------------------------------------------------"
|
||
echo "$search_results"
|
||
echo "-----------------------------------------------------"
|
||
echo "💡 Review these files carefully. They may contain legitimate code that matches these patterns."
|
||
found_suspicious_files=true
|
||
else
|
||
echo "✅ No suspicious code patterns found."
|
||
fi
|
||
echo
|
||
|
||
# --- 2. Verify WordPress Core Checksums ---
|
||
echo "--- Step 2/3: Verifying WordPress core file integrity... ---"
|
||
if ! "$WP_CLI_CMD" core verify-checksums --skip-plugins --skip-themes; then
|
||
echo "⚠️ WordPress core verification failed. The files listed above may have been modified."
|
||
else
|
||
echo "✅ WordPress core files verified successfully."
|
||
fi
|
||
echo
|
||
|
||
# --- 3. Verify Plugin Checksums ---
|
||
echo "--- Step 3/3: Verifying plugin file integrity (from wordpress.org)... ---"
|
||
local stderr_file_plugin
|
||
stderr_file_plugin=$(mktemp)
|
||
|
||
local plugin_csv_data
|
||
plugin_csv_data=$("$WP_CLI_CMD" plugin verify-checksums --all --format=csv --skip-plugins --skip-themes --quiet 2> "$stderr_file_plugin")
|
||
local plugin_checksum_status=$?
|
||
|
||
local plugin_summary_error
|
||
plugin_summary_error=$(cat "$stderr_file_plugin")
|
||
rm "$stderr_file_plugin"
|
||
|
||
if [ $plugin_checksum_status -ne 0 ]; then
|
||
echo "⚠️ Plugin verification encountered an error or found mismatches."
|
||
|
||
# Check if there is any CSV data to display
|
||
if [[ -n "$plugin_csv_data" ]]; then
|
||
echo "$plugin_csv_data" | "$GUM_CMD" table --separator "," --print
|
||
fi
|
||
|
||
# Display the summary error if it exists
|
||
if [ -n "$plugin_summary_error" ]; then
|
||
echo "$plugin_summary_error"
|
||
fi
|
||
echo "💡 This may include plugins not in the wordpress.org directory (premium plugins) or modified files."
|
||
else
|
||
echo "✅ All plugins from wordpress.org verified successfully."
|
||
fi
|
||
echo
|
||
|
||
echo "✅ Malware scan complete."
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Finds outdated or invalid PHP opening tags in PHP files.
|
||
# ----------------------------------------------------
|
||
function find_outdated_php_tags() {
|
||
local search_dir="${1:-.}"
|
||
|
||
# Ensure the search directory ends with a slash for consistency
|
||
if [[ "${search_dir: -1}" != "/" ]]; then
|
||
search_dir+="/"
|
||
fi
|
||
|
||
if [ ! -d "$search_dir" ]; then
|
||
echo "❌ Error: Directory '$search_dir' not found." >&2
|
||
return 1
|
||
fi
|
||
|
||
echo "🚀 Searching for outdated PHP tags in '${search_dir}'..."
|
||
echo "This can take a moment for large directories."
|
||
echo
|
||
|
||
# This new, more portable method first finds all lines with '<?',
|
||
# then filters out the lines containing valid tags like '<?php', '<?=', or '<?xml'.
|
||
# This avoids reliance on potentially unsupported 'grep -P' features.
|
||
local initial_results
|
||
initial_results=$(grep --include="*.php" --line-number --recursive '<?' "$search_dir" 2>/dev/null \
|
||
| grep -v -F -e '<?php' -e '<?=' -e '<?xml' \
|
||
| grep --color=always -e '<?' -e '$^'
|
||
)
|
||
|
||
# Filter out common false positives from comments, strings, etc.
|
||
local found_tags
|
||
found_tags=$(echo "$initial_results" \
|
||
| grep -v -F -e "strpos(" -e "str_replace(" \
|
||
| grep -v -E "^[^:]*:[^:]*:\s*(\*|//|#)|'\<\?'|\"\<\?\"" \
|
||
)
|
||
|
||
if [ -z "$found_tags" ]; then
|
||
echo "✅ No outdated PHP tags were found (after filtering common false positives)."
|
||
else
|
||
echo "⚠️ Found potentially outdated PHP tags in the following files:"
|
||
echo "-----------------------------------------------------"
|
||
# The output from grep is already well-formatted.
|
||
echo "$found_tags"
|
||
echo "-----------------------------------------------------"
|
||
# Use single quotes instead of backticks to prevent command execution.
|
||
echo "Recommendation: Replace all short tags like '<?' with the full '<?php' tag."
|
||
fi
|
||
}
|
||
# ----------------------------------------------------
|
||
# Applies HTTPS to a WordPress site's URLs.
|
||
# ----------------------------------------------------
|
||
function run_https() {
|
||
echo "🚀 Applying HTTPS to site URLs..."
|
||
|
||
# --- Pre-flight Checks ---
|
||
if ! setup_wp_cli; then echo "❌ Error: WP-CLI not found." >&2; return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then echo "❌ Error: This does not appear to be a WordPress installation." >&2; return 1; fi
|
||
if ! setup_gum; then echo "❌ Error: gum is required for interactive prompts." >&2; return 1; fi
|
||
|
||
# --- Get Base Domain ---
|
||
# Strips http/https and www to get a clean domain name.
|
||
local domain
|
||
domain=$("$WP_CLI_CMD" option get home)
|
||
domain=${domain/http:\/\/www./}
|
||
domain=${domain/https:\/\/www./}
|
||
domain=${domain/http:\/\//}
|
||
domain=${domain/https:\/\//}
|
||
# Trim whitespace just in case
|
||
domain=$( echo "$domain" | awk '{$1=$1};1' )
|
||
|
||
# --- Ask User Preference for 'www' ---
|
||
local use_www=false
|
||
# Ask the user, with "No" as the default option.
|
||
# If they select "Yes" (exit code 0), then set use_www to true.
|
||
if "$GUM_CMD" confirm "Should the new HTTPS URL include 'www.'?" --default=false; then
|
||
use_www=true
|
||
fi
|
||
|
||
# --- Define Target URLs ---
|
||
local new_url
|
||
local new_url_escaped
|
||
if [ "$use_www" = true ]; then
|
||
new_url="https://www.$domain"
|
||
new_url_escaped="https:\/\/www.$domain"
|
||
else
|
||
new_url="https://$domain"
|
||
new_url_escaped="https:\/\/$domain"
|
||
fi
|
||
|
||
echo "This will update all URLs to use '$new_url'."
|
||
"$GUM_CMD" confirm "Proceed with search and replace?" || { echo "Operation cancelled by user."; return 0; }
|
||
|
||
# --- Run Replacements ---
|
||
echo "1/4: Replacing http://$domain ..."
|
||
"$WP_CLI_CMD" search-replace "http://$domain" "$new_url" --all-tables --skip-plugins --skip-themes --report-changed-only
|
||
|
||
echo "2/4: Replacing http://www.$domain ..."
|
||
"$WP_CLI_CMD" search-replace "http://www.$domain" "$new_url" --all-tables --skip-plugins --skip-themes --report-changed-only
|
||
|
||
echo "3/4: Replacing escaped http:\/\/$domain ..."
|
||
"$WP_CLI_CMD" search-replace "http:\/\/$domain" "$new_url_escaped" --all-tables --skip-plugins --skip-themes --report-changed-only
|
||
|
||
echo "4/4: Replacing escaped http:\/\/www.$domain ..."
|
||
"$WP_CLI_CMD" search-replace "http:\/\/www.$domain" "$new_url_escaped" --all-tables --skip-plugins --skip-themes --report-changed-only
|
||
|
||
echo "Flushing WordPress cache..."
|
||
"$WP_CLI_CMD" cache flush
|
||
|
||
echo ""
|
||
echo "✅ HTTPS migration complete! All URLs updated to '$new_url'."
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Installs helper and premium plugins.
|
||
# ----------------------------------------------------
|
||
|
||
# ----------------------------------------------------
|
||
# Installs the Kinsta Must-Use plugin.
|
||
# ----------------------------------------------------
|
||
function install_kinsta_mu() {
|
||
local force_flag="$1"
|
||
|
||
# Check if this is a Kinsta environment unless --force is used
|
||
if [[ "$force_flag" != "true" ]]; then
|
||
if [ ! -f "/etc/update-motd.d/00-kinsta-welcome" ]; then
|
||
echo "ℹ️ This does not appear to be a Kinsta environment. Skipping installation." >&2
|
||
echo " Use the --force flag to install anyway." >&2
|
||
return 0
|
||
fi
|
||
else
|
||
echo "✅ --force flag detected. Skipping Kinsta environment check."
|
||
fi
|
||
|
||
echo "🚀 Installing Kinsta MU plugin..."
|
||
|
||
# --- Pre-flight Checks ---
|
||
if ! setup_wp_cli; then echo "❌ Error: WP-CLI not found." >&2; return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then echo "❌ Error: This does not appear to be a WordPress installation." >&2; return 1; fi
|
||
if ! command -v wget &>/dev/null; then echo "❌ Error: wget not found." >&2; return 1; fi
|
||
if ! command -v unzip &>/dev/null; then echo "❌ Error: unzip not found." >&2; return 1; fi
|
||
|
||
# Get wp-content path dynamically for reliability
|
||
local wp_content_dir
|
||
wp_content_dir=$("$WP_CLI_CMD" eval "echo rtrim(WP_CONTENT_DIR, '/');" --skip-plugins --skip-themes 2>/dev/null)
|
||
if [ -z "$wp_content_dir" ] || [ ! -d "$wp_content_dir" ]; then
|
||
echo "❌ Error: Could not determine wp-content directory." >&2
|
||
return 1
|
||
fi
|
||
|
||
local mu_plugins_dir="${wp_content_dir}/mu-plugins"
|
||
if [ ! -d "$mu_plugins_dir" ]; then
|
||
echo "Creating directory: $mu_plugins_dir"
|
||
mkdir -p "$mu_plugins_dir"
|
||
fi
|
||
|
||
# --- Installation ---
|
||
local kinsta_zip_file="kinsta-mu-plugins.zip"
|
||
|
||
# Download to the private directory to avoid clutter
|
||
local private_dir
|
||
if ! private_dir=$(_get_private_dir); then
|
||
return 1
|
||
fi
|
||
local temp_zip_path="${private_dir}/${kinsta_zip_file}"
|
||
|
||
if wget -q https://kinsta.com/kinsta-tools/kinsta-mu-plugins.zip -O "$temp_zip_path"; then
|
||
unzip -o -q "$temp_zip_path" -d "$mu_plugins_dir/"
|
||
rm "$temp_zip_path"
|
||
echo "✅ Kinsta MU plugin installed successfully to ${mu_plugins_dir}/."
|
||
else
|
||
echo "❌ Error: Could not download the Kinsta MU plugin."
|
||
# Clean up failed download
|
||
[ -f "$temp_zip_path" ] && rm "$temp_zip_path"
|
||
return 1
|
||
fi
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Installs the CaptainCore Helper plugin.
|
||
# ----------------------------------------------------
|
||
function install_helper() {
|
||
echo "🚀 Deploying CaptainCore Helper..."
|
||
|
||
# --- Pre-flight Checks ---
|
||
if ! command -v curl &>/dev/null; then echo "❌ Error: curl not found." >&2; return 1; fi
|
||
|
||
# --- Deployment ---
|
||
if curl -sSL https://run.captaincore.io/deploy-helper | bash -s; then
|
||
echo "✅ CaptainCore Helper deployed successfully."
|
||
else
|
||
echo "❌ Error: Failed to deploy CaptainCore Helper."
|
||
return 1
|
||
fi
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Installs The Events Calendar Pro.
|
||
# ----------------------------------------------------
|
||
function install_events_calendar_pro() {
|
||
echo "🚀 Installing The Events Calendar Pro..."
|
||
|
||
# --- Pre-flight Checks ---
|
||
if ! setup_wp_cli; then echo "❌ Error: WP-CLI not found." >&2; return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then echo "❌ Error: This does not appear to be a WordPress installation." >&2; return 1; fi
|
||
if ! setup_gum; then echo "Aborting: gum setup failed." >&2; return 1; fi
|
||
|
||
# --- Get License Key ---
|
||
local license_key
|
||
license_key=$("$GUM_CMD" input --placeholder="Enter Events Calendar Pro license key..." --password)
|
||
|
||
if [ -z "$license_key" ]; then
|
||
echo "❌ No license key provided. Aborting installation." >&2
|
||
return 1
|
||
fi
|
||
|
||
# --- Installation Steps ---
|
||
echo "Step 1/3: Installing 'The Events Calendar' (free version)..."
|
||
if ! "$WP_CLI_CMD" plugin install the-events-calendar --force --activate; then
|
||
echo "❌ Error: Failed to install the free version of The Events Calendar." >&2
|
||
return 1
|
||
fi
|
||
|
||
echo "Step 2/3: Saving license key..."
|
||
if ! "$WP_CLI_CMD" option update pue_install_key_events_calendar_pro "$license_key"; then
|
||
echo "❌ Error: Failed to save the license key to the database." >&2
|
||
return 1
|
||
fi
|
||
|
||
echo "Step 3/3: Installing 'Events Calendar Pro'..."
|
||
local pro_plugin_url="https://pue.tri.be/api/plugins/v2/download?plugin=events-calendar-pro&key=$license_key"
|
||
if ! "$WP_CLI_CMD" plugin install "$pro_plugin_url" --force --activate; then
|
||
echo "❌ Error: Failed to install Events Calendar Pro. Please check your license key." >&2
|
||
return 1
|
||
fi
|
||
|
||
echo "✅ The Events Calendar Pro installed and activated successfully."
|
||
}
|
||
# ----------------------------------------------------
|
||
# Launches site - updates url from dev to live,
|
||
# enables search engine visibility, and clears cache.
|
||
# ----------------------------------------------------
|
||
function run_launch() {
|
||
# The domain is passed as the first argument, skip_confirm as the second
|
||
local domain="$1"
|
||
local skip_confirm="$2"
|
||
|
||
echo "🚀 Launching Site"
|
||
|
||
# --- Pre-flight Checks ---
|
||
if ! setup_wp_cli; then echo "❌ Error: WP-CLI not found." >&2; return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then echo "❌ Error: This does not appear to be a WordPress installation." >&2; return 1; fi
|
||
if ! setup_gum; then echo "❌ Error: gum is required for interactive prompts." >&2; return 1; fi
|
||
|
||
# --- Get New Domain ---
|
||
if [ -z "$domain" ]; then
|
||
# If no argument is passed, prompt interactively
|
||
domain=$("$GUM_CMD" input --placeholder "Enter the new live domain (e.g., example.com)...")
|
||
else
|
||
# If an argument is passed, just confirm the value
|
||
echo "Using provided domain: $domain"
|
||
fi
|
||
|
||
if [ -z "$domain" ]; then
|
||
echo "No domain entered. Launch cancelled."
|
||
return 1
|
||
fi
|
||
|
||
# --- Get Current Domain ---
|
||
local current_domain
|
||
current_domain=$("$WP_CLI_CMD" option get home --skip-plugins --skip-themes)
|
||
# Strip protocols
|
||
current_domain=${current_domain/http:\/\//}
|
||
current_domain=${current_domain/https:\/\//}
|
||
# Trim whitespace
|
||
current_domain=$(echo "$current_domain" | awk '{$1=$1};1')
|
||
|
||
if [[ -z "$current_domain" ]] || [[ "$current_domain" != *"."* ]]; then
|
||
echo "❌ Error: Could not find a valid existing domain from the WordPress installation." >&2
|
||
return 1
|
||
fi
|
||
|
||
if [[ "$current_domain" == "$domain" ]]; then
|
||
echo "The new domain is the same as the current domain. No changes needed."
|
||
return 0
|
||
fi
|
||
|
||
# --- Confirmation ---
|
||
# Only ask for confirmation if the skip_confirm flag is not true
|
||
if [[ "$skip_confirm" != "true" ]]; then
|
||
echo "This will update the site URL from '$current_domain' to '$domain'."
|
||
"$GUM_CMD" confirm "Proceed with launch?" || { echo "Operation cancelled by user."; return 0; }
|
||
fi
|
||
|
||
# --- Run URL Replacements ---
|
||
echo "1/2: Running search and replace for URLs..."
|
||
"$WP_CLI_CMD" search-replace "//$current_domain" "//$domain" --all-tables --skip-plugins --skip-themes --report-changed-only
|
||
|
||
echo "2/2: Running search and replace for escaped URLs..."
|
||
"$WP_CLI_CMD" search-replace "\/\/${current_domain}" "\/\/$domain" --all-tables --skip-plugins --skip-themes --report-changed-only
|
||
|
||
# --- Final Steps ---
|
||
echo "Enabling search engine visibility..."
|
||
"$WP_CLI_CMD" option update blog_public 1 --skip-plugins --skip-themes
|
||
|
||
echo "Flushing WordPress cache..."
|
||
"$WP_CLI_CMD" cache flush
|
||
|
||
# Check for Kinsta environment and purge cache if present
|
||
if [ -f "/etc/update-motd.d/00-kinsta-welcome" ] || [[ "$current_domain" == *"kinsta"* ]]; then
|
||
echo "Kinsta environment detected. Purging Kinsta cache..."
|
||
"$WP_CLI_CMD" kinsta cache purge --all
|
||
fi
|
||
|
||
echo ""
|
||
echo "✅ Site launch complete! The new domain is '$domain'."
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Migrates a site from a backup URL or local file.
|
||
# Arguments:
|
||
# $1 - The URL/path for the backup file.
|
||
# $2 - A flag indicating whether to update URLs.
|
||
# ----------------------------------------------------
|
||
function migrate_site() {
|
||
local backup_url="$1"
|
||
local update_urls_flag="$2"
|
||
|
||
echo "🚀 Starting Site Migration ..."
|
||
|
||
# --- Pre-flight Checks ---
|
||
if ! setup_wp_cli; then echo "❌ Error: WP-CLI not found." >&2; return 1; fi
|
||
if ! command -v wget &>/dev/null; then echo "❌ Error: wget not found." >&2; return 1; fi
|
||
if ! command -v unzip &>/dev/null; then echo "❌ Error: unzip not found." >&2; return 1; fi
|
||
if ! command -v tar &>/dev/null; then echo "❌ Error: tar not found." >&2; return 1; fi
|
||
|
||
local home_directory; home_directory=$(pwd)
|
||
local wp_home; wp_home=$( "$WP_CLI_CMD" option get home --skip-themes --skip-plugins )
|
||
if [[ "$wp_home" != "http"* ]]; then
|
||
echo "❌ Error: WordPress not found in current directory. Migration cancelled." >&2
|
||
return 1
|
||
fi
|
||
|
||
# --- Find Private Directory ---
|
||
local private_dir
|
||
if ! private_dir=$(_get_private_dir); then
|
||
# Error message is handled by the helper function.
|
||
echo "❌ Error: Can't locate a suitable private folder. Migration cancelled." >&2
|
||
return 1
|
||
fi
|
||
|
||
# --- Download and Extract Backup ---
|
||
local timedate; timedate=$(date +'%Y-%m-%d-%H%M%S')
|
||
local restore_dir="${private_dir}/restore_${timedate}"
|
||
mkdir -p "$restore_dir"
|
||
cd "$restore_dir" || return 1
|
||
|
||
local local_file_name; local_file_name=$(basename "$backup_url")
|
||
if [ -f "${home_directory}/${local_file_name}" ]; then
|
||
mv "${home_directory}/${local_file_name}" "${private_dir}/${local_file_name}"
|
||
fi
|
||
|
||
# Handle special URLs
|
||
if [[ "$backup_url" == *"admin-ajax.php"* ]]; then
|
||
echo "ℹ️ Backup Buddy URL found, transforming..."
|
||
backup_url=${backup_url/wp-admin\/admin-ajax.php?action=pb_backupbuddy_backupbuddy&function=download_archive&backupbuddy_backup=/wp-content\/uploads\/backupbuddy_backups/}
|
||
fi
|
||
if [[ "$backup_url" == *"dropbox.com"* && "$backup_url" != *"dl=1" ]]; then
|
||
echo "ℹ️ Dropbox URL found, adding dl=1..."
|
||
backup_url=${backup_url/&dl=0/&dl=1}
|
||
fi
|
||
|
||
# Download or use local file
|
||
if [ ! -f "${private_dir}/${local_file_name}" ]; then
|
||
echo "Downloading from $backup_url..."
|
||
wget -q --show-progress --no-check-certificate --progress=bar:force:noscroll -O "backup_file" "$backup_url"
|
||
if [ $? -ne 0 ]; then echo "❌ Error: Download failed."; cd "$home_directory"; return 1; fi
|
||
else
|
||
echo "ℹ️ Local file '${local_file_name}' found. Using it."
|
||
mv "${private_dir}/${local_file_name}" ./backup_file
|
||
fi
|
||
|
||
# Extract based on extension
|
||
echo "Extracting backup..."
|
||
if [[ "$backup_url" == *".zip"* || "$local_file_name" == *".zip"* ]]; then
|
||
unzip -q -o backup_file -x "__MACOSX/*" "cgi-bin/*"
|
||
elif [[ "$backup_url" == *".tar.gz"* || "$local_file_name" == *".tar.gz"* ]]; then
|
||
tar xzf backup_file
|
||
elif [[ "$backup_url" == *".tar"* || "$local_file_name" == *".tar"* ]]; then
|
||
tar xf backup_file
|
||
else # Assume zip if no extension matches
|
||
echo "ℹ️ No clear extension, assuming .zip format."
|
||
unzip -q -o backup_file -x "__MACOSX/*" "cgi-bin/*"
|
||
fi
|
||
rm -f backup_file
|
||
|
||
# --- Migrate Files ---
|
||
local wordpresspath; wordpresspath=$( find . -type d -name 'wp-content' -print -quit )
|
||
if [[ -z "$wordpresspath" ]]; then
|
||
echo "❌ Error: Can't find wp-content/ in backup. Migration cancelled."; cd "$home_directory"; return 1
|
||
fi
|
||
|
||
echo "Migrating files..."
|
||
# Migrate mu-plugins if found
|
||
if [ -d "$wordpresspath/wp-content/mu-plugins" ]; then
|
||
echo "Moving: mu-plugins"
|
||
cd "$wordpresspath/wp-content/mu-plugins"
|
||
for working in *; do
|
||
echo "$working"
|
||
if [ -f "$home_directory/wp-content/mu-plugins/$working" ]; then
|
||
rm "$home_directory/wp-content/mu-plugins/$working"
|
||
fi
|
||
if [ -d "$home_directory/wp-content/mu-plugins/$working" ]; then
|
||
rm -rf "$home_directory/wp-content/mu-plugins/$working"
|
||
fi
|
||
mv "$working" "$home_directory/wp-content/mu-plugins/"
|
||
done
|
||
cd "${private}/restore_${timedate}"
|
||
fi
|
||
|
||
# Migrate blogs.dir if found
|
||
if [ -d "$wordpresspath/blogs.dir" ]; then
|
||
echo "Moving: blogs.dir"
|
||
rm -rf "$home_directory/wp-content/blogs.dir"
|
||
mv "$wordpresspath/blogs.dir" "$home_directory/wp-content/"
|
||
fi
|
||
|
||
# Migrate gallery if found
|
||
if [ -d "$wordpresspath/gallery" ]; then
|
||
echo "Moving: gallery"
|
||
rm -rf "$home_directory/wp-content/gallery"
|
||
mv "$wordpresspath/gallery" "$home_directory/wp-content/"
|
||
fi
|
||
|
||
# Migrate ngg if found
|
||
if [ -d "$wordpresspath/ngg" ]; then
|
||
echo "Moving: ngg"
|
||
rm -rf "$home_directory/wp-content/ngg"
|
||
mv "$wordpresspath/ngg" "$home_directory/wp-content/"
|
||
fi
|
||
|
||
# Migrate uploads if found
|
||
if [ -d "$wordpresspath/uploads" ]; then
|
||
echo "Moving: uploads"
|
||
rm -rf "$home_directory/wp-content/uploads"
|
||
mv "$wordpresspath/uploads" "$home_directory/wp-content/"
|
||
fi
|
||
|
||
# Migrate themes if found
|
||
for d in $wordpresspath/themes/*/; do
|
||
echo "Moving: themes/$( basename "$d" )"
|
||
rm -rf "$home_directory/wp-content/themes/$( basename "$d" )"
|
||
mv "$d" "$home_directory/wp-content/themes/"
|
||
done
|
||
|
||
# Migrate plugins if found
|
||
for d in $wordpresspath/plugins/*/; do
|
||
echo "Moving: plugins/$( basename "$d" )"
|
||
rm -rf "$home_directory/wp-content/plugins/$( basename "$d" )"
|
||
mv "$d" "$home_directory/wp-content/plugins/"
|
||
done
|
||
|
||
# Find and move non-default root files
|
||
local backup_root_dir; backup_root_dir=$(dirname "$wordpresspath")
|
||
cd "$backup_root_dir" || return 1
|
||
local default_files=( index.php license.txt readme.html wp-activate.php wp-app.php wp-blog-header.php wp-comments-post.php wp-config-sample.php wp-cron.php wp-links-opml.php wp-load.php wp-login.php wp-mail.php wp-pass.php wp-register.php wp-settings.php wp-signup.php wp-trackback.php xmlrpc.php wp-admin wp-config.php wp-content wp-includes )
|
||
for item in *; do
|
||
is_default=false
|
||
for default in "${default_files[@]}"; do
|
||
if [[ "$item" == "$default" ]]; then is_default=true; break; fi
|
||
done
|
||
if ! $is_default; then
|
||
echo "Moving root item: $item"
|
||
mv -f "$item" "${home_directory}/"
|
||
fi
|
||
done
|
||
cd "$home_directory"
|
||
|
||
# --- Database Migration ---
|
||
local database
|
||
if [[ "$(uname)" == "Darwin" ]]; then
|
||
# macOS/BSD version using stat -f
|
||
database=$(find "$restore_dir" "$home_directory" -type f -name '*.sql' -print0 | xargs -0 stat -f '%m %N' | sort -n | tail -1 | cut -f2- -d" ")
|
||
else
|
||
# Linux version using find -printf
|
||
database=$(find "$restore_dir" "$home_directory" -type f -name '*.sql' -printf '%T@ %p\n' | sort -n | tail -1 | cut -d' ' -f2-)
|
||
fi
|
||
|
||
if [[ -z "$database" || ! -f "$database" ]]; then
|
||
echo "⚠️ Warning: No .sql file found in backup. Skipping database import.";
|
||
else
|
||
echo "Importing database from $database..."
|
||
local search_privacy; search_privacy=$( "$WP_CLI_CMD" option get blog_public --skip-plugins --skip-themes )
|
||
|
||
# Outputs table prefix and updates if different
|
||
cd "${restore_dir}/${wordpresspath}/../"
|
||
if [ -f wp-config.php ]; then
|
||
table_prefix=$( cat wp-config.php | grep table_prefix | perl -n -e '/\047(.+)\047/&& print $1' )
|
||
fi
|
||
|
||
cd "$home_directory"
|
||
current_table_prefix=$( wp config get table_prefix --skip-plugins --skip-themes )
|
||
if [[ $table_prefix != "" && $table_prefix != "$current_table_prefix" ]]; then
|
||
echo "Updating table prefix from $current_table_prefix to $table_prefix"
|
||
wp config set table_prefix $table_prefix --skip-plugins --skip-themes
|
||
fi
|
||
|
||
# Reset the database first
|
||
"$WP_CLI_CMD" db reset --yes --skip-plugins --skip-themes
|
||
|
||
# Import using WP-CLI
|
||
if ! "$WP_CLI_CMD" db import "$database"; then
|
||
echo " Error: Database import failed. Please check the error message above." >&2
|
||
cd "$home_directory"
|
||
return 1
|
||
fi
|
||
|
||
"$WP_CLI_CMD" cache flush --skip-plugins --skip-themes
|
||
"$WP_CLI_CMD" option update blog_public "$search_privacy" --skip-plugins --skip-themes
|
||
|
||
# URL updates
|
||
local wp_home_imported; wp_home_imported=$( "$WP_CLI_CMD" option get home --skip-plugins --skip-themes )
|
||
if [[ "$update_urls_flag" == "true" && "$wp_home_imported" != "$wp_home" ]]; then
|
||
echo "Updating URLs from $wp_home_imported to $wp_home..."
|
||
"$WP_CLI_CMD" search-replace "$wp_home_imported" "$wp_home" --all-tables --report-changed-only --skip-plugins --skip-themes
|
||
fi
|
||
fi
|
||
|
||
# --- Cleanup & Final Steps ---
|
||
echo "Performing cleanup and final optimizations..."
|
||
local plugins_to_remove=( backupbuddy wordfence w3-total-cache wp-super-cache ewww-image-optimizer )
|
||
for plugin in "${plugins_to_remove[@]}"; do
|
||
if "$WP_CLI_CMD" plugin is-installed "$plugin" --skip-plugins --skip-themes &>/dev/null; then
|
||
echo "Removing plugin: $plugin"
|
||
"$WP_CLI_CMD" plugin delete "$plugin" --skip-plugins --skip-themes
|
||
fi
|
||
done
|
||
|
||
# Convert tables to InnoDB
|
||
local alter_queries; alter_queries=$("$WP_CLI_CMD" db query "SELECT CONCAT('ALTER TABLE ', TABLE_SCHEMA,'.', TABLE_NAME, ' ENGINE=InnoDB;') FROM information_schema.TABLES WHERE ENGINE = 'MyISAM' AND TABLE_SCHEMA=DATABASE()" --skip-column-names --skip-plugins --skip-themes)
|
||
if [[ -n "$alter_queries" ]]; then
|
||
echo "Converting MyISAM tables to InnoDB..."
|
||
echo "$alter_queries" | "$WP_CLI_CMD" db query --skip-plugins --skip-themes
|
||
fi
|
||
|
||
"$WP_CLI_CMD" rewrite flush
|
||
if "$WP_CLI_CMD" plugin is-active woocommerce --skip-plugins --skip-themes &>/dev/null; then
|
||
"$WP_CLI_CMD" wc tool run regenerate_product_attributes_lookup_table --user=1 --skip-plugins --skip-themes
|
||
fi
|
||
|
||
find . -type d -exec chmod 755 {} \;
|
||
find . -type f -exec chmod 644 {} \;
|
||
|
||
# Clean up restore directory
|
||
rm -rf "$restore_dir"
|
||
|
||
echo "✅ Site migration complete!"
|
||
}
|
||
# ----------------------------------------------------
|
||
# Monitors server access logs in real-time.
|
||
# ----------------------------------------------------
|
||
function monitor_traffic() {
|
||
local limit_arg="$1"
|
||
local process_from_now="$2"
|
||
|
||
if ! setup_gum; then
|
||
echo "Aborting monitor: gum setup failed." >&2
|
||
return 1
|
||
fi
|
||
|
||
# --- Configuration ---
|
||
local limit=${limit_arg:-25}
|
||
local log="$HOME/logs/access.log"
|
||
local initial_lines_to_process=1 # How many lines to look back initially (only used with --now)
|
||
# --- End Configuration ---
|
||
|
||
if [ ! -f "$log" ]; then
|
||
echo "Error: Log file not found at $log" >&2
|
||
exit 1
|
||
fi
|
||
|
||
# --- Initial Setup ---
|
||
local start_line=1 # Default: start from the beginning
|
||
|
||
if [ "$process_from_now" = true ]; then
|
||
echo "Processing from near the end (--now specified)." >&2
|
||
local initial_log_count; initial_log_count=$(wc -l < "$log")
|
||
local calculated_start=$((initial_log_count - initial_lines_to_process + 1))
|
||
|
||
if [ $calculated_start -gt 1 ]; then
|
||
start_line=$calculated_start
|
||
else
|
||
start_line=1
|
||
fi
|
||
else
|
||
echo "Processing from the beginning of the log (line 1)." >&2
|
||
fi
|
||
|
||
echo "Starting analysis from line: $start_line | Top hits limit: $limit" >&2
|
||
# --- End Initial Setup ---
|
||
|
||
trap "echo; echo 'Monitoring stopped.'; exit 0" INT
|
||
sleep 2 # Give user time to read initial messages
|
||
|
||
while true; do
|
||
local current_log_count; current_log_count=$(wc -l < "$log")
|
||
|
||
if [ "$current_log_count" -lt "$start_line" ]; then
|
||
echo "Warning: Log file appears to have shrunk or rotated. Resetting start line to 1." >&2
|
||
start_line=1
|
||
sleep 1
|
||
current_log_count=$(wc -l < "$log")
|
||
if [ "$current_log_count" -lt 1 ]; then
|
||
echo "Log file is empty or unreadable after reset. Waiting..." >&2
|
||
sleep 5
|
||
continue
|
||
fi
|
||
fi
|
||
|
||
local actual_lines_processed=$((current_log_count - start_line + 1))
|
||
if [ $actual_lines_processed -lt 0 ]; then
|
||
actual_lines_processed=0
|
||
fi
|
||
|
||
local overview_header="PHP Workers,Log File,Processed,From Time,To Time\n"
|
||
local overview_data=""
|
||
local php_workers; php_workers=$(ps -eo pid,uname,comm,%cpu,%mem,time --sort=time --no-headers | grep '[p]hp-fpm' | grep -v 'root' | wc -l)
|
||
|
||
local first_line_time; first_line_time=$(sed -n "${start_line}p" "$log" | awk -F'[][]' '{print $2}' | head -n 1)
|
||
[ -z "$first_line_time" ] && first_line_time="N/A"
|
||
|
||
local last_line_time; last_line_time=$(tail -n 1 "$log" | awk -F'[][]' '{print $2}' | head -n 1)
|
||
[ -z "$last_line_time" ] && last_line_time="N/A"
|
||
|
||
overview_data+="$php_workers,$log,$actual_lines_processed,$first_line_time,$last_line_time\n"
|
||
local output_header="Hits,IP Address,Status Code,Last User Agent\n"
|
||
local output_data=""
|
||
|
||
local top_combinations; top_combinations=$(timeout 10s sed -n "$start_line,\$p" "$log" | \
|
||
awk '{print $2 " " $8}' | \
|
||
sort | \
|
||
uniq -c | \
|
||
sort -nr | \
|
||
head -n "$limit")
|
||
|
||
if [ -z "$top_combinations" ]; then
|
||
output_data+="0,No new data,-,\"N/A\"\n"
|
||
else
|
||
while IFS= read -r line; do
|
||
line=$(echo "$line" | sed 's/^[ \t]*//;s/[ \t]*$//')
|
||
local count ip status_code
|
||
read -r count ip status_code <<< "$line"
|
||
|
||
if ! [[ "$count" =~ ^[0-9]+$ ]] || [[ -z "$ip" ]] || ! [[ "$status_code" =~ ^[0-9]+$ ]]; then
|
||
continue
|
||
fi
|
||
|
||
local ip_user_agent; ip_user_agent=$(timeout 2s sed -n "$start_line,\$p" "$log" | grep " $ip " | tail -n 1 | awk -F\" '{print $6}' | cut -c 1-100)
|
||
ip_user_agent=${ip_user_agent//,/}
|
||
ip_user_agent=${ip_user_agent//\"/}
|
||
|
||
[ -z "$ip_user_agent" ] && ip_user_agent="-"
|
||
|
||
output_data+="$count,$ip,$status_code,\"$ip_user_agent\"\n"
|
||
done < <(echo -e "$top_combinations")
|
||
fi
|
||
|
||
clear
|
||
echo "--- Overview (Lines $start_line - $current_log_count | Total: $actual_lines_processed) ---"
|
||
echo -e "$overview_header$overview_data" | "$GUM_CMD" table --print
|
||
echo
|
||
echo "--- Top $limit IP/Status Hits (Lines $start_line - $current_log_count) ---"
|
||
echo -e "$output_header$output_data" | "$GUM_CMD" table --print
|
||
|
||
sleep 2
|
||
done
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Monitors access and error logs for HTTP 500 and PHP fatal errors.
|
||
# ----------------------------------------------------
|
||
function monitor_errors() {
|
||
if ! setup_gum; then
|
||
echo "Aborting monitor: gum setup failed." >&2
|
||
return 1
|
||
fi
|
||
|
||
# --- Find Log Files ---
|
||
local access_log_path=""
|
||
if [ -f "$HOME/logs/access.log" ]; then
|
||
access_log_path="$HOME/logs/access.log"
|
||
elif [ -f "logs/access.log" ]; then
|
||
access_log_path="logs/access.log"
|
||
elif [ -f "../logs/access.log" ]; then
|
||
access_log_path="../logs/access.log"
|
||
fi
|
||
|
||
local error_log_path=""
|
||
if [ -f "$HOME/logs/error.log" ]; then
|
||
error_log_path="$HOME/logs/error.log"
|
||
elif [ -f "logs/error.log" ]; then
|
||
error_log_path="logs/error.log"
|
||
elif [ -f "../logs/error.log" ]; then
|
||
error_log_path="../logs/error.log"
|
||
fi
|
||
|
||
local files_to_monitor=()
|
||
if [ -n "$access_log_path" ]; then
|
||
echo "Checking for 500 errors in: $access_log_path" >&2
|
||
files_to_monitor+=("$access_log_path")
|
||
fi
|
||
if [ -n "$error_log_path" ]; then
|
||
echo "Checking for Fatal errors in: $error_log_path" >&2
|
||
files_to_monitor+=("$error_log_path")
|
||
fi
|
||
|
||
if [ ${#files_to_monitor[@]} -eq 0 ]; then
|
||
echo "No log files found in standard locations (~/logs/, logs/, ../logs/)" >&2
|
||
return 1
|
||
fi
|
||
|
||
echo "Streaming errors from specified logs..." >&2
|
||
echo "(Press Ctrl+C to stop)" >&2
|
||
|
||
# --- Real-time Stream using `tail -F` ---
|
||
tail -q -n 0 -F "${files_to_monitor[@]}" | while read -r line; do
|
||
# Skip empty lines that might come from the pipe
|
||
if [ -z "$line" ]; then
|
||
continue
|
||
fi
|
||
|
||
# Check for the most specific term first ("Fatal") before less specific terms.
|
||
if [[ "$line" == *"Fatal"* ]]; then
|
||
"$GUM_CMD" log --level error "$line"
|
||
elif [[ "$line" == *" 500 "* ]]; then
|
||
"$GUM_CMD" log --level error "$line"
|
||
fi
|
||
done
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Tails the access log for a clean, real-time view.
|
||
# ----------------------------------------------------
|
||
function monitor_access_log() {
|
||
if ! setup_gum; then
|
||
echo "Aborting monitor: gum setup failed." >&2
|
||
return 1
|
||
fi
|
||
|
||
# --- Find Log File ---
|
||
local access_log_path=""
|
||
if [ -f "$HOME/logs/access.log" ]; then
|
||
access_log_path="$HOME/logs/access.log"
|
||
elif [ -f "logs/access.log" ]; then
|
||
access_log_path="logs/access.log"
|
||
elif [ -f "../logs/access.log" ]; then
|
||
access_log_path="../logs/access.log"
|
||
fi
|
||
|
||
if [ -z "$access_log_path" ]; then
|
||
echo "No access.log file found in standard locations (~/logs/, logs/, ../logs/)" >&2
|
||
return 1
|
||
fi
|
||
|
||
echo "Streaming log: $access_log_path" >&2
|
||
echo "(Press Ctrl+C to stop)" >&2
|
||
|
||
# --- Real-time Stream using `tail -F` ---
|
||
tail -n 50 -F "$access_log_path" | while read -r line; do
|
||
# Skip empty lines
|
||
if [ -z "$line" ]; then
|
||
continue
|
||
fi
|
||
"$GUM_CMD" log --level info "$line"
|
||
done
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Tails the error log for a clean, real-time view.
|
||
# ----------------------------------------------------
|
||
function monitor_error_log() {
|
||
if ! setup_gum; then
|
||
echo "Aborting monitor: gum setup failed." >&2
|
||
return 1
|
||
fi
|
||
|
||
# --- Find Log File ---
|
||
local error_log_path=""
|
||
if [ -f "$HOME/logs/error.log" ]; then
|
||
error_log_path="$HOME/logs/error.log"
|
||
elif [ -f "logs/error.log" ]; then
|
||
error_log_path="logs/error.log"
|
||
elif [ -f "../logs/error.log" ]; then
|
||
error_log_path="../logs/error.log"
|
||
fi
|
||
|
||
if [ -z "$error_log_path" ]; then
|
||
echo "No error.log file found in standard locations (~/logs/, logs/, ../logs/)" >&2
|
||
return 1
|
||
fi
|
||
|
||
echo "Streaming log: $error_log_path" >&2
|
||
echo "(Press Ctrl+C to stop)" >&2
|
||
|
||
# --- Real-time Stream using `tail -F` ---
|
||
tail -n 50 -F "$error_log_path" | while read -r line; do
|
||
# Skip empty lines
|
||
if [ -z "$line" ]; then
|
||
continue
|
||
fi
|
||
"$GUM_CMD" log --level error "$line"
|
||
done
|
||
}
|
||
# ----------------------------------------------------
|
||
# Reset Commands
|
||
# Handles resetting WordPress components or permissions.
|
||
# ----------------------------------------------------
|
||
|
||
# ----------------------------------------------------
|
||
# Resets the WordPress installation to a clean, default state.
|
||
# ----------------------------------------------------
|
||
function reset_wp() {
|
||
# This function now only accepts an optional email flag.
|
||
# The admin user is selected interactively.
|
||
local admin_email="$1"
|
||
|
||
# --- Pre-flight Checks ---
|
||
if ! setup_wp_cli; then echo "❌ Error: WP-CLI not found." >&2; return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then echo "❌ Error: This does not appear to be a WordPress installation." >&2; return 1; fi
|
||
if ! command -v wget &>/dev/null; then echo "❌ Error: wget not found." >&2; return 1; fi
|
||
if ! command -v unzip &>/dev/null; then echo "❌ Error: unzip not found." >&2; return 1; fi
|
||
if ! command -v curl &>/dev/null; then echo "❌ Error: curl not found." >&2; return 1; fi
|
||
if ! setup_gum; then echo "❌ Error: gum is required for the interactive admin picker." >&2; return 1; fi
|
||
|
||
echo "🚀 Starting WordPress Site Reset 🚀"
|
||
|
||
# --- Interactively Select Admin User ---
|
||
echo "Fetching list of administrators..."
|
||
local admin_users
|
||
admin_users=$("$WP_CLI_CMD" user list --role=administrator --field=user_login --format=csv)
|
||
|
||
if [ -z "$admin_users" ]; then
|
||
echo "❌ Error: No administrator users found to assign to the new installation." >&2
|
||
return 1
|
||
fi
|
||
|
||
local admin_user
|
||
admin_user=$(echo "$admin_users" | "$GUM_CMD" choose --header "Select an administrator for the new installation")
|
||
|
||
if [ -z "$admin_user" ]; then
|
||
echo "No administrator selected. Aborting reset."
|
||
return 0
|
||
fi
|
||
echo "✅ Selected administrator: $admin_user"
|
||
# --- End Select Admin User ---
|
||
|
||
echo "This is a destructive operation."
|
||
# A 3-second countdown to allow the user to abort (Ctrl+C)
|
||
for i in {3..1}; do echo -n "Continuing in $i... "; sleep 1; done; echo
|
||
|
||
# --- Gather Info Before Reset ---
|
||
local url; url=$( "$WP_CLI_CMD" option get home --skip-plugins --skip-themes )
|
||
local title; title=$( "$WP_CLI_CMD" option get blogname --skip-plugins --skip-themes )
|
||
|
||
# If admin_email flag is not supplied, get it from the selected user.
|
||
if [ -z "$admin_email" ]; then
|
||
admin_email=$("$WP_CLI_CMD" user get "$admin_user" --field=user_email --format=csv)
|
||
echo "ℹ️ Admin email not provided. Using email from selected user '$admin_user': $admin_email"
|
||
fi
|
||
|
||
# --- Perform Reset ---
|
||
echo "Step 1/9: Resetting the database..."
|
||
"$WP_CLI_CMD" db reset --yes --skip-plugins --skip-themes
|
||
|
||
echo "Step 2/9: Downloading latest WordPress core..."
|
||
"$WP_CLI_CMD" core download --force --skip-plugins --skip-themes
|
||
|
||
echo "Step 3/9: Installing WordPress core..."
|
||
"$WP_CLI_CMD" core install --url="$url" --title="$title" --admin_user="$admin_user" --admin_email="$admin_email" --skip-plugins --skip-themes
|
||
|
||
echo "Step 4/9: Deleting all other themes..."
|
||
"$WP_CLI_CMD" theme delete --all --force --skip-plugins --skip-themes
|
||
|
||
echo "Step 5/9: Deleting all plugins..."
|
||
"$WP_CLI_CMD" plugin delete --all --skip-plugins --skip-themes
|
||
|
||
echo "Step 6/9: Finding the latest default WordPress theme..."
|
||
latest_default_theme=$("$WP_CLI_CMD" theme search twenty --field=slug --per-page=1 --quiet --skip-plugins --skip-themes)
|
||
|
||
if [ $? -ne 0 ] || [ -z "$latest_default_theme" ]; then
|
||
echo "❌ Error: Could not determine the latest default theme. Aborting reset."
|
||
return 1
|
||
fi
|
||
echo "✅ Latest default theme is '$latest_default_theme'."
|
||
echo "Step 7/9: Installing and activating '$latest_default_theme'..."
|
||
"$WP_CLI_CMD" theme install "$latest_default_theme" --force --activate --skip-plugins --skip-themes
|
||
|
||
echo "Step 8/9: Cleaning up directories (mu-plugins, uploads)..."
|
||
rm -rf wp-content/mu-plugins/
|
||
mkdir -p wp-content/mu-plugins/
|
||
rm -rf wp-content/uploads/
|
||
mkdir -p wp-content/uploads/
|
||
|
||
echo "Step 9/9: Installing helper plugins (Kinsta MU, CaptainCore Helper)..."
|
||
# The install_kinsta_mu function will automatically check if it's a Kinsta env.
|
||
install_kinsta_mu
|
||
install_helper
|
||
|
||
echo ""
|
||
echo "✅ WordPress reset complete!"
|
||
echo " URL: $url"
|
||
echo " Admin User: $admin_user"
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Resets file and folder permissions to common defaults (755 for dirs, 644 for files).
|
||
# ----------------------------------------------------
|
||
function reset_permissions() {
|
||
echo "Resetting file and folder permissions to defaults"
|
||
find . -type d -exec chmod 755 {} \;
|
||
find . -type f -exec chmod 644 {} \;
|
||
echo "✅ Permissions have been reset."
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Deactivates a suspend message by removing the mu-plugin.
|
||
# ----------------------------------------------------
|
||
function suspend_deactivate() {
|
||
local wp_content="$1"
|
||
|
||
# Set default wp-content if not provided
|
||
if [[ -z "$wp_content" ]]; then
|
||
wp_content="wp-content"
|
||
fi
|
||
|
||
local suspend_file="${wp_content}/mu-plugins/do-suspend.php"
|
||
|
||
if [ -f "$suspend_file" ]; then
|
||
echo "Deactivating suspend message by removing ${suspend_file}..."
|
||
rm "$suspend_file"
|
||
echo "✅ Suspend message deactivated. Site is now live."
|
||
else
|
||
echo "Site appears to be already live (suspend file not found)."
|
||
fi
|
||
|
||
# Clear Kinsta cache if environment is detected
|
||
if [ -f "/etc/update-motd.d/00-kinsta-welcome" ]; then
|
||
if setup_wp_cli && "$WP_CLI_CMD" kinsta cache purge --all --skip-themes &> /dev/null; then
|
||
echo "Kinsta cache purged."
|
||
else
|
||
echo "Warning: Could not purge Kinsta cache. Is the 'wp kinsta' command available?" >&2
|
||
fi
|
||
fi
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Activates a suspend message by adding an mu-plugin.
|
||
# ----------------------------------------------------
|
||
function suspend_activate() {
|
||
local name="$1"
|
||
local link="$2"
|
||
local wp_content="$3"
|
||
|
||
# Set default wp-content if not provided
|
||
if [[ -z "$wp_content" ]]; then
|
||
wp_content="wp-content"
|
||
fi
|
||
|
||
# Check for required arguments
|
||
if [[ -z "$name" || -z "$link" ]]; then
|
||
echo "Error: Missing required flags for 'suspend activate'." >&2
|
||
show_command_help "suspend"
|
||
return 1
|
||
fi
|
||
|
||
if [ ! -d "${wp_content}/mu-plugins" ]; then
|
||
echo "Creating directory: ${wp_content}/mu-plugins"
|
||
mkdir -p "${wp_content}/mu-plugins"
|
||
fi
|
||
|
||
# Remove existing deactivation file if present
|
||
if [ -f "${wp_content}/mu-plugins/do-suspend.php" ]; then
|
||
echo "Removing existing suspend file..."
|
||
rm "${wp_content}/mu-plugins/do-suspend.php"
|
||
fi
|
||
|
||
# Create the deactivation mu-plugin
|
||
local output_file="${wp_content}/mu-plugins/do-suspend.php"
|
||
echo "Generating suspend file at ${output_file}..."
|
||
cat <<EOF > "$output_file"
|
||
<?php
|
||
/**
|
||
* Plugin Name: Website Suspended
|
||
* Description: Deactivates the front-end of the website.
|
||
*/
|
||
function captaincore_template_redirect() {
|
||
// Return if in WP Admin or CLI
|
||
if ( is_admin() || ( defined( 'WP_CLI' ) && WP_CLI ) ) {
|
||
return;
|
||
}
|
||
?>
|
||
<html>
|
||
<head>
|
||
<meta charset="utf-8">
|
||
<title>Website Suspended</title>
|
||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||
<link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
|
||
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/materialize/1.0.0/css/materialize.min.css">
|
||
<script src="https://cdnjs.cloudflare.com/ajax/libs/materialize/1.0.0/js/materialize.min.js"></script>
|
||
<style>
|
||
@import url('https://fonts.googleapis.com/css?family=Roboto');
|
||
body {
|
||
text-align: center;
|
||
margin: 10% auto;
|
||
padding: 0 15px;
|
||
font-family: 'Roboto', sans-serif;
|
||
overflow: hidden;
|
||
display: block;
|
||
max-width: 550px;
|
||
background: #eeeeee;
|
||
}
|
||
p {
|
||
margin-top: 3%;
|
||
line-height: 1.4em;
|
||
display: block;
|
||
}
|
||
img {
|
||
margin-top: 1%;
|
||
}
|
||
a {
|
||
color:#27c3f3;
|
||
}
|
||
</style>
|
||
</head>
|
||
<body>
|
||
<div class="row">
|
||
<div class="col s12">
|
||
<div class="card">
|
||
<div class="card-content">
|
||
<span class="card-title">Website Suspended</span>
|
||
<p>This website is currently unavailable.</p>
|
||
</div>
|
||
<div class="card-content grey lighten-4">
|
||
<p>Site owners may contact <a href="${link}" target="_blank" rel="noopener noreferrer">${name}</a>.</p>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
</body>
|
||
</html>
|
||
<?php
|
||
// Stop WordPress from loading further
|
||
die();
|
||
}
|
||
add_action( 'template_redirect', 'captaincore_template_redirect', 1 );
|
||
EOF
|
||
|
||
echo "✅ Generated ${output_file}"
|
||
|
||
# Clear Kinsta cache if environment is detected
|
||
if [ -f "/etc/update-motd.d/00-kinsta-welcome" ]; then
|
||
if setup_wp_cli && "$WP_CLI_CMD" kinsta cache purge --all --skip-themes &> /dev/null; then
|
||
echo "Kinsta cache purged."
|
||
else
|
||
echo "Warning: Could not purge Kinsta cache. Is the 'wp kinsta' command available?" >&2
|
||
fi
|
||
fi
|
||
}
|
||
# ----------------------------------------------------
|
||
# Update Commands
|
||
# Handles WordPress core, theme, and plugin updates.
|
||
# ----------------------------------------------------
|
||
|
||
UPDATE_LOGS_DIR=""
|
||
UPDATE_LOGS_LIST_FILE=""
|
||
|
||
# ----------------------------------------------------
|
||
# Ensures update directories and lists exist.
|
||
# ----------------------------------------------------
|
||
function _ensure_update_setup() {
|
||
# Exit if already initialized
|
||
if [[ -n "$UPDATE_LOGS_DIR" ]]; then return 0; fi
|
||
|
||
local private_dir
|
||
if ! private_dir=$(_get_private_dir); then
|
||
return 1
|
||
fi
|
||
|
||
# Using the checkpoint base for consistency as updates are linked to checkpoints
|
||
local checkpoint_base_dir="${private_dir}/checkpoints"
|
||
UPDATE_LOGS_DIR="${checkpoint_base_dir}/updates"
|
||
UPDATE_LOGS_LIST_FILE="$UPDATE_LOGS_DIR/list.json"
|
||
|
||
mkdir -p "$UPDATE_LOGS_DIR"
|
||
if [ ! -f "$UPDATE_LOGS_LIST_FILE" ]; then
|
||
echo "[]" > "$UPDATE_LOGS_LIST_FILE"
|
||
fi
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# (Helper) Lets the user select an update log from the list.
|
||
# ----------------------------------------------------
|
||
function _select_update_log() {
|
||
_ensure_update_setup
|
||
if ! setup_wp_cli; then return 1; fi
|
||
|
||
if [ ! -s "$UPDATE_LOGS_LIST_FILE" ]; then
|
||
echo "ℹ️ No update logs found. Run '_do update all' to create one." >&2
|
||
return 1
|
||
fi
|
||
|
||
# Use PHP to read the detailed list and check format
|
||
local php_script_read_list='
|
||
<?php
|
||
$list_file = "%s";
|
||
$list = json_decode(file_get_contents($list_file), true);
|
||
|
||
if (!is_array($list) || empty($list)) {
|
||
echo "EMPTY";
|
||
return;
|
||
}
|
||
|
||
// Check if the first item has the new detailed format.
|
||
if (!isset($list[0]["formatted_timestamp"])) {
|
||
echo "NEEDS_GENERATE";
|
||
return;
|
||
}
|
||
|
||
foreach($list as $item) {
|
||
if (isset($item["formatted_timestamp"]) && isset($item["hash_before"]) && isset($item["hash_after"]) && isset($item["counts_str"]) && isset($item["diff_stats"])) {
|
||
// Output format: formatted_timestamp|hash_before|hash_after|counts_str|diff_stats
|
||
echo $item["formatted_timestamp"] . "|" . $item["hash_before"] . "|" . $item["hash_after"] . "|" . $item["counts_str"] . "|" . $item["diff_stats"] . "\n";
|
||
}
|
||
}
|
||
'
|
||
local php_script; php_script=$(printf "$php_script_read_list" "$UPDATE_LOGS_LIST_FILE")
|
||
local update_entries; update_entries=$(echo "$php_script" | "$WP_CLI_CMD" eval-file -)
|
||
|
||
if [[ "$update_entries" == "EMPTY" ]]; then
|
||
echo "ℹ️ No update logs available to select." >&2; return 1;
|
||
elif [[ "$update_entries" == "NEEDS_GENERATE" ]]; then
|
||
echo "⚠️ The update log list needs to be generated for faster display." >&2
|
||
echo "Please run: _do update list-generate" >&2
|
||
return 1
|
||
fi
|
||
|
||
local display_items=()
|
||
local data_items=()
|
||
|
||
while IFS='|' read -r formatted_timestamp hash_before hash_after counts_str diff_stats; do
|
||
hash_before=$(echo "$hash_before" | tr -d '[:space:]')
|
||
hash_after=$(echo "$hash_after" | tr -d '[:space:]')
|
||
if [ -z "$hash_before" ] || [ -z "$hash_after" ]; then continue; fi
|
||
|
||
local display_string
|
||
display_string=$(printf "%-28s | %s -> %s | %-18s | %s" \
|
||
"$formatted_timestamp" "${hash_before:0:7}" "${hash_after:0:7}" "$counts_str" "$diff_stats")
|
||
|
||
display_items+=("$display_string")
|
||
data_items+=("$hash_before|$hash_after")
|
||
done <<< "$update_entries"
|
||
|
||
if [ ${#display_items[@]} -eq 0 ]; then
|
||
echo "❌ No valid update entries to display." >&2
|
||
return 1
|
||
fi
|
||
|
||
local prompt_text="${1:-Select an update to inspect}"
|
||
local selected_display
|
||
selected_display=$(printf "%s\n" "${display_items[@]}" | "$GUM_CMD" filter --height=20 --prompt="👇 $prompt_text" --indicator="→" --placeholder="")
|
||
|
||
if [ -z "$selected_display" ]; then
|
||
echo "" # Return empty for cancellation
|
||
return 0
|
||
fi
|
||
|
||
local selected_index=-1
|
||
for i in "${!display_items[@]}"; do
|
||
if [[ "${display_items[$i]}" == "$selected_display" ]]; then
|
||
selected_index=$i
|
||
break
|
||
fi
|
||
done
|
||
|
||
if [ "$selected_index" -ne -1 ]; then
|
||
echo "${data_items[$selected_index]}"
|
||
return 0
|
||
else
|
||
echo "❌ Error: Could not find selected update." >&2
|
||
return 1
|
||
fi
|
||
}
|
||
|
||
|
||
# ----------------------------------------------------
|
||
# Generates a detailed list of updates for faster access.
|
||
# ----------------------------------------------------
|
||
function update_list_generate() {
|
||
if ! setup_gum || ! setup_git; then return 1; fi
|
||
if ! setup_wp_cli; then return 1; fi
|
||
_ensure_checkpoint_setup # This sets up repo path as well
|
||
_ensure_update_setup
|
||
|
||
local php_script_read_list='
|
||
<?php
|
||
$list_file = "%s";
|
||
if (!file_exists($list_file)) { return; }
|
||
$list = json_decode(file_get_contents($list_file), true);
|
||
if (!is_array($list) || empty($list)) { return; }
|
||
foreach($list as $item) {
|
||
// Read from both simple and potentially detailed formats
|
||
$timestamp = $item["timestamp"] ?? "N/A";
|
||
$hash_before = $item["before"] ?? $item["hash_before"] ?? null;
|
||
$hash_after = $item["after"] ?? $item["hash_after"] ?? null;
|
||
|
||
if ($timestamp && $hash_before && $hash_after) {
|
||
echo "$timestamp|$hash_before|$hash_after\n";
|
||
}
|
||
}
|
||
'
|
||
local php_script; php_script=$(printf "$php_script_read_list" "$UPDATE_LOGS_LIST_FILE")
|
||
local update_entries; update_entries=$(echo "$php_script" | "$WP_CLI_CMD" eval-file -)
|
||
|
||
if [ -z "$update_entries" ]; then
|
||
echo "ℹ️ No update logs found to generate a list from."
|
||
return 0
|
||
fi
|
||
|
||
echo "🔎 Generating detailed update list... (This may take a moment)"
|
||
local detailed_items=()
|
||
|
||
while IFS='|' read -r timestamp hash_before hash_after; do
|
||
hash_before=$(echo "$hash_before" | tr -d '[:space:]')
|
||
hash_after=$(echo "$hash_after" | tr -d '[:space:]')
|
||
if [ -z "$hash_before" ] || [ -z "$hash_after" ]; then continue; fi
|
||
|
||
# Validate that both commits exist before proceeding
|
||
if ! "$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" cat-file -e "${hash_before}^{commit}" &>/dev/null; then
|
||
echo "⚠️ Warning: Could not find 'before' commit '$hash_before'. Skipping entry." >&2
|
||
continue
|
||
fi
|
||
if ! "$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" cat-file -e "${hash_after}^{commit}" &>/dev/null; then
|
||
echo "⚠️ Warning: Could not find 'after' commit '$hash_after'. Skipping entry." >&2
|
||
continue
|
||
fi
|
||
|
||
local manifest_after; manifest_after=$("$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" show "$hash_after:manifest.json" 2>/dev/null)
|
||
if [ -z "$manifest_after" ]; then
|
||
echo "⚠️ Warning: Could not find manifest for 'after' hash '$hash_after'. Skipping entry." >&2
|
||
continue
|
||
fi
|
||
|
||
local php_get_counts='
|
||
<?php
|
||
$manifest_json = <<<'EOT'
|
||
%s
|
||
EOT;
|
||
$data = json_decode($manifest_json, true);
|
||
$theme_count = isset($data["themes"]) && is_array($data["themes"]) ? count($data["themes"]) : 0;
|
||
$plugin_count = isset($data["plugins"]) && is_array($data["plugins"]) ? count($data["plugins"]) : 0;
|
||
echo "$theme_count Themes, $plugin_count Plugins";
|
||
'
|
||
local counts_script; counts_script=$(printf "$php_get_counts" "$manifest_after")
|
||
local counts_str; counts_str=$(echo "$counts_script" | "$WP_CLI_CMD" eval-file -)
|
||
|
||
local diff_stats
|
||
diff_stats=$("$GIT_CMD" -C "$CHECKPOINT_REPO_DIR" diff --shortstat "$hash_before" "$hash_after" -- 'plugins/' 'themes/' 'mu-plugins/' | sed 's/^[ \t]*//')
|
||
if [ -z "$diff_stats" ]; then diff_stats="No file changes"; fi
|
||
|
||
local formatted_timestamp
|
||
if [[ "$(uname)" == "Darwin" ]]; then
|
||
formatted_timestamp=$(date -j -f "%Y-%m-%dT%H:%M:%SZ" -u "$timestamp" "+%a, %b %d, %Y, %-I:%M %p")
|
||
else
|
||
formatted_timestamp=$(date -d "$timestamp" "+%a, %b %d, %Y, %-I:%M %p")
|
||
fi
|
||
|
||
local json_item
|
||
json_item=$(printf '{"hash_before": "%s", "hash_after": "%s", "timestamp": "%s", "formatted_timestamp": "%s", "counts_str": "%s", "diff_stats": "%s"}' \
|
||
"$hash_before" "$hash_after" "$timestamp" "$formatted_timestamp" "$counts_str" "$diff_stats")
|
||
|
||
detailed_items+=("$json_item")
|
||
|
||
done <<< "$update_entries"
|
||
|
||
local full_json="["
|
||
full_json+=$(IFS=,; echo "${detailed_items[*]}")
|
||
full_json+="]"
|
||
|
||
local php_write_script='
|
||
<?php
|
||
$list_file = "%s";
|
||
$json_data = <<<'EOT'
|
||
%s
|
||
EOT;
|
||
$data = json_decode($json_data, true);
|
||
file_put_contents($list_file, json_encode($data, JSON_PRETTY_PRINT));
|
||
'
|
||
local write_script; write_script=$(printf "$php_write_script" "$UPDATE_LOGS_LIST_FILE" "$full_json")
|
||
if echo "$write_script" | "$WP_CLI_CMD" eval-file -; then
|
||
echo "✅ Detailed update list saved to $UPDATE_LOGS_LIST_FILE"
|
||
else
|
||
echo "❌ Error: Failed to write detailed update list."
|
||
fi
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Lists all past updates from the pre-generated list.
|
||
# ----------------------------------------------------
|
||
function update_list() {
|
||
if ! setup_gum || ! setup_git; then return 1; fi
|
||
if ! setup_wp_cli; then return 1; fi
|
||
_ensure_checkpoint_setup # Ensures repo path is set
|
||
|
||
local selected_hashes
|
||
selected_hashes=$(_select_update_log "Select an update to inspect")
|
||
|
||
if [ -z "$selected_hashes" ]; then
|
||
echo "No update selected."
|
||
return 0
|
||
fi
|
||
if [ $? -ne 0 ]; then
|
||
return 1 # Error already printed by helper
|
||
fi
|
||
|
||
local selected_hash_before; selected_hash_before=$(echo "$selected_hashes" | cut -d'|' -f1)
|
||
local selected_hash_after; selected_hash_after=$(echo "$selected_hashes" | cut -d'|' -f2)
|
||
|
||
checkpoint_show "$selected_hash_after" "$selected_hash_before"
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Runs the full update process.
|
||
# ----------------------------------------------------
|
||
function run_update_all() {
|
||
if ! setup_git; then return 1; fi
|
||
if ! command -v wp &>/dev/null; then echo "❌ Error: WP-CLI not found." >&2; return 1; fi
|
||
|
||
_ensure_checkpoint_setup
|
||
_ensure_update_setup
|
||
|
||
echo "🚀 Starting full WordPress update process..."
|
||
|
||
echo " - Step 1/5: Creating 'before' checkpoint..."
|
||
checkpoint_create > /dev/null
|
||
local hash_before; hash_before=$(checkpoint_latest)
|
||
if [ -z "$hash_before" ]; then
|
||
echo "❌ Error: Could not create 'before' checkpoint." >&2
|
||
return 1
|
||
fi
|
||
echo " Before Hash: $hash_before"
|
||
|
||
echo " - Step 2/5: Running WordPress updates..."
|
||
echo " - Updating core..."
|
||
"$WP_CLI_CMD" core update --skip-plugins --skip-themes
|
||
echo " - Updating themes..."
|
||
"$WP_CLI_CMD" theme update --all --skip-plugins --skip-themes
|
||
echo " - Updating plugins..."
|
||
"$WP_CLI_CMD" plugin update --all --skip-plugins --skip-themes
|
||
|
||
echo " - Step 3/5: Creating 'after' checkpoint..."
|
||
checkpoint_create > /dev/null
|
||
local hash_after; hash_after=$(checkpoint_latest)
|
||
if [ -z "$hash_after" ]; then
|
||
echo "❌ Error: Could not create 'after' checkpoint." >&2
|
||
return 1
|
||
fi
|
||
echo " After Hash: $hash_after"
|
||
|
||
if [ "$hash_before" == "$hash_after" ]; then
|
||
echo "✅ No updates were available. Site is up-to-date."
|
||
return 0
|
||
fi
|
||
|
||
echo " - Step 4/5: Generating update log entry..."
|
||
local timestamp; timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
|
||
|
||
# This creates a simple entry. `update list-generate` will enrich it later.
|
||
local php_list_template='
|
||
<?php
|
||
$list_file = "%s";
|
||
$before = "%s";
|
||
$after = "%s";
|
||
$timestamp = "%s";
|
||
$list = file_exists($list_file) ? json_decode(file_get_contents($list_file), true) : [];
|
||
if (!is_array($list)) { $list = []; }
|
||
$new_entry = ["before" => $before, "after" => $after, "timestamp" => $timestamp];
|
||
// To keep it simple, we just read the simple format and add to it.
|
||
// The list-generate command is responsible for creating the detailed format.
|
||
$simple_list = [];
|
||
foreach($list as $item) {
|
||
$simple_list[] = [
|
||
"before" => $item["before"] ?? $item["hash_before"] ?? null,
|
||
"after" => $item["after"] ?? $item["hash_after"] ?? null,
|
||
"timestamp" => $item["timestamp"] ?? null
|
||
];
|
||
}
|
||
array_unshift($simple_list, $new_entry);
|
||
echo json_encode($simple_list, JSON_PRETTY_PRINT);
|
||
'
|
||
local php_list_script; php_list_script=$(printf "$php_list_template" "$UPDATE_LOGS_LIST_FILE" "$hash_before" "$hash_after" "$timestamp")
|
||
|
||
local temp_list_file; temp_list_file=$(mktemp)
|
||
if echo "$php_list_script" | "$WP_CLI_CMD" eval-file - > "$temp_list_file"; then
|
||
mv "$temp_list_file" "$UPDATE_LOGS_LIST_FILE"
|
||
else
|
||
echo "❌ Error: Failed to update master update list." >&2
|
||
rm "$temp_list_file"
|
||
fi
|
||
|
||
echo " - Step 5/5: Regenerating detailed update list..."
|
||
update_list_generate > /dev/null
|
||
|
||
echo "✅ Update process complete."
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Upgrades the _do script to the latest version.
|
||
# ----------------------------------------------------
|
||
function run_upgrade() {
|
||
echo "🚀 Checking for the latest version of _do..."
|
||
|
||
# --- Pre-flight Checks ---
|
||
if ! command -v curl &> /dev/null; then echo "❌ Error: curl is required for upgrades." >&2; return 1; fi
|
||
if ! command -v grep &> /dev/null; then echo "❌ Error: grep is required for upgrades." >&2; return 1; fi
|
||
if ! command -v realpath &> /dev/null; then echo "❌ Error: realpath is required for upgrades." >&2; return 1; fi
|
||
if ! setup_gum; then return 1; fi
|
||
|
||
# --- Download latest version to a temporary file ---
|
||
local upgrade_url="https://github.com/CaptainCore/do/releases/latest/download/_do.sh"
|
||
local temp_file
|
||
temp_file=$(mktemp)
|
||
if ! curl -sL "$upgrade_url" -o "$temp_file"; then
|
||
echo "❌ Error: Failed to download the latest version from $upgrade_url" >&2
|
||
rm -f "$temp_file"
|
||
return 1
|
||
fi
|
||
|
||
# --- Extract version numbers ---
|
||
local new_version
|
||
new_version=$(grep 'CAPTAINCORE_DO_VERSION=' "$temp_file" | head -n1 | cut -d'"' -f2)
|
||
|
||
if [ -z "$new_version" ]; then
|
||
echo "❌ Error: Could not determine the version number from the downloaded file." >&2
|
||
rm -f "$temp_file"
|
||
return 1
|
||
fi
|
||
|
||
local current_version="$CAPTAINCORE_DO_VERSION"
|
||
echo " - Current version: $current_version"
|
||
echo " - Latest version: $new_version"
|
||
|
||
# --- Determine install path & type ---
|
||
local install_path
|
||
local current_script_path
|
||
local is_system_install=false
|
||
|
||
# Try to determine the path of the running script
|
||
current_script_path=$(realpath "$0" 2>/dev/null)
|
||
|
||
# Check if the script is running from a common system binary path
|
||
if [[ -n "$current_script_path" && -f "$current_script_path" ]]; then
|
||
if [[ "$current_script_path" == /usr/local/bin/* || "$current_script_path" == /usr/bin/* || "$current_script_path" == /bin/* ]]; then
|
||
is_system_install=true
|
||
fi
|
||
fi
|
||
|
||
# --- Handle Different Scenarios ---
|
||
if [[ "$is_system_install" == "true" ]]; then
|
||
# --- UPGRADE SCENARIO for an existing system install ---
|
||
echo " - Found existing system installation at: $current_script_path"
|
||
install_path="$current_script_path"
|
||
|
||
local latest_available
|
||
latest_available=$(printf '%s\n' "$new_version" "$current_version" | sort -V | tail -n1)
|
||
|
||
if [[ "$new_version" == "$current_version" ]]; then
|
||
echo "✅ You are already using the latest version ($current_version)."
|
||
if ! "$GUM_CMD" confirm "Do you want to reinstall it anyway?"; then
|
||
rm -f "$temp_file"
|
||
return 0
|
||
fi
|
||
elif [[ "$latest_available" == "$current_version" ]]; then
|
||
echo "✅ You are running a newer version ($current_version) than the latest release ($new_version). No action taken."
|
||
rm -f "$temp_file"
|
||
return 0
|
||
fi
|
||
echo " - Upgrading to version $new_version..."
|
||
|
||
else
|
||
# --- NEW INSTALL SCENARIO (for dev scripts or curl|bash) ---
|
||
if [[ -n "$current_script_path" && -f "$current_script_path" ]]; then
|
||
echo " - Running from a local script. Treating as a new system-wide installation."
|
||
else
|
||
echo " - No physical script found. Treating as a new system-wide installation."
|
||
fi
|
||
|
||
install_path="/usr/local/bin/_do"
|
||
echo " - Target install location: $install_path"
|
||
|
||
# If the target already exists, check its version to avoid unnecessary work
|
||
if [ -f "$install_path" ]; then
|
||
local existing_install_version
|
||
existing_install_version=$(grep 'CAPTAINCORE_DO_VERSION=' "$install_path" | head -n1 | cut -d'"' -f2)
|
||
if [[ "$new_version" == "$existing_install_version" ]]; then
|
||
echo "✅ The latest version ($new_version) is already installed at $install_path. No action taken."
|
||
rm -f "$temp_file"
|
||
return 0
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
# --- Perform the installation/upgrade ---
|
||
echo " - Installing to $install_path..."
|
||
|
||
# Make the downloaded script executable
|
||
chmod +x "$temp_file"
|
||
|
||
# Check for write permissions and use sudo if needed
|
||
if [ -w "$(dirname "$install_path")" ]; then
|
||
if ! mv "$temp_file" "$install_path"; then
|
||
echo "❌ Error: Failed to move the new version to $install_path." >&2
|
||
rm -f "$temp_file" # Clean up temp file on failure
|
||
return 1
|
||
fi
|
||
else
|
||
echo " - Write permission is required for the directory $(dirname "$install_path")."
|
||
echo " - You may be prompted for your password to complete the installation."
|
||
if ! sudo mv "$temp_file" "$install_path"; then
|
||
echo "❌ Error: sudo command failed. Could not complete installation/upgrade." >&2
|
||
rm -f "$temp_file" # Clean up temp file on failure
|
||
return 1
|
||
fi
|
||
fi
|
||
|
||
echo "✅ Success! _do version $new_version is now installed at $install_path."
|
||
}
|
||
# ----------------------------------------------------
|
||
# Performs a full site backup to a Restic repository on B2.
|
||
# Credentials can be injected via environment variables or piped via stdin.
|
||
# ----------------------------------------------------
|
||
function vault_create() {
|
||
echo "🚀 Starting secure snapshot to Restic B2 repository..."
|
||
|
||
# --- Pre-flight Checks ---
|
||
if ! setup_restic; then return 1; fi
|
||
if ! setup_wp_cli; then return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then
|
||
echo "❌ Error: This does not appear to be a WordPress installation." >&2
|
||
return 1
|
||
fi
|
||
|
||
# --- Setup Restic Environment ---
|
||
if ! _setup_vault_env; then
|
||
return 1 # Error message printed in helper
|
||
fi
|
||
|
||
# --- Rclone Cache Size Check ---
|
||
if [ -n "$EMAIL_NOTIFY" ]; then
|
||
local rclone_cache_dir="$HOME/.cache/rclone"
|
||
if [ -d "$rclone_cache_dir" ]; then
|
||
local cache_size_bytes
|
||
cache_size_bytes=$(du -sb "$rclone_cache_dir" | awk '{print $1}')
|
||
local size_limit_bytes=10737418240 # 10 GB
|
||
|
||
if (( cache_size_bytes > size_limit_bytes )); then
|
||
local site_url
|
||
site_url=$("$WP_CLI_CMD" option get home)
|
||
local cache_size_gb
|
||
cache_size_gb=$(awk -v bytes="$cache_size_bytes" 'BEGIN { printf "%.2f", bytes / 1024 / 1024 / 1024 }')
|
||
|
||
local email_subject="Rclone Cache Warning for ${site_url}"
|
||
local email_message="Warning: The rclone cache folder at ${rclone_cache_dir} is larger than 10GB. Current size: ${cache_size_gb}GB. This might cause issues with 'vault create' operations."
|
||
echo " - ⚠️ Rclone cache is large (${cache_size_gb}GB). Sending email notification to $EMAIL_NOTIFY..."
|
||
|
||
"$WP_CLI_CMD" eval "wp_mail( '$EMAIL_NOTIFY', '$email_subject', '$email_message', ['Content-Type: text/html; charset=UTF-8'] );"
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
# --- Check/Initialize Restic Repository ---
|
||
echo " - Checking for repository at ${RESTIC_REPOSITORY}..."
|
||
if ! "$RESTIC_CMD" stats > /dev/null 2>&1; then
|
||
echo " - Repository not found or is invalid. Attempting to initialize..."
|
||
if ! "$RESTIC_CMD" init; then
|
||
echo "❌ Error: Failed to initialize Restic repository." >&2
|
||
return 1
|
||
fi
|
||
echo " - ✅ Repository initialized successfully."
|
||
else
|
||
echo " - ✅ Repository found."
|
||
fi
|
||
|
||
# --- Create DB Dump in Private Directory ---
|
||
local private_dir
|
||
if ! private_dir=$(_get_private_dir); then
|
||
return 1
|
||
fi
|
||
local sql_file_path="${private_dir}/database-backup.sql"
|
||
|
||
echo " - Generating database dump at: ${sql_file_path}"
|
||
if ! "$WP_CLI_CMD" db export "$sql_file_path" --add-drop-table --single-transaction --quick --max_allowed_packet=512M > /dev/null; then
|
||
echo "❌ Error: Database export failed." >&2
|
||
return 1
|
||
fi
|
||
|
||
# --- Move DB dump to root for snapshot ---
|
||
local wp_root_dir
|
||
wp_root_dir=$(realpath ".")
|
||
local temporary_sql_path_in_root="${wp_root_dir}/database-backup.sql"
|
||
|
||
echo " - Temporarily moving database dump to web root for snapshotting."
|
||
if ! mv "$sql_file_path" "$temporary_sql_path_in_root"; then
|
||
echo "❌ Error: Could not move database dump to web root." >&2
|
||
return 1
|
||
fi
|
||
|
||
# --- Run Restic Backup ---
|
||
local original_dir
|
||
original_dir=$(pwd)
|
||
echo " - Changing to WordPress root ($wp_root_dir) for clean snapshot paths..."
|
||
cd "$wp_root_dir" || {
|
||
echo "❌ Error: Could not change to WordPress root directory." >&2
|
||
echo " - Attempting to move database dump back to private directory..."
|
||
mv "$temporary_sql_path_in_root" "$sql_file_path"
|
||
return 1
|
||
}
|
||
|
||
local human_readable_size
|
||
human_readable_size=$(du -sh . | awk '{print $1}')
|
||
local tag_args=()
|
||
if [[ -n "$human_readable_size" ]]; then
|
||
tag_args+=(--tag "size:${human_readable_size}")
|
||
fi
|
||
|
||
echo " - Backing up current directory (.), which now includes the SQL dump..."
|
||
if ! "$RESTIC_CMD" backup "." \
|
||
"${tag_args[@]}" \
|
||
--exclude '**.DS_Store' \
|
||
--exclude '*timthumb.txt' \
|
||
--exclude 'debug.log' \
|
||
--exclude 'error_log' \
|
||
--exclude 'phperror_log' \
|
||
--exclude 'wp-content/updraft' \
|
||
--exclude 'wp-content/cache' \
|
||
--exclude 'wp-content/et-cache' \
|
||
--exclude 'wp-content/.wps-slots' \
|
||
--exclude 'wp-content/wflogs' \
|
||
--exclude 'wp-content/uploads/sessions' \
|
||
--exclude 'wp-snapshots'; then
|
||
echo "❌ Error: Restic backup command failed." >&2
|
||
cd "$original_dir"
|
||
echo " - Moving database dump back to private directory..."
|
||
mv "$temporary_sql_path_in_root" "$sql_file_path"
|
||
return 1
|
||
fi
|
||
|
||
# --- Cleanup: Move DB dump back to private directory ---
|
||
cd "$original_dir"
|
||
echo " - Moving database dump back to private directory..."
|
||
mv "$temporary_sql_path_in_root" "$sql_file_path"
|
||
|
||
# Unset variables for security
|
||
unset B2_ACCOUNT_ID B2_ACCOUNT_KEY RESTIC_PASSWORD RESTIC_REPOSITORY
|
||
|
||
echo "✅ Vault snapshot complete!"
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# (Helper) Reads credentials and sets up the restic environment.
|
||
# ----------------------------------------------------
|
||
function _setup_vault_env() {
|
||
# --- Read Credentials ---
|
||
local b2_bucket b2_path b2_key_id b2_app_key restic_password
|
||
|
||
# Prioritize stdin: If data is being piped in, read from it.
|
||
if ! [ -t 0 ]; then
|
||
read -r stdin_b2_bucket
|
||
read -r stdin_b2_path
|
||
read -r stdin_b2_key_id
|
||
read -r stdin_b2_app_key
|
||
read -r stdin_restic_password
|
||
|
||
b2_bucket=${stdin_b2_bucket}
|
||
b2_path=${stdin_b2_path}
|
||
b2_key_id=${stdin_b2_key_id}
|
||
b2_app_key=${stdin_b2_app_key}
|
||
restic_password=${stdin_restic_password}
|
||
fi
|
||
|
||
# If stdin empty or incomplete, then attempt to load from environment variables.
|
||
if [ -z "$b2_bucket" ] || [ -z "$b2_path" ] || [ -z "$b2_key_id" ] || [ -z "$b2_app_key" ] || [ -z "$restic_password" ]; then
|
||
b2_bucket="$B2_BUCKET"
|
||
b2_path="$B2_PATH"
|
||
b2_key_id="$B2_ACCOUNT_ID"
|
||
b2_app_key="$B2_ACCOUNT_KEY"
|
||
restic_password="$RESTIC_PASSWORD"
|
||
fi
|
||
|
||
if [ -z "$b2_bucket" ] || [ -z "$b2_path" ] || [ -z "$b2_key_id" ] || [ -z "$b2_app_key" ] || [ -z "$restic_password" ]; then
|
||
echo "❌ Error: One or more required credentials were not provided or were empty." >&2
|
||
return 1
|
||
fi
|
||
|
||
export B2_ACCOUNT_ID="$b2_key_id"
|
||
export B2_ACCOUNT_KEY="$b2_app_key"
|
||
export RESTIC_PASSWORD="$restic_password"
|
||
export RESTIC_REPOSITORY="b2:${b2_bucket}:${b2_path}"
|
||
|
||
return 0
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# (Helper) Caches the file list for a snapshot.
|
||
# ----------------------------------------------------
|
||
function _cache_snapshot_files() {
|
||
local snapshot_id="$1"
|
||
local cache_file="$2"
|
||
|
||
# Show a spinner while caching the entire file list.
|
||
if ! "$GUM_CMD" spin --spinner dot --title "Caching file list for snapshot ${snapshot_id}..." -- \
|
||
"$RESTIC_CMD" ls --json --long --recursive "${snapshot_id}" > "$cache_file";
|
||
then
|
||
echo "❌ Error: Could not cache the file list for snapshot ${snapshot_id}."
|
||
>&2
|
||
rm -f "$cache_file" # Clean up partial cache file
|
||
return 1
|
||
fi
|
||
return 0
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# (Helper) Provides an interactive menu for a selected file.
|
||
# ----------------------------------------------------
|
||
function _file_action_menu() {
|
||
local snapshot_id="$1"
|
||
local file_path="$2"
|
||
|
||
local choice
|
||
choice=$("$GUM_CMD" choose "View Content" "Download File" "Restore File" "Back")
|
||
|
||
case "$choice" in
|
||
"View Content")
|
||
echo "📄 Viewing content of '$file_path'... (Press 'q' to quit)"
|
||
local temp_file
|
||
temp_file=$(mktemp)
|
||
|
||
|
||
if [ -z "$temp_file" ];
|
||
then
|
||
echo "❌ Error: Could not create a temporary file."
|
||
>&2
|
||
sleep 2
|
||
return
|
||
fi
|
||
|
||
# Dump the file content to the temporary file
|
||
if ! "$RESTIC_CMD" dump "${snapshot_id}" "${file_path}" > "$temp_file"; then
|
||
echo "❌ Error: Could not dump file content from repository."
|
||
>&2
|
||
rm -f "$temp_file"
|
||
sleep 2
|
||
return
|
||
fi
|
||
|
||
# View the temporary file with less, ensuring it's interactive
|
||
|
||
|
||
less -RN "$temp_file" </dev/tty
|
||
|
||
# Clean up the temporary file
|
||
rm -f "$temp_file"
|
||
;;
|
||
"Download File")
|
||
local filename
|
||
filename=$(basename "$file_path")
|
||
echo "⬇️ Downloading '$filename' to current directory..."
|
||
if "$GUM_CMD" confirm "Download '${filename}' to '$(pwd)'?";
|
||
then
|
||
if "$RESTIC_CMD" dump "${snapshot_id}" "${file_path}" > "$filename";
|
||
then
|
||
local size
|
||
size=$(ls -lh "$filename" | awk '{print $5}')
|
||
echo "✅ File downloaded: $filename ($size)"
|
||
else
|
||
|
||
|
||
echo "❌ Error: Failed to download file."
|
||
rm -f "$filename"
|
||
fi
|
||
else
|
||
echo "Download cancelled."
|
||
fi
|
||
"$GUM_CMD" input --placeholder="Press Enter to continue..." > /dev/null
|
||
;;
|
||
"Restore File")
|
||
echo "🔄 Restoring '$file_path' to current directory..."
|
||
if "$GUM_CMD" confirm "Restore '${file_path}' to '$(pwd)'?";
|
||
then
|
||
if "$RESTIC_CMD" restore "${snapshot_id}" --include "${file_path}" --target ".";
|
||
then
|
||
echo "✅ File restored successfully."
|
||
else
|
||
echo "❌ Error: Failed to restore file."
|
||
fi
|
||
else
|
||
echo "Restore cancelled."
|
||
fi
|
||
# Add a pause so the user can see the result before returning to the browser.
|
||
"$GUM_CMD" input --placeholder="Press Enter to continue..." > /dev/null
|
||
;;
|
||
"Back")
|
||
return
|
||
;;
|
||
*)
|
||
esac
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# (Helper) Handles the download/restore of a full folder.
|
||
# ----------------------------------------------------
|
||
function _download_folder_action() {
|
||
local snapshot_id="$1"
|
||
local folder_path_in_repo="$2"
|
||
|
||
echo "📦 Preparing to download folder: '${folder_path_in_repo}'"
|
||
echo "This action will restore the selected folder and its full directory structure from the snapshot's root into your current working directory."
|
||
echo "For example, restoring '/wp-content/plugins/' will create the path './wp-content/plugins/' here."
|
||
|
||
if "$GUM_CMD" confirm "Proceed with restoring '${folder_path_in_repo}' to '$(pwd)'?"; then
|
||
echo " - Restoring files..."
|
||
if "$RESTIC_CMD" restore "${snapshot_id}" --include "${folder_path_in_repo}" --target "."; then
|
||
echo "✅ Folder and its contents restored successfully."
|
||
else
|
||
echo "❌ Error: Failed to restore folder."
|
||
fi
|
||
else
|
||
echo "Download cancelled."
|
||
fi
|
||
"$GUM_CMD" input --placeholder="Press Enter to continue..." > /dev/null
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# (Helper) Provides an interactive file browser for a snapshot.
|
||
# ----------------------------------------------------
|
||
function _browse_snapshot() {
|
||
local snapshot_id="$1"
|
||
local cache_file="$2"
|
||
local current_path="/"
|
||
|
||
while true;
|
||
do
|
||
clear
|
||
echo "🗂 Browse Snapshot: ${snapshot_id} | Path: ${current_path}"
|
||
|
||
# PHP script to parse the cached JSON and format it for the current directory
|
||
local php_parser_code='
|
||
<?php
|
||
$cache_file = $argv[1] ?? "";
|
||
$current_path = $argv[2] ?? "/";
|
||
|
||
if (!file_exists($cache_file)) {
|
||
fwrite(STDERR, "Cache file not found.\n");
|
||
exit(1);
|
||
}
|
||
|
||
$file_content = file_get_contents($cache_file);
|
||
$lines = explode("\n", trim($file_content));
|
||
|
||
$items_in_current_dir = [];
|
||
$dirs_in_current_dir = [];
|
||
|
||
foreach ($lines as $line) {
|
||
if (empty($line)) continue;
|
||
$item = json_decode($line, true);
|
||
if (json_last_error() !== JSON_ERROR_NONE || !isset($item["path"])) continue;
|
||
|
||
$item_path = $item["path"];
|
||
|
||
if (strpos($item_path, $current_path) !== 0) continue;
|
||
|
||
$relative_path = substr($item_path, strlen($current_path));
|
||
if (empty($relative_path)) continue;
|
||
|
||
if (strpos($relative_path, "/") === false) {
|
||
if ($item["type"] === "dir") {
|
||
$dirs_in_current_dir[$relative_path] = true;
|
||
} else {
|
||
$items_in_current_dir[$relative_path] = $item;
|
||
}
|
||
} else {
|
||
$dir_name = explode("/", $relative_path)[0];
|
||
$dirs_in_current_dir[$dir_name] = true;
|
||
}
|
||
}
|
||
|
||
ksort($dirs_in_current_dir);
|
||
ksort($items_in_current_dir);
|
||
|
||
if ($current_path !== "/") {
|
||
echo "⤴️ ../ (Up one level)|up|..\n";
|
||
}
|
||
|
||
foreach (array_keys($dirs_in_current_dir) as $dir) {
|
||
echo "📁 " . $dir . "/|dir|" . $dir . "\n";
|
||
}
|
||
|
||
foreach ($items_in_current_dir as $name => $item) {
|
||
$size_bytes = $item["size"] ?? 0;
|
||
$size_formatted = "0 B";
|
||
if ($size_bytes >= 1048576) { $size_formatted = round($size_bytes / 1048576, 2) . " MB"; }
|
||
elseif ($size_bytes >= 1024) { $size_formatted = round($size_bytes / 1024, 2) . " KB"; }
|
||
elseif ($size_bytes > 0) { $size_formatted = $size_bytes . " B"; }
|
||
echo "📄 " . $name . " (" . $size_formatted . ")|file|" . $name . "\n";
|
||
}
|
||
|
||
echo "\n";
|
||
echo "💾 Download this directory ({$current_path})|download_dir|.\n";
|
||
'
|
||
# Execute PHP script to get a formatted list from the cache
|
||
local temp_script_file;
|
||
temp_script_file=$(mktemp)
|
||
echo "$php_parser_code" > "$temp_script_file"
|
||
local formatted_list;
|
||
formatted_list=$(php -f "$temp_script_file" "$cache_file" "$current_path")
|
||
rm "$temp_script_file"
|
||
|
||
# --- Display and selection logic ---
|
||
local display_items=()
|
||
local data_items=()
|
||
|
||
while IFS='|'
|
||
read -r display_part type_part name_part; do
|
||
if [ -z "$display_part" ];
|
||
then continue; fi
|
||
display_items+=("$display_part")
|
||
data_items+=("${type_part}|${name_part}")
|
||
done <<< "$formatted_list"
|
||
|
||
local selected_display
|
||
# Use a for loop to pipe items to gum filter, avoiding argument list limits.
|
||
selected_display=$(
|
||
for item in "${display_items[@]}"; do
|
||
echo "$item"
|
||
done | "$GUM_CMD" filter --height=20 --prompt="👇 Select a snapshot to browse" --indicator="→" --placeholder=""
|
||
)
|
||
|
||
if [ -z "$selected_display" ];
|
||
then
|
||
return # Exit the browser
|
||
fi
|
||
|
||
local selected_index=-1
|
||
for i in "${!display_items[@]}";
|
||
do
|
||
if [[ "${display_items[$i]}" == "$selected_display" ]];
|
||
then
|
||
selected_index=$i
|
||
break
|
||
fi
|
||
done
|
||
|
||
if [ "$selected_index" -eq -1 ];
|
||
then continue; fi
|
||
|
||
local selected_data="${data_items[selected_index]}"
|
||
local item_type;
|
||
item_type=$(echo "$selected_data" | cut -d'|' -f1)
|
||
local item_name;
|
||
item_name=$(echo "$selected_data" | cut -d'|' -f2)
|
||
|
||
case "$item_type" in
|
||
"dir")
|
||
current_path="${current_path}${item_name}/"
|
||
;;
|
||
"file")
|
||
_file_action_menu "${snapshot_id}" "${current_path}${item_name}"
|
||
;;
|
||
"up")
|
||
if [[ "$current_path" != "/" ]]; then
|
||
# Get parent directory
|
||
parent_path=$(dirname "${current_path%/}")
|
||
# If the parent is the root, the new path is simply "/".
|
||
# Otherwise, it's the parent path with a trailing slash.
|
||
if [[ "$parent_path" == "/" ]]; then
|
||
current_path="/"
|
||
else
|
||
current_path="${parent_path}/"
|
||
fi
|
||
fi
|
||
;;
|
||
"download_dir")
|
||
_download_folder_action "${snapshot_id}" "${current_path}"
|
||
;;
|
||
esac
|
||
done
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Lists all snapshots in the Restic repository.
|
||
# ----------------------------------------------------
|
||
function vault_snapshots() {
|
||
local output_mode="$1"
|
||
|
||
if ! setup_restic; then return 1; fi
|
||
if ! setup_gum; then return 1; fi
|
||
if ! command -v php &>/dev/null; then echo "❌ Error: The 'php' command is required for this operation." >&2; return 1; fi
|
||
if ! command -v mktemp &>/dev/null; then echo "❌ Error: The 'mktemp' command is required for this operation." >&2; return 1; fi
|
||
if ! command -v wc &>/dev/null; then echo "❌ Error: The 'wc' command is required for this operation." >&2; return 1; fi
|
||
|
||
if ! _setup_vault_env; then
|
||
return 1 # Error message printed in helper
|
||
fi
|
||
|
||
local snapshots_json
|
||
snapshots_json=$("$GUM_CMD" spin --spinner dot --title "Fetching snapshots from repository..." -- \
|
||
"$RESTIC_CMD" snapshots --json
|
||
)
|
||
if [[ ! "$snapshots_json" =~ ^\[ ]]; then
|
||
echo "Error: Failed to fetch snapshots. Restic output:" >&2
|
||
echo "$snapshots_json" >&2
|
||
exit 1
|
||
fi
|
||
|
||
local total_count
|
||
read -r -d '' php_script << 'EOF'
|
||
$json_string = file_get_contents("php://stdin");
|
||
$snapshots = json_decode($json_string, true);
|
||
if (json_last_error() === JSON_ERROR_NONE) {
|
||
echo count($snapshots);
|
||
} else {
|
||
echo 0;
|
||
}
|
||
EOF
|
||
total_count=$("$GUM_CMD" spin --spinner dot --title "Counting total snapshots..." -- \
|
||
bash -c 'php -r "$1"' _ "$php_script" <<< "$snapshots_json"
|
||
)
|
||
|
||
echo "🔎 Fetching ${total_count} snapshots..."
|
||
|
||
if [[ "$snapshots_json" == "[]" ]]; then
|
||
echo "ℹ️ No snapshots found in the repository."
|
||
return 0
|
||
fi
|
||
|
||
local php_parser_code='
|
||
<?php
|
||
if (defined("STDIN")) {
|
||
$json_data = file_get_contents("php://stdin");
|
||
$snapshots = json_decode($json_data, true);
|
||
if (json_last_error() !== JSON_ERROR_NONE) {
|
||
fwrite(STDERR, "PHP Error: Failed to decode JSON - " . json_last_error_msg() . "\n");
|
||
exit(1);
|
||
}
|
||
if (empty($snapshots) || !is_array($snapshots)) {
|
||
exit(0);
|
||
}
|
||
usort($snapshots, function($a, $b) { return strtotime($b["time"]) - strtotime($a["time"]); });
|
||
|
||
foreach ($snapshots as $snap) {
|
||
$size_formatted = "N/A";
|
||
if (isset($snap["summary"]["total_bytes_processed"])) {
|
||
$size_bytes = (float)$snap["summary"]["total_bytes_processed"];
|
||
if ($size_bytes >= 1073741824) {
|
||
$size_formatted = round($size_bytes / 1073741824, 2) . " GB";
|
||
} elseif ($size_bytes >= 1048576) {
|
||
$size_formatted = round($size_bytes / 1048576, 2) . " MB";
|
||
} elseif ($size_bytes >= 1024) {
|
||
$size_formatted = round($size_bytes / 1024, 2) . " KB";
|
||
} elseif ($size_bytes > 0) {
|
||
$size_formatted = $size_bytes . " B";
|
||
}
|
||
}
|
||
|
||
echo $snap["short_id"] . "|" .
|
||
(new DateTime($snap["time"]))->format("Y-m-d H:i:s") . "|" .
|
||
$size_formatted . "\n";
|
||
}
|
||
}
|
||
'
|
||
local php_script_file
|
||
php_script_file=$(mktemp)
|
||
if [ -z "$php_script_file" ]; then
|
||
echo "❌ Error: Could not create a temporary file for the PHP script." >&2
|
||
return 1
|
||
fi
|
||
|
||
echo "$php_parser_code" > "$php_script_file"
|
||
local snapshot_list
|
||
snapshot_list=$(printf "%s" "$snapshots_json" | php -f "$php_script_file" 2>/dev/null)
|
||
rm -f "$php_script_file"
|
||
|
||
if [ -z "$snapshot_list" ]; then
|
||
echo "❌ Error parsing snapshot list." >&2
|
||
return 1
|
||
fi
|
||
|
||
local display_items=()
|
||
local data_items=()
|
||
|
||
while IFS='|' read -r id time size; do
|
||
if [ -z "$id" ]; then
|
||
continue
|
||
fi
|
||
display_items+=("$(printf "%-9s | %-20s | %-10s" "$id" "$time" "$size")")
|
||
data_items+=("$id")
|
||
done <<< "$snapshot_list"
|
||
|
||
if [[ "$output_mode" == "true" ]]; then
|
||
printf "%s\n" "${display_items[@]}"
|
||
return 0
|
||
fi
|
||
|
||
local selected_display
|
||
selected_display=$(printf "%s\n" "${display_items[@]}" | "$GUM_CMD" filter --height=20 --prompt="👇 Select a snapshot to browse" --indicator="→" --placeholder="")
|
||
|
||
if [ -z "$selected_display" ]; then echo "No snapshot selected."; return 0; fi
|
||
|
||
local selected_id
|
||
selected_id=$(echo "$selected_display" | awk '{print $1}')
|
||
|
||
local cache_file;
|
||
cache_file=$(mktemp)
|
||
if ! _cache_snapshot_files "$selected_id" "$cache_file"; then
|
||
[ -f "$cache_file" ] && rm -f "$cache_file"
|
||
return 1
|
||
fi
|
||
|
||
_browse_snapshot "$selected_id" "$cache_file"
|
||
rm -f "$cache_file"
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Mounts the Restic repository to a local directory.
|
||
# ----------------------------------------------------
|
||
function vault_mount() {
|
||
echo "🚀 Preparing to mount Restic repository..."
|
||
if ! setup_restic;
|
||
then return 1; fi
|
||
if ! _setup_vault_env; then return 1;
|
||
fi
|
||
|
||
local mount_point="/tmp/restic_mount_$(date +%s)"
|
||
mkdir -p "$mount_point"
|
||
|
||
echo " - Mount point created at: $mount_point"
|
||
echo " - To unmount, run: umount \"$mount_point\""
|
||
echo " - Press Ctrl+C to stop the foreground mount process."
|
||
"$RESTIC_CMD" mount "$mount_point"
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Displays statistics about the Restic repository.
|
||
# ----------------------------------------------------
|
||
function vault_info() {
|
||
echo "🔎 Gathering repository information..."
|
||
|
||
# --- Pre-flight Checks ---
|
||
if ! setup_restic; then return 1; fi
|
||
if ! setup_gum; then return 1; fi
|
||
if ! setup_rclone; then return 1; fi
|
||
if ! command -v php &>/dev/null; then echo "❌ Error: The 'php' command is required for this operation." >&2; return 1; fi
|
||
|
||
if ! _setup_vault_env; then
|
||
return 1 # Error message printed in helper
|
||
fi
|
||
|
||
# --- Get repo size and file count using rclone ---
|
||
local temp_repo_string="${RESTIC_REPOSITORY#b2:}"
|
||
local b2_bucket="${temp_repo_string%%:*}"
|
||
local b2_path="${temp_repo_string#*:}"
|
||
local rclone_remote_string=":b2,account='${B2_ACCOUNT_ID}',key='${B2_ACCOUNT_KEY}':${b2_bucket}/${b2_path}"
|
||
|
||
local size_json
|
||
size_json=$("$GUM_CMD" spin --spinner dot --title "Calculating repository size with rclone..." -- \
|
||
"$RCLONE_CMD" size --json "$rclone_remote_string"
|
||
)
|
||
|
||
local size_data=""
|
||
if [[ "$size_json" == *"bytes"* ]]; then
|
||
local size_parser_code='
|
||
$json_str = file_get_contents("php://stdin");
|
||
$data = json_decode($json_str, true);
|
||
if (json_last_error() === JSON_ERROR_NONE) {
|
||
$bytes = $data["bytes"] ?? 0;
|
||
$count = $data["count"] ?? 0;
|
||
$size_formatted = "0 B";
|
||
if ($bytes >= 1073741824) { $size_formatted = round($bytes / 1073741824, 2) . " GiB"; }
|
||
elseif ($bytes >= 1048576) { $size_formatted = round($bytes / 1048576, 2) . " MiB"; }
|
||
elseif ($bytes >= 1024) { $size_formatted = round($bytes / 1024, 2) . " KiB"; }
|
||
elseif ($bytes > 0) { $size_formatted = $bytes . " B"; }
|
||
echo "Total Size," . $size_formatted . "\n";
|
||
echo "Total Files," . $count . "\n";
|
||
}
|
||
'
|
||
size_data=$(echo "$size_json" | php -r "$size_parser_code")
|
||
fi
|
||
|
||
# --- Get Snapshot Info from Restic ---
|
||
local snapshots_json
|
||
snapshots_json=$("$GUM_CMD" spin --spinner dot --title "Fetching snapshot list..." -- \
|
||
"$RESTIC_CMD" snapshots --json)
|
||
|
||
if [ $? -ne 0 ]; then
|
||
echo "❌ Error fetching snapshots from restic." >&2
|
||
echo "Restic output: $snapshots_json" >&2
|
||
return 1
|
||
fi
|
||
|
||
# Verify JSON and default to empty array if invalid
|
||
if ! printf "%s" "$snapshots_json" | "$GUM_CMD" format >/dev/null 2>&1; then
|
||
snapshots_json="[]"
|
||
fi
|
||
|
||
# --- MODIFIED: Pipe Restic JSON directly to PHP parser ---
|
||
local php_parser_code_info='
|
||
$json_data = file_get_contents("php://stdin");
|
||
$snapshots = json_decode($json_data, true);
|
||
|
||
// Exit if JSON is invalid or empty after decoding
|
||
if (json_last_error() !== JSON_ERROR_NONE || !is_array($snapshots)) { exit(0); }
|
||
|
||
$snapshot_count = count($snapshots);
|
||
$oldest_date = "N/A";
|
||
$newest_date = "N/A";
|
||
|
||
if ($snapshot_count > 0) {
|
||
$timestamps = array_map(function($s) {
|
||
return isset($s["time"]) ? strtotime($s["time"]) : 0;
|
||
}, $snapshots);
|
||
$timestamps = array_filter($timestamps);
|
||
if(count($timestamps) > 0) {
|
||
$oldest_ts = min($timestamps);
|
||
$newest_ts = max($timestamps);
|
||
$oldest_date = date("Y-m-d H:i:s T", $oldest_ts);
|
||
$newest_date = date("Y-m-d H:i:s T", $newest_ts);
|
||
}
|
||
}
|
||
echo "Snapshot Count," . $snapshot_count . "\n";
|
||
echo "Oldest Snapshot," . $oldest_date . "\n";
|
||
echo "Newest Snapshot," . $newest_date . "\n";
|
||
'
|
||
local info_data
|
||
info_data=$(printf "%s" "$snapshots_json" | php -r "$php_parser_code_info")
|
||
|
||
echo "--- Repository Information ---"
|
||
(
|
||
echo "Statistic,Value"
|
||
echo "B2 Bucket,${b2_bucket}"
|
||
echo "B2 Path,${b2_path}"
|
||
if [ -n "$size_data" ]; then echo "$size_data"; fi
|
||
if [ -n "$info_data" ]; then echo "$info_data"; fi
|
||
) | "$GUM_CMD" table --print --separator "," --widths=20,40
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Prunes the Restic repository to remove unneeded data.
|
||
# ----------------------------------------------------
|
||
function vault_prune() {
|
||
echo "🚀 Preparing to prune the Restic repository..."
|
||
echo "This command removes old data that is no longer needed."
|
||
echo "It can be a long-running process and will lock the repository."
|
||
|
||
# --- Pre-flight Checks ---
|
||
if ! setup_restic; then return 1; fi
|
||
if ! setup_gum; then return 1; fi
|
||
|
||
# --- Setup Restic Environment ---
|
||
if ! _setup_vault_env; then
|
||
return 1 # Error message printed in helper
|
||
fi
|
||
|
||
# --- User Confirmation ---
|
||
echo "Repository: ${RESTIC_REPOSITORY}"
|
||
if ! "$GUM_CMD" confirm "Are you sure you want to prune this repository?"; then
|
||
echo "Prune operation cancelled."
|
||
unset B2_ACCOUNT_ID B2_ACCOUNT_KEY RESTIC_PASSWORD RESTIC_REPOSITORY
|
||
return 0
|
||
fi
|
||
|
||
# --- Run Restic Prune with lock detection ---
|
||
echo " - Starting prune operation. This may take a while..."
|
||
local prune_output
|
||
# Capture all output (stdout and stderr) to check for the lock message
|
||
prune_output=$("$RESTIC_CMD" prune 2>&1)
|
||
local prune_exit_code=$?
|
||
|
||
# Check if the prune command failed
|
||
if [ $prune_exit_code -ne 0 ]; then
|
||
# If it failed, check if it was due to a lock
|
||
if echo "$prune_output" | grep -q "unable to create lock"; then
|
||
echo "⚠️ The repository is locked. A previous operation may have failed or is still running."
|
||
echo "$prune_output" # Show the user the detailed lock info from restic
|
||
|
||
if "$GUM_CMD" confirm "Do you want to attempt to remove the stale lock and retry?"; then
|
||
echo " - Attempting to unlock repository..."
|
||
if ! "$RESTIC_CMD" unlock; then
|
||
echo "❌ Error: Failed to unlock the repository. Please check it manually." >&2
|
||
unset B2_ACCOUNT_ID B2_ACCOUNT_KEY RESTIC_PASSWORD RESTIC_REPOSITORY
|
||
return 1
|
||
fi
|
||
|
||
echo " - Unlock successful. Retrying prune operation..."
|
||
if ! "$RESTIC_CMD" prune; then
|
||
echo "❌ Error: Restic prune command failed even after unlocking." >&2
|
||
unset B2_ACCOUNT_ID B2_ACCOUNT_KEY RESTIC_PASSWORD RESTIC_REPOSITORY
|
||
return 1
|
||
fi
|
||
else
|
||
echo "Prune operation cancelled due to locked repository."
|
||
unset B2_ACCOUNT_ID B2_ACCOUNT_KEY RESTIC_PASSWORD RESTIC_REPOSITORY
|
||
return 0
|
||
fi
|
||
else
|
||
# The failure was for a reason other than a lock
|
||
echo "❌ Error: Restic prune command failed." >&2
|
||
echo "$prune_output" >&2
|
||
unset B2_ACCOUNT_ID B2_ACCOUNT_KEY RESTIC_PASSWORD RESTIC_REPOSITORY
|
||
return 1
|
||
fi
|
||
fi
|
||
|
||
# --- Cleanup ---
|
||
unset B2_ACCOUNT_ID B2_ACCOUNT_KEY RESTIC_PASSWORD RESTIC_REPOSITORY
|
||
|
||
echo "✅ Vault prune complete!"
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Deletes a specific snapshot from the Restic repository.
|
||
# ----------------------------------------------------
|
||
function vault_delete() {
|
||
local snapshot_id="$1"
|
||
|
||
if [ -z "$snapshot_id" ]; then
|
||
echo "❌ Error: You must provide a snapshot ID to delete." >&2
|
||
show_command_help "vault" >&2
|
||
return 1
|
||
fi
|
||
|
||
# --- Pre-flight Checks ---
|
||
if ! setup_restic; then return 1; fi
|
||
if ! setup_gum; then return 1; fi
|
||
|
||
# --- Setup Restic Environment ---
|
||
if ! _setup_vault_env; then
|
||
return 1 # Error message printed in helper
|
||
fi
|
||
|
||
echo "You are about to permanently delete snapshot: ${snapshot_id}"
|
||
echo "This action cannot be undone."
|
||
if ! "$GUM_CMD" confirm "Are you sure you want to delete this snapshot?"; then
|
||
echo "Delete operation cancelled."
|
||
unset B2_ACCOUNT_ID B2_ACCOUNT_KEY RESTIC_PASSWORD RESTIC_REPOSITORY
|
||
return 0
|
||
fi
|
||
|
||
echo " - Deleting snapshot ${snapshot_id}..."
|
||
local forget_output
|
||
# Capture stdout and stderr to check for errors
|
||
forget_output=$("$RESTIC_CMD" forget "$snapshot_id" 2>&1)
|
||
local forget_exit_code=$?
|
||
|
||
# Check if the command failed
|
||
if [ $forget_exit_code -ne 0 ]; then
|
||
# If it failed, check if it was due to a lock
|
||
if echo "$forget_output" | grep -q "unable to create lock"; then
|
||
echo "⚠️ The repository is locked. A previous operation may have failed or is still running."
|
||
echo "$forget_output"
|
||
|
||
if "$GUM_CMD" confirm "Do you want to attempt to remove the stale lock and retry?"; then
|
||
echo " - Attempting to unlock repository..."
|
||
if ! "$RESTIC_CMD" unlock; then
|
||
echo "❌ Error: Failed to unlock the repository. Please check it manually." >&2
|
||
unset B2_ACCOUNT_ID B2_ACCOUNT_KEY RESTIC_PASSWORD RESTIC_REPOSITORY
|
||
return 1
|
||
fi
|
||
|
||
echo " - Unlock successful. Retrying delete operation..."
|
||
if ! "$RESTIC_CMD" forget "$snapshot_id"; then
|
||
echo "❌ Error: Restic forget command failed even after unlocking." >&2
|
||
unset B2_ACCOUNT_ID B2_ACCOUNT_KEY RESTIC_PASSWORD RESTIC_REPOSITORY
|
||
return 1
|
||
fi
|
||
else
|
||
echo "Delete operation cancelled due to locked repository."
|
||
unset B2_ACCOUNT_ID B2_ACCOUNT_KEY RESTIC_PASSWORD RESTIC_REPOSITORY
|
||
return 0
|
||
fi
|
||
else
|
||
# The failure was for a reason other than a lock
|
||
echo "❌ Error: Failed to delete snapshot ${snapshot_id}." >&2
|
||
echo "$forget_output" >&2
|
||
unset B2_ACCOUNT_ID B2_ACCOUNT_KEY RESTIC_PASSWORD RESTIC_REPOSITORY
|
||
return 1
|
||
fi
|
||
else
|
||
# Print the success output from the first attempt
|
||
echo "$forget_output"
|
||
fi
|
||
|
||
# --- Cleanup ---
|
||
unset B2_ACCOUNT_ID B2_ACCOUNT_KEY RESTIC_PASSWORD RESTIC_REPOSITORY
|
||
|
||
echo "✅ Snapshot ${snapshot_id} has been forgotten."
|
||
echo "💡 Note: This only removes the snapshot reference. To free up storage space by removing the underlying data, run '_do vault prune'."
|
||
}
|
||
|
||
function vault_snapshot_info() {
|
||
local snapshot_id="$1"
|
||
|
||
if [ -z "$snapshot_id" ];
|
||
then
|
||
echo "❌ Error: You must provide a snapshot ID."
|
||
show_command_help "vault" >&2
|
||
return 1
|
||
fi
|
||
|
||
# --- Pre-flight Checks ---
|
||
if ! setup_restic; then return 1; fi
|
||
if ! setup_gum; then return 1; fi
|
||
if ! command -v php &>/dev/null; then
|
||
echo "❌ Error: The 'php' command is required for this operation."
|
||
>&2
|
||
return 1
|
||
fi
|
||
|
||
# --- Setup Restic Environment ---
|
||
if ! _setup_vault_env; then
|
||
return 1
|
||
fi
|
||
|
||
# --- Fetch Snapshot Data ---
|
||
echo "🔎 Fetching information for snapshot ${snapshot_id}..."
|
||
local snapshots_json
|
||
snapshots_json=$("$GUM_CMD" spin --spinner dot --title "Fetching repository data..." -- \
|
||
"$RESTIC_CMD" snapshots --json)
|
||
|
||
if [ $? -ne 0 ]; then
|
||
echo "❌ Error: Failed to fetch snapshot list from the repository."
|
||
>&2
|
||
unset B2_ACCOUNT_ID B2_ACCOUNT_KEY RESTIC_PASSWORD RESTIC_REPOSITORY
|
||
return 1
|
||
fi
|
||
|
||
# --- PHP Parser ---
|
||
# This script searches the JSON list for the specific snapshot ID and falls back to 'restic stats' if needed.
|
||
local php_parser_code='
|
||
$target_id = $argv[1] ?? "";
|
||
$restic_cmd = $argv[2] ?? "restic";
|
||
|
||
if (empty($target_id)) { exit(1);
|
||
}
|
||
|
||
$json_data = file_get_contents("php://stdin");
|
||
$snapshots = json_decode($json_data, true);
|
||
if (json_last_error() !== JSON_ERROR_NONE || !is_array($snapshots)) {
|
||
exit(1);
|
||
}
|
||
|
||
$found_snap = null;
|
||
foreach ($snapshots as $snap) {
|
||
if ((isset($snap["id"]) && strpos($snap["id"], $target_id) === 0) || (isset($snap["short_id"]) && $snap["short_id"] === $target_id)) {
|
||
$found_snap = $snap;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if ($found_snap === null) {
|
||
fwrite(STDERR, "Snapshot with ID starting with \"$target_id\" not found.\n");
|
||
exit(1);
|
||
}
|
||
|
||
$snap = $found_snap;
|
||
|
||
function format_bytes($bytes) {
|
||
$bytes = (float)$bytes;
|
||
if ($bytes >= 1073741824) { return round($bytes / 1073741824, 2) . " GB"; }
|
||
elseif ($bytes >= 1048576) { return round($bytes / 1048576, 2) . " MB"; }
|
||
elseif ($bytes >= 1024) { return round($bytes / 1024, 2) . " KB"; }
|
||
elseif ($bytes > 0) { return $bytes . " B"; }
|
||
else { return "0 B"; }
|
||
}
|
||
|
||
$output = [];
|
||
$output["ID"] = $snap["short_id"] ?? "N/A";
|
||
$output["Time"] = isset($snap["time"]) ? (new DateTime($snap["time"]))->format("Y-m-d H:i:s T") : "N/A";
|
||
$output["Parent"] = $snap["parent"] ?? "None";
|
||
$output["Paths"] = isset($snap["paths"]) && is_array($snap["paths"]) ? implode("\n", $snap["paths"]) : "N/A";
|
||
|
||
$size_formatted = "N/A";
|
||
$data_added_formatted = "N/A";
|
||
|
||
if (isset($snap["summary"]["total_bytes_processed"])) {
|
||
$size_formatted = format_bytes($snap["summary"]["total_bytes_processed"]);
|
||
if (isset($snap["summary"]["data_added"])) {
|
||
$data_added_formatted = format_bytes($snap["summary"]["data_added"]);
|
||
}
|
||
} else {
|
||
fwrite(STDERR, "Snapshot summary not found. Calculating size with '\''restic stats'\''.\n");
|
||
$full_snapshot_id = $snap["id"];
|
||
$stats_json = shell_exec(escapeshellarg($restic_cmd) . " stats --json " . escapeshellarg($full_snapshot_id));
|
||
if ($stats_json) {
|
||
$stats_data = json_decode($stats_json, true);
|
||
if (json_last_error() === JSON_ERROR_NONE && isset($stats_data["total_size"])) {
|
||
$size_formatted = format_bytes($stats_data["total_size"]);
|
||
}
|
||
}
|
||
}
|
||
|
||
$output["Size (Full)"] = $size_formatted;
|
||
$output["Data Added (Unique)"] = $data_added_formatted;
|
||
|
||
foreach($output as $key => $value) {
|
||
// Using addslashes and quoting to handle multi-line paths and other special characters
|
||
echo $key . "," . "\"" . addslashes($value) . "\"\n";
|
||
}
|
||
'
|
||
# --- Process and Display ---
|
||
local info_data
|
||
info_data=$(echo "$snapshots_json" | php -r "$php_parser_code" "$snapshot_id" "$RESTIC_CMD")
|
||
|
||
# If the PHP script returns no data, the snapshot was not found in the JSON.
|
||
if [ -z "$info_data" ]; then
|
||
echo "❌ Error: Could not find data for snapshot '${snapshot_id}' in the repository list." >&2
|
||
unset B2_ACCOUNT_ID B2_ACCOUNT_KEY RESTIC_PASSWORD RESTIC_REPOSITORY
|
||
return 1
|
||
fi
|
||
|
||
# Unset variables for security
|
||
unset B2_ACCOUNT_ID B2_ACCOUNT_KEY RESTIC_PASSWORD RESTIC_REPOSITORY
|
||
|
||
# Display the final table
|
||
echo "--- Snapshot Information ---"
|
||
(
|
||
echo "Property,Value"
|
||
# The PHP script now correctly escapes output for the table
|
||
echo "$info_data"
|
||
) |
|
||
"$GUM_CMD" table --print --separator "," --widths=25,0
|
||
|
||
}
|
||
# ----------------------------------------------------
|
||
# Displays the version of the _do script.
|
||
# ----------------------------------------------------
|
||
function show_version() {
|
||
echo "_do version $CAPTAINCORE_DO_VERSION"
|
||
}
|
||
# ----------------------------------------------------
|
||
# Checks for and identifies sources of WP-CLI warnings.
|
||
# ----------------------------------------------------
|
||
function wpcli_check() {
|
||
if ! setup_wp_cli; then echo "❌ Error: WP-CLI not found." >&2; return 1; fi
|
||
if ! "$WP_CLI_CMD" core is-installed --quiet; then echo "❌ Error: This does not appear to be a WordPress installation." >&2; return 1; fi
|
||
|
||
echo "🚀 Checking for WP-CLI warnings..."
|
||
|
||
# 1. Run with everything skipped to check for core issues.
|
||
local base_warnings
|
||
base_warnings=$("$WP_CLI_CMD" plugin list --skip-themes --skip-plugins 2>&1 >/dev/null)
|
||
|
||
if [[ -n "$base_warnings" ]]; then
|
||
echo "⚠️ Found warnings even with all plugins and themes skipped. This might be a WP-CLI core or WordPress core issue."
|
||
echo "--- Warnings ---"
|
||
echo "$base_warnings"
|
||
echo "----------------"
|
||
return 1
|
||
fi
|
||
|
||
# 2. Run with everything active to get a baseline.
|
||
local initial_warnings
|
||
initial_warnings=$("$WP_CLI_CMD" plugin list 2>&1 >/dev/null)
|
||
|
||
if [[ -z "$initial_warnings" ]]; then
|
||
echo "✅ WP-CLI is running smoothly. No warnings detected."
|
||
return 0
|
||
fi
|
||
|
||
echo "⚠️ WP-CLI produced warnings. Investigating the source..."
|
||
echo
|
||
echo "--- Initial Warnings Found ---"
|
||
echo "$initial_warnings"
|
||
echo "----------------------------"
|
||
echo
|
||
|
||
local culprit_found=false
|
||
|
||
# 3. Check theme impact
|
||
echo "Testing for theme conflicts..."
|
||
local warnings_without_theme
|
||
warnings_without_theme=$("$WP_CLI_CMD" plugin list --skip-themes 2>&1 >/dev/null)
|
||
if [[ -z "$warnings_without_theme" ]]; then
|
||
local active_theme
|
||
active_theme=$("$WP_CLI_CMD" theme list --status=active --field=name)
|
||
echo "✅ Problem resolved by skipping themes. The active theme '$active_theme' is the likely source of the warnings."
|
||
culprit_found=true
|
||
else
|
||
echo "No warnings seem to originate from the theme."
|
||
fi
|
||
|
||
# 4. Check plugin impact
|
||
echo "Testing for plugin conflicts..."
|
||
local active_plugins=()
|
||
while IFS= read -r line; do
|
||
active_plugins+=("$line")
|
||
done < <("$WP_CLI_CMD" plugin list --field=name --status=active)
|
||
|
||
if [[ ${#active_plugins[@]} -eq 0 ]]; then
|
||
echo "ℹ️ No active plugins found to test."
|
||
else
|
||
echo "Comparing output when skipping each of the ${#active_plugins[@]} active plugins..."
|
||
for plugin in "${active_plugins[@]}"; do
|
||
printf " - Testing by skipping '%s'... " "$plugin"
|
||
local warnings_without_plugin
|
||
warnings_without_plugin=$("$WP_CLI_CMD" plugin list --skip-plugins="$plugin" 2>&1 >/dev/null)
|
||
|
||
if [[ -z "$warnings_without_plugin" ]]; then
|
||
printf "FOUND CULPRIT\n"
|
||
echo " ✅ Warnings disappeared when skipping '$plugin'. This plugin is a likely source of the warnings."
|
||
culprit_found=true
|
||
else
|
||
printf "no change\n"
|
||
fi
|
||
done
|
||
fi
|
||
echo
|
||
if ! $culprit_found; then
|
||
echo "ℹ️ Could not isolate a single plugin or theme as the source. The issue might be from a combination of plugins or WordPress core itself."
|
||
fi
|
||
echo "✅ Check complete."
|
||
}
|
||
|
||
# ----------------------------------------------------
|
||
# Creates a zip archive of a specified folder.
|
||
# ----------------------------------------------------
|
||
function run_zip() {
|
||
local target_folder="$1"
|
||
|
||
# --- 1. Validate Input ---
|
||
if [ -z "$target_folder" ]; then
|
||
echo "Error: No folder specified." >&2
|
||
echo "Usage: _do zip \"<folder>\"" >&2
|
||
return 1
|
||
fi
|
||
|
||
if [ ! -d "$target_folder" ]; then
|
||
echo "Error: Folder '$target_folder' not found." >&2
|
||
return 1
|
||
fi
|
||
|
||
if ! command -v realpath &> /dev/null; then
|
||
echo "Error: 'realpath' command is required but not found." >&2
|
||
return 1
|
||
fi
|
||
|
||
# --- 2. Determine Paths and Names ---
|
||
local full_target_path
|
||
full_target_path=$(realpath "$target_folder")
|
||
local parent_dir
|
||
parent_dir=$(dirname "$full_target_path")
|
||
local dir_to_zip
|
||
dir_to_zip=$(basename "$full_target_path")
|
||
local output_zip_file="${dir_to_zip}.zip"
|
||
local output_zip_path="${parent_dir}/${output_zip_file}"
|
||
|
||
# Prevent zipping to the same name if it already exists
|
||
if [ -f "$output_zip_path" ]; then
|
||
echo "Error: A file named '${output_zip_file}' already exists in the target directory." >&2
|
||
return 1
|
||
fi
|
||
|
||
echo "🚀 Creating zip archive for '${dir_to_zip}'..."
|
||
|
||
# --- 3. Create Zip Archive ---
|
||
# Change to the parent directory to ensure clean paths inside the zip
|
||
local original_dir
|
||
original_dir=$(pwd)
|
||
cd "$parent_dir" || { echo "Error: Could not change to directory '$parent_dir'." >&2; return 1; }
|
||
|
||
# Create the zip file, excluding common unnecessary files
|
||
if ! zip -r "$output_zip_file" "$dir_to_zip" -x "*.git*" "*.DS_Store*" "*node_modules*" > /dev/null; then
|
||
echo "Error: Failed to create zip archive." >&2
|
||
cd "$original_dir"
|
||
return 1
|
||
fi
|
||
|
||
# Return to the original directory
|
||
cd "$original_dir"
|
||
|
||
# --- 4. Final Report ---
|
||
local file_size
|
||
file_size=$(du -h "$output_zip_path" | cut -f1 | xargs)
|
||
local final_output_path="$output_zip_path"
|
||
|
||
# --- WordPress URL Logic ---
|
||
local zip_url=""
|
||
# Silently check if WP-CLI is available and we're in a WordPress installation.
|
||
# This check works by traversing up from the current directory.
|
||
if setup_wp_cli &>/dev/null && "$WP_CLI_CMD" core is-installed --quiet 2>/dev/null; then
|
||
local wp_home
|
||
wp_home=$("$WP_CLI_CMD" option get home --skip-plugins --skip-themes 2>/dev/null)
|
||
|
||
if [ -n "$wp_home" ]; then
|
||
local wp_root_path
|
||
# Use `wp config path` to reliably find the WP root.
|
||
wp_root_path=$("$WP_CLI_CMD" config path --quiet 2>/dev/null)
|
||
|
||
if [ -n "$wp_root_path" ] && [ -f "$wp_root_path" ]; then
|
||
wp_root_path=$(dirname "$wp_root_path")
|
||
|
||
# The zip file is created in `parent_dir`. We need its path relative to the WP root.
|
||
local relative_zip_dir_path
|
||
relative_zip_dir_path=${parent_dir#"$wp_root_path"}
|
||
|
||
# Construct the final URL
|
||
zip_url="${wp_home%/}${relative_zip_dir_path}/${output_zip_file}"
|
||
fi
|
||
fi
|
||
fi
|
||
# --- End WordPress URL Logic ---
|
||
|
||
echo "✅ Zip archive created successfully."
|
||
if [ -n "$zip_url" ]; then
|
||
echo " Link: $zip_url ($file_size)"
|
||
else
|
||
echo " File: $final_output_path ($file_size)"
|
||
fi
|
||
}
|
||
|
||
# Pass all script arguments to the main function.
|
||
main "$@"
|
