wfu-migrate 0.1.1

package/dist/lib/migration-engine.js

@@ -0,0 +1,1175 @@
+/**
+ * Migration Engine
+ *
+ * Implements the core migration workflow (Steps 3-9):
+ * - Step 3: Import to migration database
+ * - Step 4: WP-CLI search-replace via Docker
+ * - Step 5: Export transformed tables
+ * - Step 6: Backup target tables
+ * - Step 7: Import to target
+ * - Step 8: S3 file sync
+ * - Step 9: Archive and cleanup
+ */
+import { spawn } from 'child_process';
+import { existsSync, writeFileSync, mkdirSync, statSync } from 'fs';
+import { rm } from 'fs/promises';
+import { join } from 'path';
+import { mysqlImport, mysqldump, cleanupSiteTables, discoverSiteTables, discoverNetworkTables, countSiteTables, } from './database.js';
+import { getUrlReplacementPatterns, parseCustomDomain } from './url-patterns.js';
+import { compressFile } from './compress.js';
+import { s3Sync, s3Upload } from './s3.js';
+import { logger } from './logger.js';
+import { SITE_TABLES, getSiteTablePrefix } from './wp-tables.js';
+/**
+ * Network tables to skip during search-replace (shared across all sites).
+ * These are WordPress multisite network tables that should not be modified
+ * during individual site migrations.
+ */
+const SKIP_NETWORK_TABLES = [
+    'wp_blogmeta', 'wp_blogs', 'wp_registration_log', 'wp_signups',
+    'wp_site', 'wp_sitemeta', 'wp_usermeta', 'wp_users',
+];
+/**
+ * Get the skip tables list for WP-CLI search-replace.
+ * WP-CLI uses --all-tables --skip-tables= approach, not a hardcoded include list.
+ *
+ * For homepage (site 1): Only skip network tables
+ * For subsites: Skip network tables AND main site tables (wp_posts, etc.)
+ *   to prevent accidentally modifying the main site's data
+ */
+function getSkipTables(homepage) {
+    if (homepage) {
+        return [...SKIP_NETWORK_TABLES];
+    }
+    const mainSiteTables = SITE_TABLES.map(table => `${getSiteTablePrefix(1)}${table}`);
+    return [...SKIP_NETWORK_TABLES, ...mainSiteTables];
+}
+/**
+ * Download WordPress core files using WP-CLI in Docker.
+ * Required for search-replace to work properly.
+ */
+async function downloadWordPressCore(wpDir, verbose) {
+    return new Promise((resolve) => {
+        const uid = process.getuid?.() ?? 1000;
+        const gid = process.getgid?.() ?? 1000;
+        const cacheDir = join(wpDir, '.wp-cli-cache');
+        if (!existsSync(cacheDir)) {
+            mkdirSync(cacheDir, { recursive: true });
+        }
+        const args = [
+            'run',
+            '--rm',
+            '-v', `${wpDir}:/var/www/html`,
+            '-v', `${cacheDir}:/var/www/.wp-cli/cache`,
+            '-e', 'WP_CLI_CACHE_DIR=/var/www/.wp-cli/cache',
+            '-u', `${uid}:${gid}`,
+            'wordpress:cli',
+            'wp', 'core', 'download',
+            '--path=/var/www/html',
+            '--skip-content',
+        ];
+        if (verbose) {
+            logger.debug('Downloading WordPress core files...');
+        }
+        const proc = spawn('docker', args, { stdio: ['pipe', 'pipe', 'pipe'] });
+        let stderr = '';
+        proc.stderr.on('data', (data) => { stderr += data.toString(); });
+        proc.on('close', (code) => {
+            if (code === 0) {
+                resolve({ success: true });
+            }
+            else {
+                resolve({ success: false, error: stderr || 'Download failed' });
+            }
+        });
+        proc.on('error', (err) => {
+            resolve({ success: false, error: err.message });
+        });
+    });
+}
+/**
+ * Get the Docker-accessible host for a database connection.
+ * On macOS/Windows, localhost must be replaced with host.docker.internal
+ * for containers to reach the host machine.
+ */
+function getDockerDbHost(host) {
+    if (host === 'localhost' || host === '127.0.0.1') {
+        return 'host.docker.internal';
+    }
+    return host;
+}
+/**
+ * Create wp-config.php for WP-CLI to connect to the database.
+ * The table_prefix must match the site being migrated.
+ */
+function createWpConfig(wpDir, dbConfig, siteId) {
+    const tablePrefix = siteId === 1 ? 'wp_' : `wp_${siteId}_`;
+    const dockerHost = getDockerDbHost(dbConfig.host);
+    const wpConfigContent = `<?php
+define('DB_NAME', '${dbConfig.database}');
+define('DB_USER', '${dbConfig.user}');
+define('DB_PASSWORD', '${dbConfig.password}');
+define('DB_HOST', '${dockerHost}:${dbConfig.port}');
+define('DB_CHARSET', 'utf8mb4');
+define('DB_COLLATE', '');
+$table_prefix = '${tablePrefix}';
+define('WP_DEBUG', false);
+if ( ! defined( 'ABSPATH' ) ) {
+    define( 'ABSPATH', __DIR__ . '/' );
+}
+require_once ABSPATH . 'wp-settings.php';
+`;
+    writeFileSync(join(wpDir, 'wp-config.php'), wpConfigContent);
+}
+/**
+ * Execute WP-CLI search-replace via Docker.
+ * This is the critical step that handles serialized PHP data correctly.
+ */
+async function runWpCliSearchReplace(migrationDbConfig, patterns, homepage, siteId, workDir, verbose) {
+    const skipTables = getSkipTables(homepage);
+    const skipTablesArg = skipTables.join(',');
+    let totalReplacements = 0;
+    const wpCacheDir = join(workDir, 'wp-cache');
+    if (!existsSync(wpCacheDir)) {
+        mkdirSync(wpCacheDir, { recursive: true });
+    }
+    logger.debug(`Site ${siteId}: Downloading WordPress core files...`);
+    const downloadResult = await downloadWordPressCore(wpCacheDir, verbose);
+    if (!downloadResult.success) {
+        return {
+            success: false,
+            error: `Failed to download WordPress core: ${downloadResult.error}`,
+            replacements: 0,
+        };
+    }
+    logger.debug(`Site ${siteId}: WordPress core ready, starting search-replace...`);
+    createWpConfig(wpCacheDir, migrationDbConfig, siteId);
+    const totalPatterns = patterns.length;
+    for (let i = 0; i < patterns.length; i++) {
+        const pattern = patterns[i];
+        const patternNum = i + 1;
+        const patternStart = Date.now();
+        logger.debug(`Site ${siteId}: Pattern ${patternNum}/${totalPatterns}: "${pattern.search}" → "${pattern.replace}"`);
+        const result = await new Promise((resolve) => {
+            const args = [
+                'run',
+                '--rm',
+                '--network', 'host',
+                '-v', `${wpCacheDir}:/var/www/html`,
+                'wordpress:cli',
+                'wp', 'search-replace',
+                pattern.search,
+                pattern.replace,
+                '--all-tables',
+                `--skip-tables=${skipTablesArg}`,
+                '--precise',
+                '--skip-columns=guid',
+                '--skip-plugins',
+                '--skip-themes',
+                '--path=/var/www/html',
+            ];
+            if (verbose) {
+                args.push('--verbose');
+            }
+            const proc = spawn('docker', args, { stdio: ['pipe', 'pipe', 'pipe'] });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout.on('data', (data) => {
+                stdout += data.toString();
+                if (verbose) {
+                    const lines = data.toString().split('\n');
+                    for (const line of lines) {
+                        if (filterVerboseOutput(line)) {
+                            logger.debug(line);
+                        }
+                    }
+                }
+            });
+            proc.stderr.on('data', (data) => {
+                stderr += data.toString();
+                if (verbose) {
+                    const lines = data.toString().split('\n');
+                    for (const line of lines) {
+                        if (filterVerboseOutput(line)) {
+                            logger.debug(line);
+                        }
+                    }
+                }
+            });
+            proc.on('close', (code) => {
+                if (code === 0) {
+                    resolve({ success: true, output: stdout });
+                }
+                else {
+                    resolve({ success: false, output: stdout, error: stderr || stdout });
+                }
+            });
+            proc.on('error', (err) => {
+                resolve({ success: false, output: '', error: err.message });
+            });
+        });
+        if (!result.success) {
+            return {
+                success: false,
+                error: `Search-replace failed for pattern "${pattern.search}" → "${pattern.replace}": ${result.error}`,
+                replacements: totalReplacements,
+            };
+        }
+        const match = result.output.match(/Made (\d+) replacements/);
+        const patternReplacements = match ? parseInt(match[1], 10) : 0;
+        totalReplacements += patternReplacements;
+        const patternDuration = Math.round((Date.now() - patternStart) / 1000);
+        logger.debug(`Site ${siteId}: Pattern ${patternNum}/${totalPatterns} complete: ${patternReplacements} replacements in ${patternDuration}s`);
+    }
+    return { success: true, replacements: totalReplacements };
+}
+/**
+ * Run the full migration workflow (Steps 3-9)
+ */
+export async function runMigrationEngine(options) {
+    const steps = [];
+    const { siteId, source, target, config, workDir, homepage, customDomain, skipBackup, skipS3, keepFiles, verbose, siteName, } = options;
+    const sourceExportFile = join(workDir, `source-export-${siteId}.sql`);
+    const transformedExportFile = join(workDir, `transformed-export-${siteId}.sql`);
+    const targetBackupFile = join(workDir, `target-backup-${siteId}.sql`);
+    if (!existsSync(sourceExportFile)) {
+        return {
+            success: false,
+            error: `Source export file not found: ${sourceExportFile}`,
+            steps,
+        };
+    }
+    const step3Start = Date.now();
+    logger.debug(`Site ${siteId}: Step 3 - Importing to migration database...`);
+    logger.debug(`Site ${siteId}: Cleaning up existing tables in migration DB...`);
+    const cleanupResult = await cleanupSiteTables(config.migration, siteId);
+    if (!cleanupResult.success) {
+        steps.push({
+            step: 3,
+            name: 'Import to migration database',
+            success: false,
+            error: `Failed to clean existing tables: ${cleanupResult.error}`,
+            duration: Date.now() - step3Start,
+        });
+        return { success: false, error: steps[0].error, steps };
+    }
+    logger.debug(`Site ${siteId}: Importing source export file...`);
+    const importResult = await mysqlImport(config.migration, sourceExportFile);
+    if (!importResult.success) {
+        steps.push({
+            step: 3,
+            name: 'Import to migration database',
+            success: false,
+            error: `Import failed: ${importResult.error}`,
+            duration: Date.now() - step3Start,
+        });
+        return { success: false, error: steps[0].error, steps };
+    }
+    const tableCount = await countSiteTables(config.migration, siteId);
+    const step3Duration = Math.round((Date.now() - step3Start) / 1000);
+    logger.debug(`Site ${siteId}: Step 3 complete - Imported ${tableCount.count} tables in ${step3Duration}s`);
+    steps.push({
+        step: 3,
+        name: 'Import to migration database',
+        success: true,
+        message: `Imported ${tableCount.count} tables to migration database`,
+        duration: Date.now() - step3Start,
+    });
+    const step4Start = Date.now();
+    logger.debug(`Site ${siteId}: Step 4 - Running WP-CLI search-replace...`);
+    const patterns = getUrlReplacementPatterns(source, target);
+    if (customDomain) {
+        const customPattern = parseCustomDomain(customDomain);
+        if (customPattern) {
+            patterns.push(customPattern);
+        }
+    }
+    logger.debug(`Site ${siteId}: Applying ${patterns.length} URL replacement patterns...`);
+    const searchReplaceResult = await runWpCliSearchReplace(config.migration, patterns, homepage, siteId, workDir, verbose);
+    if (!searchReplaceResult.success) {
+        steps.push({
+            step: 4,
+            name: 'WP-CLI search-replace',
+            success: false,
+            error: searchReplaceResult.error,
+            duration: Date.now() - step4Start,
+        });
+        return { success: false, error: steps[steps.length - 1].error, steps };
+    }
+    const step4Duration = Math.round((Date.now() - step4Start) / 1000);
+    logger.debug(`Site ${siteId}: Step 4 complete - ${searchReplaceResult.replacements} total replacements in ${step4Duration}s`);
+    steps.push({
+        step: 4,
+        name: 'WP-CLI search-replace',
+        success: true,
+        message: `Applied ${patterns.length} replacement patterns (${searchReplaceResult.replacements} total replacements)`,
+        duration: Date.now() - step4Start,
+    });
+    const step5Start = Date.now();
+    logger.debug(`Site ${siteId}: Step 5 - Exporting transformed tables...`);
+    const transformedTables = await discoverSiteTables(config.migration, siteId);
+    if (!transformedTables.success) {
+        steps.push({
+            step: 5,
+            name: 'Export transformed tables',
+            success: false,
+            error: `Failed to discover tables: ${transformedTables.error}`,
+            duration: Date.now() - step5Start,
+        });
+        return { success: false, error: steps[steps.length - 1].error, steps };
+    }
+    logger.debug(`Site ${siteId}: Exporting ${transformedTables.tables.length} tables...`);
+    const exportTransformedResult = await mysqldump(config.migration, transformedTables.tables, transformedExportFile);
+    if (!exportTransformedResult.success) {
+        steps.push({
+            step: 5,
+            name: 'Export transformed tables',
+            success: false,
+            error: `Export failed: ${exportTransformedResult.error}`,
+            duration: Date.now() - step5Start,
+        });
+        return { success: false, error: steps[steps.length - 1].error, steps };
+    }
+    const step5Duration = Math.round((Date.now() - step5Start) / 1000);
+    logger.debug(`Site ${siteId}: Step 5 complete - Exported ${transformedTables.tables.length} tables in ${step5Duration}s`);
+    steps.push({
+        step: 5,
+        name: 'Export transformed tables',
+        success: true,
+        message: `Exported ${transformedTables.tables.length} transformed tables`,
+        duration: Date.now() - step5Start,
+    });
+    const step6Start = Date.now();
+    logger.debug(`Site ${siteId}: Step 6 - Backing up target tables...`);
+    if (skipBackup) {
+        logger.debug(`Site ${siteId}: Step 6 skipped (--skip-backup)`);
+        steps.push({
+            step: 6,
+            name: 'Backup target tables',
+            success: true,
+            message: 'Skipped (--skip-backup)',
+            duration: 0,
+        });
+    }
+    else {
+        const targetDbConfig = target === 'local' ? config.environments.local : config.environments[target];
+        const targetTables = await discoverSiteTables(targetDbConfig, siteId);
+        if (targetTables.success && targetTables.tables.length > 0) {
+            logger.debug(`Site ${siteId}: Backing up ${targetTables.tables.length} tables from ${target}...`);
+            const backupResult = await mysqldump(targetDbConfig, targetTables.tables, targetBackupFile);
+            if (!backupResult.success) {
+                steps.push({
+                    step: 6,
+                    name: 'Backup target tables',
+                    success: false,
+                    error: `Backup failed: ${backupResult.error}`,
+                    duration: Date.now() - step6Start,
+                });
+                return { success: false, error: steps[steps.length - 1].error, steps };
+            }
+            const step6Duration = Math.round((Date.now() - step6Start) / 1000);
+            logger.debug(`Site ${siteId}: Step 6 complete - Backed up ${targetTables.tables.length} tables in ${step6Duration}s`);
+            steps.push({
+                step: 6,
+                name: 'Backup target tables',
+                success: true,
+                message: `Backed up ${targetTables.tables.length} tables`,
+                duration: Date.now() - step6Start,
+            });
+        }
+        else {
+            logger.debug(`Site ${siteId}: Step 6 complete - No existing tables to backup`);
+            steps.push({
+                step: 6,
+                name: 'Backup target tables',
+                success: true,
+                message: 'No existing tables to backup',
+                duration: Date.now() - step6Start,
+            });
+        }
+    }
+    const step7Start = Date.now();
+    logger.debug(`Site ${siteId}: Step 7 - Importing to ${target}...`);
+    const targetDbConfig = target === 'local' ? config.environments.local : config.environments[target];
+    logger.debug(`Site ${siteId}: Cleaning up existing tables in ${target}...`);
+    const targetCleanup = await cleanupSiteTables(targetDbConfig, siteId);
+    if (!targetCleanup.success) {
+        logger.debug(`Site ${siteId}: Warning - Failed to clean target tables: ${targetCleanup.error}`);
+    }
+    logger.debug(`Site ${siteId}: Importing transformed data to ${target}...`);
+    const importToTargetResult = await mysqlImport(targetDbConfig, transformedExportFile);
+    if (!importToTargetResult.success) {
+        steps.push({
+            step: 7,
+            name: 'Import to target',
+            success: false,
+            error: `Import to target failed: ${importToTargetResult.error}`,
+            duration: Date.now() - step7Start,
+        });
+        return { success: false, error: steps[steps.length - 1].error, steps };
+    }
+    const targetTableCount = await countSiteTables(targetDbConfig, siteId);
+    const step7Duration = Math.round((Date.now() - step7Start) / 1000);
+    logger.debug(`Site ${siteId}: Step 7 complete - Imported ${targetTableCount.count} tables in ${step7Duration}s`);
+    steps.push({
+        step: 7,
+        name: 'Import to target',
+        success: true,
+        message: `Imported ${targetTableCount.count} tables to ${target}`,
+        duration: Date.now() - step7Start,
+    });
+    const step8Start = Date.now();
+    logger.debug(`Site ${siteId}: Step 8 - Syncing S3 files...`);
+    if (skipS3) {
+        logger.debug(`Site ${siteId}: Step 8 skipped (--skip-s3)`);
+        steps.push({
+            step: 8,
+            name: 'S3 file sync',
+            success: true,
+            message: 'Skipped (--skip-s3)',
+            duration: 0,
+        });
+    }
+    else if (config.s3) {
+        const sourceBucket = `wfu-cer-wordpress-${source}-us-east-1`;
+        const targetBucket = `wfu-cer-wordpress-${target === 'local' ? 'dev' : target}-us-east-1`;
+        const sourcePath = `s3://${sourceBucket}/sites/${siteId}/`;
+        const targetPath = `s3://${targetBucket}/sites/${siteId}/`;
+        logger.debug(`Site ${siteId}: Syncing files from ${sourcePath} to ${targetPath}...`);
+        const s3Result = await s3Sync(config.s3, sourcePath, targetPath);
+        if (!s3Result.success) {
+            steps.push({
+                step: 8,
+                name: 'S3 file sync',
+                success: false,
+                error: `S3 sync failed: ${s3Result.error}`,
+                duration: Date.now() - step8Start,
+            });
+        }
+        else {
+            const fileCount = s3Result.filesTransferred ?? 0;
+            const fileMsg = fileCount === 0 ? 'No files to sync' : `${fileCount} files synced`;
+            const step8Duration = Math.round((Date.now() - step8Start) / 1000);
+            logger.debug(`Site ${siteId}: Step 8 complete - ${fileMsg} in ${step8Duration}s`);
+            steps.push({
+                step: 8,
+                name: 'S3 file sync',
+                success: true,
+                message: `${fileMsg} from ${source} to ${target}`,
+                duration: Date.now() - step8Start,
+            });
+        }
+    }
+    else {
+        logger.debug(`Site ${siteId}: Step 8 skipped (S3 not configured)`);
+        steps.push({
+            step: 8,
+            name: 'S3 file sync',
+            success: true,
+            message: 'Skipped (S3 not configured)',
+            duration: 0,
+        });
+    }
+    const step9Start = Date.now();
+    logger.debug(`Site ${siteId}: Step 9 - Archive and cleanup...`);
+    let archiveLocation;
+    let archiveFilesUploaded = 0;
+    if (!skipS3 && config.s3?.bucket) {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const archivePrefix = siteName || 'site';
+        const archivePath = `${archivePrefix}-${siteId}-${source}-to-${target}-${timestamp}`;
+        try {
+            await compressFile(sourceExportFile);
+            await compressFile(transformedExportFile);
+            if (existsSync(targetBackupFile)) {
+                await compressFile(targetBackupFile);
+            }
+            const metadata = {
+                siteId,
+                source,
+                target,
+                timestamp: new Date().toISOString(),
+                tablesCount: tableCount.count,
+                replacementsApplied: searchReplaceResult.replacements,
+                files: [
+                    `source-export-${siteId}.sql.gz`,
+                    `transformed-export-${siteId}.sql.gz`,
+                    existsSync(targetBackupFile + '.gz') ? `target-backup-${siteId}.sql.gz` : null,
+                ].filter(Boolean),
+            };
+            const metadataPath = join(workDir, 'metadata.json');
+            writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+            const uploadFiles = [
+                { local: sourceExportFile + '.gz', key: `${archivePath}/source-export-${siteId}.sql.gz` },
+                { local: transformedExportFile + '.gz', key: `${archivePath}/transformed-export-${siteId}.sql.gz` },
+                { local: metadataPath, key: `${archivePath}/metadata.json` },
+            ];
+            if (existsSync(targetBackupFile + '.gz')) {
+                uploadFiles.push({ local: targetBackupFile + '.gz', key: `${archivePath}/target-backup-${siteId}.sql.gz` });
+            }
+            for (const file of uploadFiles) {
+                if (existsSync(file.local)) {
+                    const uploadResult = await s3Upload(config.s3, file.local, file.key);
+                    if (uploadResult.success) {
+                        archiveFilesUploaded++;
+                        logger.debug(`Uploaded: ${file.key}`);
+                    }
+                    else {
+                        logger.debug(`Upload failed: ${file.key} - ${uploadResult.error}`);
+                    }
+                }
+            }
+            archiveLocation = `s3://${config.s3.bucket}/${config.s3.prefix}/${archivePath}/`;
+            logger.debug(`Archive complete: ${archiveFilesUploaded}/${uploadFiles.length} files uploaded to ${archiveLocation}`);
+        }
+        catch (err) {
+            logger.debug(`Archive upload failed: ${err}`);
+        }
+    }
+    logger.debug(`Site ${siteId}: Cleaning up migration database tables...`);
+    await cleanupSiteTables(config.migration, siteId);
+    if (!keepFiles) {
+        logger.debug(`Site ${siteId}: Removing temporary work directory...`);
+        try {
+            await rm(workDir, { recursive: true, force: true });
+        }
+        catch (err) {
+            logger.debug(`Site ${siteId}: Cleanup warning: ${err}`);
+        }
+    }
+    const step9Duration = Math.round((Date.now() - step9Start) / 1000);
+    const archiveMsg = archiveLocation
+        ? `${archiveFilesUploaded} files archived to ${archiveLocation}`
+        : 'Cleanup complete';
+    logger.debug(`Site ${siteId}: Step 9 complete - ${archiveMsg} in ${step9Duration}s`);
+    steps.push({
+        step: 9,
+        name: 'Archive and cleanup',
+        success: true,
+        message: archiveMsg,
+        duration: Date.now() - step9Start,
+    });
+    return {
+        success: true,
+        steps,
+        archiveLocation,
+        tablesProcessed: tableCount.count,
+        replacementsApplied: searchReplaceResult.replacements,
+    };
+}
+/**
+ * Migrate network tables from source to target environment.
+ * Network tables are shared across all sites in a WordPress multisite:
+ * - wp_blogmeta, wp_blogs, wp_registration_log, wp_signups
+ * - wp_site, wp_sitemeta, wp_usermeta, wp_users
+ */
+export async function migrateNetworkTables(options) {
+    const { source, target, config, workDir, skipBackup, verbose } = options;
+    if (!existsSync(workDir)) {
+        mkdirSync(workDir, { recursive: true });
+    }
+    const sourceDbConfig = config.environments[source];
+    const targetDbConfig = target === 'local' ? config.environments.local : config.environments[target];
+    logger.debug(`Discovering network tables from ${source}...`);
+    const discoveryResult = await discoverNetworkTables(sourceDbConfig);
+    if (!discoveryResult.success) {
+        return { success: false, error: `Table discovery failed: ${discoveryResult.error}`, tablesProcessed: 0 };
+    }
+    const networkTableNames = discoveryResult.tables;
+    logger.debug(`Found ${networkTableNames.length} network tables: ${networkTableNames.slice(0, 5).join(', ')}${networkTableNames.length > 5 ? '...' : ''}`);
+    logger.debug(`Exporting network tables from ${source}...`);
+    const exportFile = join(workDir, `network-tables-${source}.sql`);
+    const exportResult = await mysqldump(sourceDbConfig, networkTableNames, exportFile);
+    if (!exportResult.success) {
+        return { success: false, error: `Export failed: ${exportResult.error}`, tablesProcessed: 0 };
+    }
+    logger.debug('Cleaning up migration database...');
+    const cleanupResult = await cleanupAllMigrationDbTables(config.migration);
+    if (!cleanupResult.success) {
+        logger.debug(`Warning: cleanup failed: ${cleanupResult.error}`);
+    }
+    else if (cleanupResult.tablesDropped && cleanupResult.tablesDropped > 0) {
+        logger.debug(`Dropped ${cleanupResult.tablesDropped} leftover tables from migration database`);
+    }
+    logger.debug('Importing network tables to migration database...');
+    const importToMigrationResult = await mysqlImport(config.migration, exportFile);
+    if (!importToMigrationResult.success) {
+        return { success: false, error: `Import to migration DB failed: ${importToMigrationResult.error}`, tablesProcessed: 0 };
+    }
+    logger.debug('Running search-replace on network tables...');
+    const patterns = getUrlReplacementPatterns(source, target);
+    const searchReplaceResult = await runNetworkTableSearchReplace(config.migration, patterns, networkTableNames, workDir, verbose);
+    if (!searchReplaceResult.success) {
+        return { success: false, error: `Search-replace failed: ${searchReplaceResult.error}`, tablesProcessed: 0 };
+    }
+    const transformedExportFile = join(workDir, `network-tables-transformed.sql`);
+    logger.debug('Exporting transformed network tables...');
+    const transformedExportResult = await mysqldump(config.migration, networkTableNames, transformedExportFile);
+    if (!transformedExportResult.success) {
+        return { success: false, error: `Export transformed failed: ${transformedExportResult.error}`, tablesProcessed: 0 };
+    }
+    let backupPath;
+    if (!skipBackup) {
+        logger.debug('Backing up target network tables...');
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        backupPath = join(workDir, `network-tables-backup-${target}-${timestamp}.sql`);
+        const backupResult = await mysqldump(targetDbConfig, networkTableNames, backupPath);
+        if (backupResult.success && existsSync(backupPath)) {
+            const stats = statSync(backupPath);
+            if (stats.size === 0) {
+                logger.debug('Warning: Backup file is empty');
+            }
+            else {
+                logger.debug(`Backup created: ${backupPath} (${stats.size} bytes)`);
+            }
+        }
+    }
+    logger.debug(`Importing network tables to ${target}...`);
+    const targetCleanup = await cleanupNetworkTables(targetDbConfig, networkTableNames);
+    if (!targetCleanup.success) {
+        logger.debug(`Warning: target cleanup failed: ${targetCleanup.error}`);
+    }
+    const importToTargetResult = await mysqlImport(targetDbConfig, transformedExportFile);
+    if (!importToTargetResult.success) {
+        return { success: false, error: `Import to target failed: ${importToTargetResult.error}`, tablesProcessed: 0 };
+    }
+    const verifyResult = await verifyNetworkTablesImport(targetDbConfig, networkTableNames);
+    if (!verifyResult.success) {
+        return { success: false, error: `Verification failed: ${verifyResult.error}`, tablesProcessed: networkTableNames.length };
+    }
+    await cleanupNetworkTables(config.migration, networkTableNames);
+    return {
+        success: true,
+        tablesProcessed: networkTableNames.length,
+        replacementsApplied: searchReplaceResult.replacements,
+        backupPath,
+    };
+}
+async function cleanupNetworkTables(dbConfig, tables) {
+    return new Promise((resolve) => {
+        const dropStatements = tables.map(t => `DROP TABLE IF EXISTS ${t}`).join('; ');
+        const args = [
+            '-h', dbConfig.host,
+            '-P', String(dbConfig.port),
+            '-u', dbConfig.user,
+            `-p${dbConfig.password}`,
+            dbConfig.database,
+            '-e', dropStatements,
+        ];
+        const proc = spawn('mysql', args, { stdio: ['pipe', 'pipe', 'pipe'] });
+        let stderr = '';
+        proc.stderr.on('data', (data) => { stderr += data.toString(); });
+        proc.on('close', (code) => {
+            if (code !== 0 && stderr) {
+                resolve({ success: false, error: stderr.trim() });
+            }
+            else {
+                resolve({ success: true });
+            }
+        });
+        proc.on('error', () => {
+            resolve({ success: true });
+        });
+    });
+}
+/**
+ * Clean up ALL tables in the migration database.
+ * This ensures no leftover tables from previous migrations interfere with search-replace.
+ */
+async function cleanupAllMigrationDbTables(dbConfig) {
+    return new Promise((resolve) => {
+        const query = `SELECT table_name FROM information_schema.tables WHERE table_schema = '${dbConfig.database}' AND table_name LIKE 'wp\\_%'`;
+        const args = [
+            '-h', dbConfig.host,
+            '-P', String(dbConfig.port),
+            '-u', dbConfig.user,
+            `-p${dbConfig.password}`,
+            '-N',
+            '-e', query,
+        ];
+        const proc = spawn('mysql', args, { stdio: ['pipe', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout.on('data', (data) => { stdout += data.toString(); });
+        proc.stderr.on('data', (data) => { stderr += data.toString(); });
+        proc.on('close', async (code) => {
+            if (code !== 0) {
+                resolve({ success: false, error: stderr.trim() || 'Failed to list tables' });
+                return;
+            }
+            const tables = stdout.trim().split('\n').filter(Boolean);
+            if (tables.length === 0) {
+                resolve({ success: true, tablesDropped: 0 });
+                return;
+            }
+            const dropResult = await cleanupNetworkTables(dbConfig, tables);
+            if (dropResult.success) {
+                resolve({ success: true, tablesDropped: tables.length });
+            }
+            else {
+                resolve({ success: false, error: dropResult.error });
+            }
+        });
+        proc.on('error', (err) => {
+            resolve({ success: false, error: err.message });
+        });
+    });
+}
+/**
+ * Create a minimal wp_options table for WP-CLI to work.
+ * WordPress requires wp_options to initialize, even for search-replace.
+ */
+async function ensureWpOptionsTable(dbConfig) {
+    const createTableSql = `
+    CREATE TABLE IF NOT EXISTS wp_options (
+      option_id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
+      option_name varchar(191) NOT NULL DEFAULT '',
+      option_value longtext NOT NULL,
+      autoload varchar(20) NOT NULL DEFAULT 'yes',
+      PRIMARY KEY (option_id),
+      UNIQUE KEY option_name (option_name)
+    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+  `;
+    const insertDefaultsSql = `
+    INSERT IGNORE INTO wp_options (option_name, option_value, autoload) VALUES
+    ('siteurl', 'http://localhost', 'yes'),
+    ('home', 'http://localhost', 'yes'),
+    ('blogname', 'Migration Temp', 'yes'),
+    ('admin_email', 'admin@localhost', 'yes');
+  `;
+    return new Promise((resolve) => {
+        const args = [
+            'run', '--rm', '--network', 'host',
+            'mysql:8.0', 'mysql',
+            '-h', dbConfig.host,
+            '-P', String(dbConfig.port),
+            '-u', dbConfig.user,
+            `-p${dbConfig.password}`,
+            dbConfig.database,
+            '-e', createTableSql + insertDefaultsSql,
+        ];
+        const proc = spawn('docker', args, { stdio: ['pipe', 'pipe', 'pipe'] });
+        let stderr = '';
+        proc.stderr.on('data', (data) => { stderr += data.toString(); });
+        proc.on('close', (code) => {
+            if (code === 0) {
+                resolve({ success: true });
+            }
+            else {
+                resolve({ success: false, error: stderr || 'Failed to create wp_options' });
+            }
+        });
+        proc.on('error', (err) => {
+            resolve({ success: false, error: err.message });
+        });
+    });
+}
+async function runNetworkTableSearchReplace(dbConfig, patterns, tables, workDir, verbose) {
+    let totalReplacements = 0;
+    const wpCacheDir = join(workDir, 'wp-cache');
+    if (!existsSync(wpCacheDir)) {
+        mkdirSync(wpCacheDir, { recursive: true });
+    }
+    const downloadResult = await downloadWordPressCore(wpCacheDir, verbose);
+    if (!downloadResult.success) {
+        return {
+            success: false,
+            error: `Failed to download WordPress core: ${downloadResult.error}`,
+        };
+    }
+    createWpConfig(wpCacheDir, dbConfig, 1);
+    const optionsResult = await ensureWpOptionsTable(dbConfig);
+    if (!optionsResult.success) {
+        logger.debug(`Warning: Could not create wp_options: ${optionsResult.error}`);
+    }
+    const totalPatterns = patterns.length;
+    for (let patternIdx = 0; patternIdx < patterns.length; patternIdx++) {
+        const pattern = patterns[patternIdx];
+        const patternNum = patternIdx + 1;
+        const patternStart = Date.now();
+        logger.debug(`Pattern ${patternNum}/${totalPatterns}: "${pattern.search}" → "${pattern.replace}" (${tables.length} tables)`);
+        const args = [
+            'run', '--rm',
+            '--network', 'host',
+            '-v', `${wpCacheDir}:/var/www/html`,
+            'wordpress:cli',
+            'wp', 'search-replace',
+            pattern.search,
+            pattern.replace,
+            '--all-tables',
+            '--precise',
+            '--skip-columns=guid',
+            '--skip-plugins',
+            '--skip-themes',
+            '--path=/var/www/html',
+        ];
+        if (verbose) {
+            args.push('--verbose');
+        }
+        const result = await runDockerCommand(args, verbose);
+        if (!result.success) {
+            return { success: false, error: `Pattern '${pattern.search}' failed: ${result.error}` };
+        }
+        const match = result.output?.match(/Made (\d+) replacements/);
+        const patternReplacements = match ? parseInt(match[1], 10) : 0;
+        totalReplacements += patternReplacements;
+        const patternDuration = Math.round((Date.now() - patternStart) / 1000);
+        logger.debug(`Pattern ${patternNum}/${totalPatterns} complete: ${patternReplacements} replacements in ${patternDuration}s`);
+    }
+    return { success: true, replacements: totalReplacements };
+}
+async function verifyNetworkTablesImport(dbConfig, tables) {
+    const criticalTables = ['wp_users', 'wp_blogs', 'wp_site'].filter(t => tables.includes(t));
+    const tableCountResult = await verifyTableExistence(dbConfig, tables);
+    if (!tableCountResult.success) {
+        return tableCountResult;
+    }
+    const rowCountResult = await verifyRowCounts(dbConfig, tables, criticalTables);
+    return rowCountResult;
+}
+async function verifyTableExistence(dbConfig, tables) {
+    return new Promise((resolve) => {
+        const query = `SELECT COUNT(*) as cnt FROM information_schema.tables WHERE table_schema = '${dbConfig.database}' AND table_name IN (${tables.map(t => `'${t}'`).join(',')})`;
+        const args = [
+            '-h', dbConfig.host,
+            '-P', String(dbConfig.port),
+            '-u', dbConfig.user,
+            `-p${dbConfig.password}`,
+            '-N',
+            '-e', query,
+        ];
+        const proc = spawn('mysql', args, { stdio: ['pipe', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout.on('data', (data) => { stdout += data.toString(); });
+        proc.stderr.on('data', (data) => { stderr += data.toString(); });
+        proc.on('close', (code) => {
+            if (code !== 0) {
+                resolve({ success: false, error: stderr.trim() || 'Table count query failed' });
+                return;
+            }
+            const count = parseInt(stdout.trim(), 10);
+            if (count !== tables.length) {
+                resolve({ success: false, error: `Expected ${tables.length} tables, found ${count}` });
+                return;
+            }
+            resolve({ success: true });
+        });
+        proc.on('error', (err) => {
+            resolve({ success: false, error: err.message });
+        });
+    });
+}
+async function verifyRowCounts(dbConfig, tables, criticalTables) {
+    return new Promise((resolve) => {
+        const queries = tables.map(t => `SELECT '${t}' as tbl, COUNT(*) as cnt FROM ${t}`).join(' UNION ALL ');
+        const args = [
+            '-h', dbConfig.host,
+            '-P', String(dbConfig.port),
+            '-u', dbConfig.user,
+            `-p${dbConfig.password}`,
+            dbConfig.database,
+            '-N',
+            '-e', queries,
+        ];
+        const proc = spawn('mysql', args, { stdio: ['pipe', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout.on('data', (data) => { stdout += data.toString(); });
+        proc.stderr.on('data', (data) => { stderr += data.toString(); });
+        proc.on('close', (code) => {
+            if (code !== 0) {
+                resolve({ success: false, error: stderr.trim() || 'Row count query failed' });
+                return;
+            }
+            const rowCounts = {};
+            const warnings = [];
+            const lines = stdout.trim().split('\n').filter(Boolean);
+            for (const line of lines) {
+                const [table, countStr] = line.split('\t');
+                const count = parseInt(countStr, 10);
+                rowCounts[table] = count;
+                if (criticalTables.includes(table) && count === 0) {
+                    resolve({ success: false, error: `Critical table ${table} has zero rows after import` });
+                    return;
+                }
+                if (count === 0) {
+                    warnings.push(`Table ${table} has zero rows`);
+                }
+            }
+            if (warnings.length > 0) {
+                logger.debug(`Verification warnings: ${warnings.join(', ')}`);
+            }
+            resolve({ success: true, warnings: warnings.length > 0 ? warnings : undefined, rowCounts });
+        });
+        proc.on('error', (err) => {
+            resolve({ success: false, error: err.message });
+        });
+    });
+}
+/**
+ * Filter verbose output to reduce log noise.
+ * Only shows lines that indicate actual work (non-zero replacements).
+ */
+function filterVerboseOutput(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return false;
+    if (trimmed.startsWith('Checking:')) {
+        return false;
+    }
+    if (trimmed.includes('0 replacements')) {
+        return false;
+    }
+    if (trimmed.startsWith('Skipping an uninitialized class')) {
+        return false;
+    }
+    return true;
+}
+async function runDockerCommand(args, verbose) {
+    return new Promise((resolve) => {
+        const proc = spawn('docker', args, { stdio: ['pipe', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout.on('data', (data) => {
+            stdout += data.toString();
+            if (verbose) {
+                const lines = data.toString().split('\n');
+                for (const line of lines) {
+                    if (filterVerboseOutput(line)) {
+                        logger.debug(line);
+                    }
+                }
+            }
+        });
+        proc.stderr.on('data', (data) => {
+            stderr += data.toString();
+            if (verbose) {
+                const lines = data.toString().split('\n');
+                for (const line of lines) {
+                    if (filterVerboseOutput(line)) {
+                        logger.debug(line);
+                    }
+                }
+            }
+        });
+        proc.on('close', (code) => {
+            if (code !== 0) {
+                resolve({ success: false, error: stderr.trim() || stdout.trim() });
+            }
+            else {
+                resolve({ success: true, output: stdout });
+            }
+        });
+        proc.on('error', (err) => {
+            resolve({ success: false, error: err.message });
+        });
+    });
+}
+/**
+ * Process sites in batches.
+ * Chunks sites into batches by batchSize and processes each batch.
+ * In sequential mode (default): processes sites one at a time.
+ * In parallel mode: processes sites concurrently within each batch.
+ */
+export async function processSiteBatch(siteIds, options) {
+    const { source, target, config, workDir, batchSize, parallel, concurrency, skipBackup, skipS3, keepFiles, verbose, timeout, maxRetries, onSiteStart, onSiteComplete, onBatchStart, onBatchComplete, onRetry, onStateChange, } = options;
+    const { splitIntoBatches, runWithConcurrency, createSiteTasks } = await import('./parallel.js');
+    const { withRetry, DEFAULT_INITIAL_DELAY_MS, DEFAULT_MAX_DELAY_MS, DEFAULT_BACKOFF_MULTIPLIER } = await import('./retry.js');
+    const batches = splitIntoBatches(siteIds, batchSize);
+    const siteResults = [];
+    let successCount = 0;
+    let failureCount = 0;
+    const migrateSiteOnce = async (siteId) => {
+        const siteWorkDir = join(workDir, `site-${siteId}`);
+        if (!existsSync(siteWorkDir)) {
+            mkdirSync(siteWorkDir, { recursive: true });
+        }
+        const sourceExportFile = join(siteWorkDir, `source-export-${siteId}.sql`);
+        const sourceDbConfig = config.environments[source];
+        const tables = await discoverSiteTables(sourceDbConfig, siteId);
+        if (!tables.success) {
+            throw new Error(`Table discovery failed: ${tables.error}`);
+        }
+        const exportResult = await mysqldump(sourceDbConfig, tables.tables, sourceExportFile);
+        if (!exportResult.success) {
+            throw new Error(`Export failed: ${exportResult.error}`);
+        }
+        const result = await runMigrationEngine({
+            siteId,
+            source,
+            target,
+            config,
+            workDir: siteWorkDir,
+            homepage: siteId === 1,
+            skipBackup,
+            skipS3,
+            keepFiles,
+            verbose,
+            timeout,
+        });
+        if (!result.success) {
+            throw new Error(result.error || 'Migration failed');
+        }
+        return result;
+    };
+    const migrateSiteWithRetry = async (siteId) => {
+        if (onSiteStart)
+            onSiteStart(siteId);
+        if (onStateChange)
+            onStateChange(siteId, 'in_progress');
+        const retryResult = await withRetry(() => migrateSiteOnce(siteId), {
+            maxRetries,
+            initialDelayMs: DEFAULT_INITIAL_DELAY_MS,
+            maxDelayMs: DEFAULT_MAX_DELAY_MS,
+            backoffMultiplier: DEFAULT_BACKOFF_MULTIPLIER,
+            onRetry: (attempt, error, delay) => {
+                if (onRetry) {
+                    onRetry(siteId, attempt, maxRetries, delay, error.message);
+                }
+                logger.debug(`Site ${siteId}: Retry ${attempt}/${maxRetries} in ${delay}ms: ${error.message}`);
+            },
+        });
+        if (retryResult.success && retryResult.value) {
+            if (onStateChange)
+                onStateChange(siteId, 'completed');
+            return { result: retryResult.value, attempts: retryResult.attempts, errors: retryResult.errors };
+        }
+        const errorMsg = retryResult.errors[retryResult.errors.length - 1] || 'Unknown error';
+        if (onStateChange)
+            onStateChange(siteId, 'failed', errorMsg);
+        return {
+            result: { success: false, error: errorMsg, steps: [] },
+            attempts: retryResult.attempts,
+            errors: retryResult.errors,
+        };
+    };
+    for (let batchIdx = 0; batchIdx < batches.length; batchIdx++) {
+        const batch = batches[batchIdx];
+        if (onBatchStart)
+            onBatchStart(batchIdx, batch.items.length);
+        let batchSuccesses = 0;
+        let batchFailures = 0;
+        if (parallel) {
+            const tasks = createSiteTasks(batch.items, async (siteId) => {
+                const { result, attempts } = await migrateSiteWithRetry(siteId);
+                return { ...result, attempts };
+            });
+            await runWithConcurrency(tasks, concurrency, (result) => {
+                const wasSuccess = Boolean(result.success && result.result?.success);
+                const attempts = result.result?.attempts ?? 1;
+                siteResults.push({
+                    siteId: result.id,
+                    success: wasSuccess,
+                    error: result.success ? result.result?.error : result.error?.message,
+                    attempts,
+                });
+                if (wasSuccess) {
+                    successCount++;
+                    batchSuccesses++;
+                }
+                else {
+                    failureCount++;
+                    batchFailures++;
+                }
+                if (onSiteComplete) {
+                    onSiteComplete(result.id, wasSuccess, result.success ? result.result?.error : result.error?.message, attempts);
+                }
+            });
+        }
+        else {
+            for (const siteId of batch.items) {
+                try {
+                    const { result, attempts } = await migrateSiteWithRetry(siteId);
+                    const wasSuccess = result?.success ?? false;
+                    siteResults.push({ siteId, success: wasSuccess, error: result?.error, attempts });
+                    if (wasSuccess) {
+                        successCount++;
+                        batchSuccesses++;
+                    }
+                    else {
+                        failureCount++;
+                        batchFailures++;
+                    }
+                    if (onSiteComplete)
+                        onSiteComplete(siteId, wasSuccess, result?.error, attempts);
+                }
+                catch (err) {
+                    const error = err instanceof Error ? err.message : String(err);
+                    siteResults.push({ siteId, success: false, error, attempts: 1 });
+                    failureCount++;
+                    batchFailures++;
+                    if (onStateChange)
+                        onStateChange(siteId, 'failed', error);
+                    if (onSiteComplete)
+                        onSiteComplete(siteId, false, error, 1);
+                }
+            }
+        }
+        if (onBatchComplete)
+            onBatchComplete(batchIdx, batchSuccesses, batchFailures);
+    }
+    return {
+        success: failureCount === 0,
+        totalSites: siteIds.length,
+        successCount,
+        failureCount,
+        siteResults,
+    };
+}
+/**
+ * Format a summary report after batch processing completes.
+ * Returns structured lines that can be rendered with chalk or other formatters.
+ */
+export function formatBatchSummary(options) {
+    const { result, startTime, migrationId } = options;
+    const lines = [];
+    const elapsedMs = Date.now() - startTime;
+    const elapsedSec = Math.round(elapsedMs / 1000);
+    const minutes = Math.floor(elapsedSec / 60);
+    const seconds = elapsedSec % 60;
+    const elapsedStr = minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+    lines.push({ type: 'header', text: 'Migration Summary' });
+    lines.push({ type: 'header', text: '=================' });
+    lines.push({ type: 'info', text: `Total sites: ${result.totalSites}` });
+    lines.push({ type: 'success', text: `Successful: ${result.successCount}` });
+    lines.push({ type: 'failure', text: `Failed: ${result.failureCount}` });
+    lines.push({ type: 'info', text: `Duration: ${elapsedStr}` });
+    if (result.failureCount > 0) {
+        lines.push({ type: 'header', text: '' });
+        lines.push({ type: 'header', text: 'Failed Sites:' });
+        const failedSites = result.siteResults.filter(r => !r.success);
+        for (const site of failedSites) {
+            const attemptsStr = site.attempts > 1 ? ` (${site.attempts} attempts)` : '';
+            const errorStr = site.error ? `: ${site.error}` : '';
+            lines.push({ type: 'failure', text: `  Site ${site.siteId}${attemptsStr}${errorStr}` });
+        }
+        if (migrationId) {
+            lines.push({ type: 'header', text: '' });
+            lines.push({ type: 'warning', text: 'To resume this migration:' });
+            lines.push({ type: 'resume', text: `  wfu-migrate env-migrate --resume ${migrationId}` });
+            lines.push({ type: 'info', text: '' });
+            lines.push({ type: 'info', text: 'To retry only failed sites:' });
+            lines.push({ type: 'resume', text: `  wfu-migrate env-migrate --resume ${migrationId} --retry-failed` });
+            lines.push({ type: 'info', text: '' });
+            lines.push({ type: 'info', text: 'To skip failed sites and continue:' });
+            lines.push({ type: 'resume', text: `  wfu-migrate env-migrate --resume ${migrationId} --skip-failed` });
+        }
+    }
+    else {
+        lines.push({ type: 'header', text: '' });
+        const avgMs = result.totalSites > 0 ? Math.round(elapsedMs / result.totalSites) : 0;
+        const avgSec = Math.round(avgMs / 1000);
+        lines.push({ type: 'success', text: `All sites migrated successfully!` });
+        lines.push({ type: 'info', text: `Average time per site: ${avgSec}s` });
+    }
+    return lines;
+}
+/**
+ * Get a plain text version of the batch summary (for logging).
+ */
+export function getBatchSummaryText(options) {
+    const lines = formatBatchSummary(options);
+    return lines.map(l => l.text).join('\n');
+}
+//# sourceMappingURL=migration-engine.js.map