Context Navigation

← Previous Changeset
Next Changeset →

Changeset 3445801

Timestamp:

01/23/2026 08:10:58 PM (7 weeks ago)

Author:

siteskite

Message:

Update version to 1.2.2

Location:

siteskite/trunk

Files:

: 8 edited

includes/API/FallbackAPI.php (modified) (4 diffs)
includes/Backup/BackupManager.php (modified) (35 diffs)
includes/Cron/ExternalCronManager.php (modified) (2 diffs)
includes/Cron/HybridCronManager.php (modified) (2 diffs)
includes/Restore/RestoreManager.php (modified) (1 diff)
languages/siteskite.pot (modified) (1 diff)
readme.txt (modified) (3 diffs)
siteskite-link.php (modified) (2 diffs)

Legend:

: Unmodified
: Added
: Removed

siteskite/trunk/includes/API/FallbackAPI.php

-                      r3431615
+                      r3445801
+                    }
                 } elseif ($status >= 200 && $status < 300) {
+                    wp_send_json_success($data, $status);
+                    // Send data directly to match wp-json REST API format
+                    // This ensures consistency between REST API and AJAX responses
+                    if (!headers_sent()) {
+                        status_header($status);
+                        header('Content-Type: application/json; charset=utf-8');
+                    }
+                    echo wp_json_encode($data);
+                    exit;
                 } else {
                     wp_send_json_error($data, $status);
 …
         // Merge GET, POST, and JSON body data
+        if (!empty($_GET)) {
+            $params = array_merge($params, $_GET);
+        }
+        if (!empty($_POST)) {
+            $params = array_merge($params, $_POST);
+        // Remove WordPress admin-ajax routing 'action' (siteskite_api) and 'route' from GET/POST
+        // But preserve data 'action' parameter if it's not the routing action
+        $get_params = $_GET ?? [];
+        $post_params = $_POST ?? [];
+        // Only remove the routing action, not data action parameters
+        if (isset($get_params['action']) && $get_params['action'] === self::AJAX_ACTION) {
+            unset($get_params['action']);
+        }
+        if (isset($post_params['action']) && $post_params['action'] === self::AJAX_ACTION) {
+            unset($post_params['action']);
+        }
+        unset($get_params['route'], $post_params['route']);
+        if (!empty($get_params)) {
+            $params = array_merge($params, $get_params);
+        }
+        if (!empty($post_params)) {
+            $params = array_merge($params, $post_params);
+        }
         // Handle JSON body (use pre-parsed data if provided)
+        // Only remove 'route' from JSON body, keep 'action' as it's actual data
+        // JSON body parameters take precedence over GET/POST to ensure data integrity
         if (is_array($json_data)) {
             $params = array_merge($params, $json_data);
+        }
         // Remove action and route from params (they're routing params, not data)
         unset($params['action'], $params['route']);
+            $json_params = $json_data;
+            unset($json_params['route']); // Remove route, but keep action
+            // Merge JSON params last so they override any GET/POST params with same keys
+            $params = array_merge($params, $json_params);
+        }
         // Set all parameters
+        // Preserve original value types (don't convert integers to strings prematurely)
         foreach ($params as $key => $value) {
             $request->set_param($key, $value);
 …
         // Also check for X-SiteSkite-Key in various formats
+        // Priority: HTTP header > JSON body > $_REQUEST parameter > request params (after merge)
+        $api_key = null;
         if (isset($headers['X-Siteskite-Key'])) {
+            $request->add_header('X-SiteSkite-Key', $headers['X-Siteskite-Key']);
+            $api_key = $headers['X-Siteskite-Key'];
+        } elseif (is_array($json_data) && isset($json_data['api_key'])) {
+            $api_key = sanitize_text_field(wp_unslash($json_data['api_key']));
         } elseif (isset($_REQUEST['api_key'])) {
+            $request->add_header('X-SiteSkite-Key', sanitize_text_field(wp_unslash($_REQUEST['api_key'])));
+            $api_key = sanitize_text_field(wp_unslash($_REQUEST['api_key']));
+        } elseif (isset($params['api_key'])) {
+            // Check params after merge (in case it was in JSON body)
+            $api_key = is_string($params['api_key']) ? $params['api_key'] : sanitize_text_field(wp_unslash($params['api_key']));
+        }
+        if ($api_key) {
+            $request->add_header('X-SiteSkite-Key', $api_key);
+        }
 …
             '/get-users' => [$this->wp_canvas_controller, 'get_all_users'],
             '/get-user' => [$this->wp_canvas_controller, 'get_single_user_details_by_id'],
+            '/get-error-log' => [$this->wp_canvas_controller, 'get_wp_error_logs'],
+            '/get-error-log' => function($req) {
+                return $this->wp_canvas_controller->get_wp_error_logs();
+            },
+            '/get-custom-error-log' => [$this->wp_canvas_controller, 'get_custom_error_log'],
+            '/get-debug-log' => function($req) {
+                return $this->wp_canvas_controller->get_wp_debug_logs();
+            },
+            '/delete-error-log' => function($req) {
+                return $this->wp_canvas_controller->delete_wp_error_logs();
+            },
+            '/delete-debug-log' => function($req) {
+                return $this->wp_canvas_controller->delete_wp_debug_logs();
+            },
+            '/delete-custom-error-log' => [$this->wp_canvas_controller, 'delete_custom_error_log'],
             '/count-wp-updates' => [$this->wp_canvas_controller, 'laravel_api_get_update_counts'],
             '/logs' => [$this->wp_canvas_controller, 'get_wp_logs'],

siteskite/trunk/includes/Backup/BackupManager.php

-                      r3445137
+                      r3445801
         ];
+        // Expose database-specific progress details for both classic and incremental backups.
+        // This allows the progress endpoint/UI to show real progress for large DBs (tables/bytes/chunks).
+        $db_total_bytes = isset($backup_info['db_total_bytes']) ? (int)$backup_info['db_total_bytes'] : null;
+        $db_bytes_processed = isset($backup_info['db_bytes_processed']) ? (int)$backup_info['db_bytes_processed'] : null;
+        $db_chunks_processed = isset($backup_info['db_chunks_processed']) ? (int)$backup_info['db_chunks_processed'] : null;
+        $db_chunks_total_estimate = isset($backup_info['db_chunks_total_estimate']) ? (int)$backup_info['db_chunks_total_estimate'] : null;
+        $db_new_chunks_count = isset($backup_info['db_new_chunks_count']) ? (int)$backup_info['db_new_chunks_count'] : null;
+        $db_reused_chunks_count = isset($backup_info['db_reused_chunks_count']) ? (int)$backup_info['db_reused_chunks_count'] : null;
+        $db_tables_processed = isset($backup_info['db_tables_processed']) ? (int)$backup_info['db_tables_processed'] : null;
+        $db_total_tables = isset($backup_info['db_total_tables']) ? (int)$backup_info['db_total_tables'] : null;
+        $db_current_table = $backup_info['db_current_table'] ?? null;
+        $db_progress_percent_bytes = null;
+        if ($db_total_bytes !== null && $db_bytes_processed !== null && $db_total_bytes > 0) {
+            $db_progress_percent_bytes = round(($db_bytes_processed / $db_total_bytes) * 100, 2);
+        }
+        $db_progress_percent_tables = null;
+        if ($db_total_tables !== null && $db_tables_processed !== null && $db_total_tables > 0) {
+            $db_progress_percent_tables = round(($db_tables_processed / $db_total_tables) * 100, 2);
+        }
+        if ($db_total_bytes !== null || $db_total_tables !== null || $db_chunks_processed !== null) {
+            $progress_data['database_progress'] = [
+                'total_bytes' => $db_total_bytes,
+                'bytes_processed' => $db_bytes_processed,
+                'progress_percent_bytes' => $db_progress_percent_bytes,
+                'chunks_processed' => $db_chunks_processed,
+                'chunks_total_estimate' => $db_chunks_total_estimate,
+                'new_chunks_count' => $db_new_chunks_count,
+                'reused_chunks_count' => $db_reused_chunks_count,
+                'tables_processed' => $db_tables_processed,
+                'total_tables' => $db_total_tables,
+                'progress_percent_tables' => $db_progress_percent_tables,
+                'current_table' => $db_current_table
+            ];
+        }
         // Add classic backup detailed progress information
         if ($is_classic_backup) {
 …
             $db_backup_complete = $backup_info['db_backup_complete'] ?? false;
             $db_cron_scheduled = $backup_info['cron_job_scheduled_db'] ?? false;
+            $tables_processed = isset($backup_info['db_tables_processed']) ? (int)$backup_info['db_tables_processed'] : null;
+            $total_tables = isset($backup_info['db_total_tables']) ? (int)$backup_info['db_total_tables'] : null;
+            $db_progress_percent = null;
+            if ($tables_processed !== null && $total_tables !== null && $total_tables > 0) {
+                $db_progress_percent = round(($tables_processed / $total_tables) * 100, 2);
+                if ($db_backup_complete) {
+                    $db_progress_percent = 100.0;
+                }
+            }
             $classic_progress['database'] = [
 …
                 'cron_scheduled' => $db_cron_scheduled,
                 'sql_file_size' => isset($backup_info['db_sql_size']) ? $backup_info['db_sql_size'] : null,
+                'tables_processed' => $backup_info['db_tables_processed'] ?? null,
+                'total_tables' => $backup_info['db_total_tables'] ?? null
+                'tables_processed' => $tables_processed,
+                'total_tables' => $total_tables,
+                'progress_percent' => $db_progress_percent,
+                'current_table' => $backup_info['db_current_table'] ?? null,
+                'current_operation' => $backup_info['current_operation'] ?? null
             ];
+        }
 …
                 ]);
+                $zip = new \ZipArchive();
+                $zip_result = $zip->open($zip_file, \ZipArchive::CREATE | \ZipArchive::OVERWRITE);
+                if ($zip_result !== TRUE) {
+                    throw new \RuntimeException('Failed to create zip file: ' . $zip_result);
+                }
+                if (!$zip->addFile($backup_file, basename($backup_file))) {
+                $zip->close();
+                    throw new \RuntimeException('Failed to add SQL file to ZIP archive');
+                }
+                if (!$zip->close()) {
+                    throw new \RuntimeException('Failed to close ZIP archive');
+                }
+                // Use helper method with ZipArchive/PclZip fallback
+                $this->create_zip_file($zip_file, $backup_file, $backup_id);
                 $this->logger->info('ZIP file created successfully', [
                     'backup_id' => $backup_id,
                     'zip_file' => $zip_file,
                     'zip_size' => filesize($zip_file)
+                    'zip_size' => file_exists($zip_file) ? filesize($zip_file) : 0
                 ]);
 …
             $lock_acquired = true;
+            // Check for and clean up orphaned temp files from previous failed runs
+            $temp_zip_file = $zip_file . '.tmp';
+            if (file_exists($temp_zip_file)) {
+                $temp_file_age = time() - filemtime($temp_zip_file);
+                // If temp file is older than 5 minutes, it's likely orphaned
+                if ($temp_file_age > 300) {
+                    $this->logger->warning('Found orphaned temp ZIP file, attempting recovery', [
+                        'backup_id' => $backup_id,
+                        'temp_file' => $temp_zip_file,
+                        'temp_file_age_seconds' => $temp_file_age,
+                        'temp_file_size' => filesize($temp_zip_file),
+                        'zip_file_exists' => file_exists($zip_file),
+                        'zip_file_size' => file_exists($zip_file) ? filesize($zip_file) : 0
+                    ]);
+                    // If temp file is larger than existing ZIP, try to recover it
+                    if (file_exists($zip_file)) {
+                        $temp_size = filesize($temp_zip_file);
+                        $zip_size = filesize($zip_file);
+                        if ($temp_size > $zip_size) {
+                            // Temp file is larger, try to replace ZIP with it
+                            @unlink($zip_file);
+                            if (rename($temp_zip_file, $zip_file)) {
+                                $this->logger->info('Recovered ZIP file from orphaned temp file', [
+                                    'backup_id' => $backup_id,
+                                    'recovered_size' => filesize($zip_file)
+                                ]);
+                            } else {
+                                // Rename failed, try copy
+                                if (copy($temp_zip_file, $zip_file)) {
+                                    @unlink($temp_zip_file);
+                                    $this->logger->info('Recovered ZIP file from orphaned temp file (via copy)', [
+                                        'backup_id' => $backup_id,
+                                        'recovered_size' => filesize($zip_file)
+                                    ]);
+                                } else {
+                                    $this->logger->error('Failed to recover ZIP from orphaned temp file', [
+                                        'backup_id' => $backup_id,
+                                        'temp_file' => $temp_zip_file
+                                    ]);
+                                    @unlink($temp_zip_file); // Clean up failed temp file
+                                }
+                            }
+                        } else {
+                            // Temp file is not larger, just clean it up
+                            @unlink($temp_zip_file);
+                            $this->logger->info('Removed orphaned temp file (smaller than existing ZIP)', [
+                                'backup_id' => $backup_id,
+                                'temp_size' => $temp_size,
+                                'zip_size' => $zip_size
+                            ]);
+                        }
+                    } else {
+                        // No ZIP file exists, try to use temp file
+                        if (rename($temp_zip_file, $zip_file)) {
+                            $this->logger->info('Recovered ZIP file from orphaned temp file (no existing ZIP)', [
+                                'backup_id' => $backup_id,
+                                'recovered_size' => filesize($zip_file)
+                            ]);
+                        } else {
+                            // Rename failed, try copy
+                            if (copy($temp_zip_file, $zip_file)) {
+                                @unlink($temp_zip_file);
+                                $this->logger->info('Recovered ZIP file from orphaned temp file (via copy, no existing ZIP)', [
+                                    'backup_id' => $backup_id,
+                                    'recovered_size' => filesize($zip_file)
+                                ]);
+                            } else {
+                                $this->logger->error('Failed to recover ZIP from orphaned temp file (no existing ZIP)', [
+                                    'backup_id' => $backup_id,
+                                    'temp_file' => $temp_zip_file
+                                ]);
+                                @unlink($temp_zip_file);
+                            }
+                        }
+                    }
+                }
+            }
             // Check if ZIP file exists (resume mode)
             $zip_exists = file_exists($zip_file);
+                $zip = new \ZipArchive();
+            if ($zip_exists) {
+                // Open existing ZIP for appending
+                $zip_result = $zip->open($zip_file, \ZipArchive::CREATE);
+                if ($zip_result !== TRUE) {
+                    // If we can't open existing ZIP, recreate it
+                    $this->logger->warning('Cannot open existing ZIP file, recreating', [
+            // For files backup, we need to append files incrementally, so we need ZipArchive or PclZip
+            // Try ZipArchive first
+            $zip = null;
+            $use_pclzip = false;
+            if (class_exists('ZipArchive') || extension_loaded('zip')) {
+                try {
+                    $zip = new \ZipArchive();
+                    if ($zip_exists) {
+                        $zip_result = $zip->open($zip_file, \ZipArchive::CREATE);
+                        if ($zip_result !== TRUE) {
+                            $this->logger->warning('Cannot open existing ZIP file, recreating', [
+                                'backup_id' => $backup_id,
+                                'zip_file' => $zip_file,
+                                'zip_result' => $zip_result
+                            ]);
+                            @unlink($zip_file);
+                            $zip_exists = false;
+                        }
+                    }
+                    if (!$zip_exists) {
+                        $zip_result = $zip->open($zip_file, \ZipArchive::CREATE | \ZipArchive::OVERWRITE);
+                        if ($zip_result !== TRUE) {
+                            throw new \RuntimeException('Failed to create zip file: ' . $zip_result);
+                        }
+                    }
+                } catch (\Exception $e) {
+                    $this->logger->warning('ZipArchive failed, will use PclZip', [
                         'backup_id' => $backup_id,
+                        'zip_file' => $zip_file,
+                        'zip_result' => $zip_result
+                        'error' => $e->getMessage()
                     ]);
+                    @unlink($zip_file);
+                    $zip_result = $zip->open($zip_file, \ZipArchive::CREATE | \ZipArchive::OVERWRITE);
+                    if ($zip_result !== TRUE) {
+                        throw new \RuntimeException('Failed to create zip file: ' . $zip_result);
+                    }
+                    $zip_exists = false;
+                    $zip = null;
+                    $use_pclzip = true;
+                }
             } else {
+                // Create new ZIP file
+                $zip_result = $zip->open($zip_file, \ZipArchive::CREATE | \ZipArchive::OVERWRITE);
+                if ($zip_result !== TRUE) {
+                    throw new \RuntimeException('Failed to create zip file: ' . $zip_result);
+                $use_pclzip = true;
+            }
+            // Fallback to PclZip if ZipArchive not available
+            $pclzip = null;
+            if ($use_pclzip) {
+                if (file_exists(ABSPATH . 'wp-admin/includes/class-pclzip.php')) {
+                    if (!class_exists('PclZip')) {
+                        require_once ABSPATH . 'wp-admin/includes/class-pclzip.php';
+                    }
+                    if (class_exists('PclZip')) {
+                        // Check if we have files in pclzip_files array - if so, we can safely recreate
+                        // If array is empty but ZIP exists, keep the ZIP (it was created in a previous chunk)
+                        $pclzip_files_count = isset($backup_info['pclzip_files']) ? count($backup_info['pclzip_files']) : 0;
+                        if ($zip_exists) {
+                            if ($pclzip_files_count > 0) {
+                                // We have files in array, can safely recreate ZIP
+                                $this->logger->info('PclZip mode: recreating ZIP file (append not well supported)', [
+                                    'backup_id' => $backup_id,
+                                    'pclzip_files_count' => $pclzip_files_count
+                                ]);
+                                @unlink($zip_file);
+                                $zip_exists = false;
+                            } else {
+                                // ZIP exists but array is empty - keep existing ZIP (from previous chunk)
+                                // It will be recreated at end of chunk with all files
+                                $this->logger->info('PclZip mode: keeping existing ZIP file (pclzip_files array empty, will recreate at end)', [
+                                    'backup_id' => $backup_id,
+                                    'existing_zip_size' => filesize($zip_file)
+                                ]);
+                            }
+                        }
+                        $pclzip = new \PclZip($zip_file);
+                    } else {
+                        throw new \RuntimeException(
+                            'ZipArchive and PclZip are not available. ' .
+                            'Please contact your hosting provider to enable the PHP zip extension.'
+                        );
+                    }
+                } else {
+                    throw new \RuntimeException(
+                        'ZipArchive and PclZip are not available. ' .
+                        'Please contact your hosting provider to enable the PHP zip extension.'
+                    );
+                }
+            }
 …
             $processed_files = $backup_info['files_processed'] ?? [];
             $processed_files_set = array_flip($processed_files); // For fast lookup
+            // For PclZip, ensure pclzip_files array is initialized and maintained across chunks
+            if ($use_pclzip && !isset($backup_info['pclzip_files'])) {
+                // If we're resuming (ZIP exists) and have processed files, rebuild pclzip_files array
+                // from the processed files list to preserve all previously added files
+                if ($zip_exists && !empty($processed_files)) {
+                    $this->logger->info('Rebuilding pclzip_files array from processed files list', [
+                        'backup_id' => $backup_id,
+                        'processed_count' => count($processed_files),
+                        'existing_zip_size' => filesize($zip_file)
+                    ]);
+                    // Rebuild pclzip_files by matching MD5 hashes from processed_files to actual file paths
+                    $backup_info['pclzip_files'] = [];
+                    $processed_files_set_for_rebuild = array_flip($processed_files);
+                    $pclzip_files_set = []; // Track files already added to prevent duplicates
+                    foreach ($files as $file) {
+                        if ($this->should_exclude($file)) {
+                            continue;
+                        }
+                        $file_key = md5($file);
+                        if (isset($processed_files_set_for_rebuild[$file_key])) {
+                            // This file was already processed, add it to pclzip_files
+                            // Use file path as key to prevent duplicates
+                            if (!isset($pclzip_files_set[$file])) {
+                                $backup_info['pclzip_files'][] = $file;
+                                $pclzip_files_set[$file] = true;
+                            }
+                        }
+                    }
+                    $this->logger->info('Rebuilt pclzip_files array', [
+                        'backup_id' => $backup_id,
+                        'rebuilt_count' => count($backup_info['pclzip_files']),
+                        'expected_count' => count($processed_files)
+                    ]);
+                    // Save the rebuilt array to backup_info
+                    update_option(self::OPTION_PREFIX . $backup_id, $backup_info);
+                } else {
+                    // New backup, initialize empty array
+                    $backup_info['pclzip_files'] = [];
+                    $this->logger->debug('Initialized pclzip_files array for new backup', [
+                        'backup_id' => $backup_id
+                    ]);
+                }
+            }
             // Store total files count for cron to check completion
 …
                     $relative_path = $this->get_relative_path($file, ABSPATH);
+                    if ($zip->addFile($file, $relative_path)) {
+                    // Add file using ZipArchive or PclZip
+                    $file_added = false;
+                    if ($zip !== null) {
+                        // Use ZipArchive
+                        $file_added = $zip->addFile($file, $relative_path);
+                    } elseif ($pclzip !== null) {
+                        // Use PclZip - add file to array for batch processing
+                        // We'll recreate ZIP with all files periodically
+                        if (!isset($backup_info['pclzip_files'])) {
+                            $backup_info['pclzip_files'] = [];
+                        }
+                        $backup_info['pclzip_files'][] = $file; // Store full path
+                        $file_added = true;
+                        // Save to database so we can recreate ZIP later
+                        update_option(self::OPTION_PREFIX . $backup_id, $backup_info);
+                    }
+                    if ($file_added) {
                     $file_key = md5($file);
                     $processed_files[] = $file_key;
 …
                 // Update progress every 50 files (less frequent updates for better performance)
+                // For PclZip, recreate ZIP less frequently (every 500 files) to reduce risk of data loss
+                // and improve performance on slow hosts
                 if ($processed_in_batch % 50 === 0) {
                     $processed = $already_processed + $processed_in_batch;
 …
                     $backup_info['files_processed'] = $processed_files;
                     update_option(self::OPTION_PREFIX . $backup_id, $backup_info);
+                    // For PclZip, recreate ZIP periodically (every 500 files) since it doesn't support appending
+                    // Reduced frequency from every 50 files to reduce risk and improve performance
+                    if ($pclzip !== null && ($processed_in_batch % 500 === 0) && isset($backup_info['pclzip_files']) && !empty($backup_info['pclzip_files'])) {
+                        // Store old ZIP size for validation
+                        $old_zip_size = file_exists($zip_file) ? filesize($zip_file) : 0;
+                        $old_zip_file_count = count($backup_info['pclzip_files']);
+                        // Create temporary ZIP first to avoid data loss
+                        $temp_zip_file = $zip_file . '.tmp';
+                        @unlink($temp_zip_file); // Remove any existing temp file
+                        $pclzip_temp = new \PclZip($temp_zip_file);
+                        $result = $pclzip_temp->create($backup_info['pclzip_files'], PCLZIP_OPT_REMOVE_ALL_PATH);
+                        if ($result === 0) {
+                            $error = $pclzip_temp->errorInfo(true);
+                            $this->logger->warning('PclZip periodic recreate failed, keeping existing ZIP', [
+                                'backup_id' => $backup_id,
+                                'error' => $error,
+                                'files_count' => $old_zip_file_count,
+                                'old_zip_size' => $old_zip_size
+                            ]);
+                            @unlink($temp_zip_file); // Clean up failed temp file
+                            // Don't clear pclzip_files on failure - keep them for retry
+                        } else {
+                            // Verify temp ZIP was created successfully and has valid size
+                            if (file_exists($temp_zip_file)) {
+                                $temp_zip_size = filesize($temp_zip_file);
+                                if ($temp_zip_size > 0 && $temp_zip_size >= $old_zip_size) {
+                                    // New ZIP is valid and not smaller - replace old one
+                                    @unlink($zip_file); // Remove old ZIP
+                                    $replace_success = false;
+                                    if (rename($temp_zip_file, $zip_file)) {
+                                        // Verify the rename succeeded by checking file exists and size
+                                        if (file_exists($zip_file) && filesize($zip_file) === $temp_zip_size) {
+                                            $replace_success = true;
+                                        } else {
+                                            $this->logger->warning('Rename appeared to succeed but file verification failed', [
+                                                'backup_id' => $backup_id,
+                                                'temp_file' => $temp_zip_file,
+                                                'zip_file' => $zip_file,
+                                                'expected_size' => $temp_zip_size,
+                                                'actual_size' => file_exists($zip_file) ? filesize($zip_file) : 0
+                                            ]);
+                                        }
+                                    }
+                                    if (!$replace_success) {
+                                        // Rename failed or verification failed, try copy
+                                        if (file_exists($temp_zip_file) && copy($temp_zip_file, $zip_file)) {
+                                            // Verify copy succeeded
+                                            if (file_exists($zip_file) && filesize($zip_file) === $temp_zip_size) {
+                                                @unlink($temp_zip_file);
+                                                $replace_success = true;
+                                            } else {
+                                                @unlink($zip_file); // Remove incomplete copy
+                                                $this->logger->error('Copy appeared to succeed but file verification failed', [
+                                                    'backup_id' => $backup_id,
+                                                    'temp_file' => $temp_zip_file,
+                                                    'zip_file' => $zip_file,
+                                                    'expected_size' => $temp_zip_size,
+                                                    'actual_size' => file_exists($zip_file) ? filesize($zip_file) : 0
+                                                ]);
+                                            }
+                                        }
+                                    }
+                                    if (!$replace_success) {
+                                        $this->logger->error('Failed to replace ZIP file after recreation', [
+                                            'backup_id' => $backup_id,
+                                            'temp_file' => $temp_zip_file,
+                                            'zip_file' => $zip_file,
+                                            'temp_size' => $temp_zip_size
+                                        ]);
+                                        // Keep temp file for potential recovery on next run
+                                        // Don't delete it here - let the cleanup logic handle it
+                                    } else {
+                                        $this->logger->debug('PclZip ZIP recreated with processed files', [
+                                            'backup_id' => $backup_id,
+                                            'files_count' => count($backup_info['pclzip_files']),
+                                            'zip_size' => $temp_zip_size,
+                                            'old_zip_size' => $old_zip_size
+                                        ]);
+                                    }
+                                } else {
+                                    $this->logger->warning('PclZip periodic recreate created invalid or smaller ZIP, keeping old one', [
+                                        'backup_id' => $backup_id,
+                                        'files_count' => count($backup_info['pclzip_files']),
+                                        'temp_zip_size' => $temp_zip_size,
+                                        'old_zip_size' => $old_zip_size
+                                    ]);
+                                    @unlink($temp_zip_file); // Remove invalid temp file
+                                    // Keep old ZIP and pclzip_files array
+                                }
+                            } else {
+                                $this->logger->warning('PclZip periodic recreate reported success but temp ZIP file was not created', [
+                                    'backup_id' => $backup_id,
+                                    'files_count' => count($backup_info['pclzip_files']),
+                                    'temp_zip_file' => $temp_zip_file
+                                ]);
+                                // Keep old ZIP and pclzip_files array
+                            }
+                        }
+                    }
+                }
+            }
 …
             update_option(self::OPTION_PREFIX . $backup_id, $backup_info);
+            // Close ZIP file
+            if (!$zip->close()) {
+                throw new \RuntimeException('Failed to close ZIP archive');
+            // Close ZIP file (ZipArchive) or recreate ZIP (PclZip)
+            if ($zip !== null) {
+                if (!$zip->close()) {
+                    throw new \RuntimeException('Failed to close ZIP archive');
+                }
+            } elseif ($pclzip !== null) {
+                // For PclZip, final recreate ZIP with all processed files
+                $pclzip_files = $backup_info['pclzip_files'] ?? [];
+                // If pclzip_files is empty but ZIP exists, it means files were already added in periodic recreations
+                // In this case, verify the existing ZIP is valid
+                if (empty($pclzip_files) && file_exists($zip_file) && filesize($zip_file) > 0) {
+                    $this->logger->info('PclZip files array empty but ZIP exists - using existing ZIP', [
+                        'backup_id' => $backup_id,
+                        'zip_size' => filesize($zip_file)
+                    ]);
+                } elseif (!empty($pclzip_files)) {
+                    // Filter to only existing files
+                    $existing_files = array_filter($pclzip_files, 'file_exists');
+                    if (!empty($existing_files)) {
+                        // Recreate ZIP with all files
+                        @unlink($zip_file); // Remove old ZIP
+                        $pclzip = new \PclZip($zip_file);
+                        // Use PCLZIP_OPT_REMOVE_ALL_PATH to add files with relative paths
+                        $result = $pclzip->create($existing_files, PCLZIP_OPT_REMOVE_ALL_PATH);
+                        if ($result === 0) {
+                            $error = $pclzip->errorInfo(true);
+                            throw new \RuntimeException('Failed to create ZIP with PclZip: ' . $error);
+                        }
+                        // Verify ZIP was created successfully
+                        if (!file_exists($zip_file)) {
+                            throw new \RuntimeException('PclZip reported success but ZIP file was not created: ' . $zip_file);
+                        }
+                        $zip_size = filesize($zip_file);
+                        if ($zip_size === false || $zip_size === 0) {
+                            throw new \RuntimeException('PclZip created ZIP file but it is empty or invalid: ' . $zip_file);
+                        }
+                        $this->logger->info('Final ZIP file recreated using PclZip', [
+                            'backup_id' => $backup_id,
+                            'files_count' => count($existing_files),
+                            'zip_size' => $zip_size
+                        ]);
+                    } else {
+                        $this->logger->warning('PclZip: No existing files found to add to ZIP', [
+                            'backup_id' => $backup_id,
+                            'pclzip_files_count' => count($pclzip_files)
+                        ]);
+                    }
+                    // Clear the array after successful creation
+                    unset($backup_info['pclzip_files']);
+                    update_option(self::OPTION_PREFIX . $backup_id, $backup_info);
+                } else {
+                    $this->logger->warning('PclZip: No files to process and no existing ZIP found', [
+                        'backup_id' => $backup_id,
+                        'zip_file_exists' => file_exists($zip_file)
+                    ]);
+                }
+            }
 …
+            }
+            // Verify ZIP file exists and is valid before marking as complete
+            if (!file_exists($zip_file)) {
+                $this->logger->error('Files backup ZIP does not exist after processing completion', [
+                    'backup_id' => $backup_id,
+                    'zip_file' => $zip_file,
+                    'processed' => $processed,
+                    'total_files' => $total_files
+                ]);
+                throw new \RuntimeException('Files backup ZIP file does not exist: ' . $zip_file . '. Backup may have been interrupted during PclZip creation.');
+            }
+            $zip_size = filesize($zip_file);
+            if ($zip_size === false || $zip_size === 0) {
+                $this->logger->error('Files backup ZIP is invalid or empty after processing completion', [
+                    'backup_id' => $backup_id,
+                    'zip_file' => $zip_file,
+                    'zip_size' => $zip_size,
+                    'processed' => $processed,
+                    'total_files' => $total_files
+                ]);
+                throw new \RuntimeException('Files backup ZIP file is invalid or empty: ' . $zip_file . ' (size: ' . ($zip_size === false ? 'false' : $zip_size) . '). Backup may have been interrupted during PclZip creation.');
+            }
             // Prepare file info for the backup
                 $file_info = [
                     'size' => filesize($zip_file),
+                    'size' => $zip_size,
                     'path' => $zip_file,
                     'download_url' => null // Will be set after upload
 …
     /**
      * Backup table
+     * Improved version with chunked processing for large tables to prevent memory exhaustion
+     * Improved version with chunked processing for large tables, PK-based cursor pagination,
+     * and safer, mysqldump-style session handling/escaping (including BLOB-safe hex).
+     *
+     * Note: $table_name is currently ignored and all tables are dumped. It is kept
+     * in the signature for backward compatibility and potential future filtering.
      */
     private function backup_table(string $table_name, string $backup_file): void
 …
         global $wpdb;
+        // Check if file exists and is being written to (resume mode)
+        $is_resume = file_exists($backup_file);
+        $handle = fopen($backup_file, $is_resume ? 'a' : 'w');
+        // Best-effort: infer backup_id from file name so we can update progress for both
+        // classic DB backups (SITESKITE_BACKUP_PATH/{id}_db.sql) and incremental temp dumps
+        // (uploads/siteskite-backups/tmp/{id}_db.sql).
+        $backup_id_guess = null;
+        $base = basename($backup_file);
+        if (preg_match('/^(.+)_db\.sql$/', $base, $m)) {
+            $backup_id_guess = (string)$m[1];
+        }
+        $total_tables = null;
+        $tables_processed = 0;
+        $current_table_for_progress = null;
+        $last_progress_update = 0;
+        $progress_option_key = null;
+        if ($backup_id_guess) {
+            $progress_option_key = self::OPTION_PREFIX . $backup_id_guess;
+        }
+        // Always create a fresh dump file for correctness (resume handled at higher level)
+        $handle = fopen($backup_file, 'w');
         if (!$handle) {
             throw new \RuntimeException('Failed to create/open backup file');
+        }
+        // Only write header if starting fresh (not resuming)
+        if (!$is_resume) {
+        // Write header (deterministic - no timestamp to ensure consistent chunk hashes)
+        // Timestamp removed to prevent duplicate chunks with different hashes when database content is identical
+        // Header (deterministic - no timestamp) and session setup similar to mysqldump
         fwrite($handle, "-- SiteSkite Database Backup\n");
         fwrite($handle, "-- Generated by SiteSkite Backup Plugin\n\n");
+        // Removed NO_AUTO_VALUE_ON_ZERO to prevent duplicate key errors when importing
+        // This mode allows inserting 0 into auto-increment columns which can cause conflicts
         fwrite($handle, "SET AUTOCOMMIT = 0;\n");
+        fwrite($handle, "START TRANSACTION;\n");
+        fwrite($handle, "SET time_zone = \"+00:00\";\n\n");
+        }
+        fwrite($handle, "START TRANSACTION /*!40100 WITH CONSISTENT SNAPSHOT */;\n");
+        // Save and adjust session settings to make import behavior consistent
+        fwrite($handle, "/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;\n");
+        fwrite($handle, "/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;\n");
+        fwrite($handle, "/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;\n");
+        fwrite($handle, "/*!40101 SET NAMES utf8mb4 */;\n");
+        fwrite($handle, "/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;\n");
+        fwrite($handle, "/*!40103 SET TIME_ZONE='+00:00' */;\n");
+        fwrite($handle, "/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;\n");
+        fwrite($handle, "/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;\n");
+        fwrite($handle, "/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;\n");
+        fwrite($handle, "/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;\n");
+        // Also emit non-version-gated statements for maximum compatibility
+        fwrite($handle, "SET FOREIGN_KEY_CHECKS=0;\n");
+        fwrite($handle, "SET UNIQUE_CHECKS=0;\n\n");
         // Get all tables (ensure deterministic ordering for consistent chunk hashes)
         $tables = $wpdb->get_results('SHOW TABLES', ARRAY_N);
         // Sort tables by name to ensure deterministic ordering
         usort($tables, function($a, $b) {
+        usort($tables, function ($a, $b) {
             return strcmp($a[0], $b[0]);
         });
+        $total_tables = is_array($tables) ? count($tables) : 0;
+        if ($progress_option_key && $total_tables > 0) {
+            $backup_info = get_option($progress_option_key);
+            if (is_array($backup_info)) {
+                $backup_info['db_total_tables'] = $total_tables;
+                $backup_info['db_tables_processed'] = 0;
+                $backup_info['db_current_table'] = null;
+                $backup_info['db_sql_size'] = 0;
+                $backup_info['current_stage'] = $backup_info['current_stage'] ?? 'database';
+                $backup_info['current_operation'] = $backup_info['current_operation'] ?? 'Creating database SQL dump';
+                update_option($progress_option_key, $backup_info);
+            }
+        }
         foreach ($tables as $table) {
             $current_table_name = $table[0];
+            // $this->logger->info('Processing table for backup', [
+            //     'table' => $current_table_name,
+            //     'backup_file' => $backup_file
+            // ]);
+            $tables_processed++;
+            $current_table_for_progress = $current_table_name;
             // Get table structure
             $create_table = $wpdb->get_row("SHOW CREATE TABLE `{$current_table_name}`", ARRAY_N);
             if ($create_table) {
+                fwrite($handle, "\n--\n");
+                fwrite($handle, "-- Table structure for table `{$current_table_name}`\n");
+                fwrite($handle, "--\n\n");
                 fwrite($handle, "DROP TABLE IF EXISTS `{$current_table_name}`;\n");
+                fwrite($handle, $create_table[1] . ";\n\n");
+            }
+            // Get table row count to determine if chunking is needed
+            $row_count_result = $wpdb->get_var("SELECT COUNT(*) FROM `{$current_table_name}`");
+            $row_count = (int)$row_count_result;
+            // $this->logger->info('Table row count', [
+            //     'table' => $current_table_name,
+            //     'row_count' => $row_count
+            // ]);
+            // Get table data with deterministic ordering
+            // Use primary key or first column for ordering to ensure consistent row order
+            // This prevents duplicate chunks with different hashes when data is identical
+            $order_by = '';
+            $order_column = '';
+            $primary_key_info = $wpdb->get_row("SHOW KEYS FROM `{$current_table_name}` WHERE Key_name = 'PRIMARY'", ARRAY_A);
+            if ($primary_key_info && !empty($primary_key_info['Column_name'])) {
+                $order_column = $primary_key_info['Column_name'];
+                $order_by = " ORDER BY `{$order_column}`";
+            } else {
+                // Fallback: use first column for ordering
+                $first_col = $wpdb->get_col("SHOW COLUMNS FROM `{$current_table_name}` LIMIT 1");
+                if (!empty($first_col)) {
+                    $order_column = $first_col[0];
+                    $order_by = " ORDER BY `{$order_column}`";
+                }
+            }
+            // Get column names in table order (not sorted) to match INSERT statement expectations
+            // We'll explicitly specify column names in INSERT to ensure correct mapping
+                fwrite($handle, "/*!40101 SET @saved_cs_client     = @@character_set_client */;\n");
+                // Keep character_set_client aligned with utf8mb4 to avoid surprises
+                fwrite($handle, "/*!40101 SET character_set_client = utf8mb4 */;\n");
+                fwrite($handle, $create_table[1] . ";\n");
+                fwrite($handle, "/*!40101 SET character_set_client = @saved_cs_client */;\n\n");
+            }
+            // Get column names and types in table order (not sorted)
             $column_info = $wpdb->get_results("SHOW COLUMNS FROM `{$current_table_name}`", ARRAY_A);
             $column_names = [];
+            $is_binary = [];
+            $column_types = [];
             foreach ($column_info as $col) {
+                $column_names[] = $col['Field'];
+            }
+            // Keep column names in table order (don't sort) to match table structure
+            // We'll specify column names explicitly in INSERT statement for safety
+            if ($row_count > 0) {
+                fwrite($handle, "LOCK TABLES `{$current_table_name}` WRITE;\n");
+                // Process in chunks if table is large (>5000 rows)
+                if ($row_count > 5000) {
+                    $this->logger->info('Processing large table in chunks', [
+                $field = $col['Field'];
+                $column_names[] = $field;
+                $type = strtolower((string) $col['Type']);
+                $column_types[$field] = $type;
+                $is_binary[$field] = (strpos($type, 'blob') !== false || strpos($type, 'binary') !== false);
+            }
+            // Short-circuit if there are no columns (should not happen in normal WordPress tables)
+            if (empty($column_names)) {
+                continue;
+            }
+            // Determine ordering/PK information
+            $order_column = $column_names[0];
+            $primary_key_rows = $wpdb->get_results("SHOW KEYS FROM `{$current_table_name}` WHERE Key_name = 'PRIMARY'", ARRAY_A);
+            $has_primary_key = !empty($primary_key_rows);
+            $is_composite_pk = $has_primary_key && count($primary_key_rows) > 1;
+            $has_single_column_pk = $has_primary_key && !$is_composite_pk && !empty($primary_key_rows[0]['Column_name']);
+            // Check for single-column unique key (for cursor pagination)
+            $unique_key_rows = $wpdb->get_results(
+                "SHOW KEYS FROM `{$current_table_name}` WHERE Non_unique = 0 AND Key_name != 'PRIMARY'",
+                ARRAY_A
+            );
+            $has_single_column_unique = false;
+            $unique_key_column = null;
+            // Group unique key columns by key name to find single-column unique indexes efficiently
+            if (!empty($unique_key_rows)) {
+                $key_columns = [];
+                foreach ($unique_key_rows as $uk_row) {
+                    $kname = $uk_row['Key_name'];
+                    if (!isset($key_columns[$kname])) {
+                        $key_columns[$kname] = [];
+                    }
+                    if (!empty($uk_row['Column_name'])) {
+                        $key_columns[$kname][] = $uk_row['Column_name'];
+                    }
+                }
+                foreach ($key_columns as $kname => $cols) {
+                    if (count($cols) === 1) {
+                        $has_single_column_unique = true;
+                        $unique_key_column = $cols[0];
+                        break;
+                    }
+                }
+            }
+            if ($has_single_column_pk) {
+                $order_column = $primary_key_rows[0]['Column_name'];
+            } elseif ($has_single_column_unique && $unique_key_column) {
+                $order_column = $unique_key_column;
+            } else {
+                // No single-column PK or unique key; prefer any unique key for ordering (even if composite)
+                $unique_key = $wpdb->get_row(
+                    "SHOW KEYS FROM `{$current_table_name}` WHERE Non_unique = 0 AND Key_name != 'PRIMARY' LIMIT 1",
+                    ARRAY_A
+                );
+                if ($unique_key && !empty($unique_key['Column_name'])) {
+                    $order_column = $unique_key['Column_name'];
+                }
+            }
+            // Determine if order_column is numeric type for correct cursor comparison
+            $order_type = $column_types[$order_column] ?? '';
+            $pk_is_numeric = (bool) preg_match('/int|decimal|float|double|bit/i', $order_type);
+            // Check if table has any data (cheap existence check instead of COUNT(*))
+            $has_data = (bool) $wpdb->get_var("SELECT 1 FROM `{$current_table_name}` LIMIT 1");
+            // Optionally get approximate row count from SHOW TABLE STATUS for logging
+            $table_status = $wpdb->get_row(
+                $wpdb->prepare("SHOW TABLE STATUS LIKE %s", $current_table_name),
+                ARRAY_A
+            );
+            $approximate_rows = isset($table_status['Rows']) ? (int) $table_status['Rows'] : 0;
+            if ($has_data) {
+                fwrite($handle, "--\n");
+                fwrite($handle, "-- Dumping data for table `{$current_table_name}`\n");
+                fwrite($handle, "--\n\n");
+                $column_list = '`' . implode('`, `', $column_names) . '`';
+                $chunk_size = 1000;
+                $max_rows_per_insert = 250;
+                $max_statement_bytes = 2 * 1024 * 1024; // ~2MB per INSERT batch
+                // Use cursor pagination when we have a single-column primary key OR single-column unique key
+                $use_cursor = $has_single_column_pk || $has_single_column_unique;
+                if ($use_cursor) {
+                    $last_pk = null;
+                    $cursor_type = $has_single_column_pk ? 'PRIMARY KEY' : 'UNIQUE KEY';
+                    $this->logger->info('Processing table with cursor pagination', [
                         'table' => $current_table_name,
+                        'row_count' => $row_count,
+                        'chunk_size' => 1000
+                        'approximate_rows' => $approximate_rows,
+                        'chunk_size' => $chunk_size,
+                        'cursor_column' => $order_column,
+                        'cursor_type' => $cursor_type,
                     ]);
+                    $chunk_size = 1000;
+                    $offset = 0;
+                    $first_chunk = true;
+                    while ($offset < $row_count) {
+                        // Get chunk of rows
+                        $chunk_query = "SELECT * FROM `{$current_table_name}`{$order_by} LIMIT {$chunk_size} OFFSET {$offset}";
+                        $rows = $wpdb->get_results($chunk_query, ARRAY_A);
+                    while (true) {
+                        // Build WHERE clause for PK cursor
+                        if ($last_pk === null) {
+                            $where = '';
+                        } else {
+                            // Use prepare to avoid injection and keep correct quoting, with correct type
+                            if ($pk_is_numeric) {
+                                $where = $wpdb->prepare(" WHERE `{$order_column}` > %d", (int) $last_pk);
+                            } else {
+                                $where = $wpdb->prepare(" WHERE `{$order_column}` > %s", (string) $last_pk);
+                            }
+                        }
+                        $query = "SELECT * FROM `{$current_table_name}`{$where} ORDER BY `{$order_column}` ASC LIMIT {$chunk_size}";
+                        $rows = $wpdb->get_results($query, ARRAY_A);
                         if (empty($rows)) {
                             break; // No more rows
+                            break;
+                        }
+                        // Write INSERT statement for this chunk
+                        // Explicitly specify column names to ensure correct value mapping
+                        if ($first_chunk) {
+                            $column_list = '`' . implode('`, `', $column_names) . '`';
+                            fwrite($handle, "INSERT INTO `{$current_table_name}` ({$column_list}) VALUES ");
+                            $first_chunk = false;
+                        } else {
+                            fwrite($handle, ",\n");
+                        }
                         $values = [];
+                        $values_count = 0;
+                        $statement_bytes = 0;
                         foreach ($rows as $row) {
-                            // Build values array in deterministic column order
-                            // Use wpdb->prepare for each value to ensure consistent escaping
                             $escaped_values = [];
                             foreach ($column_names as $col_name) {
 …
                                 if ($value === null) {
                                     $escaped_values[] = 'NULL';
                                 } elseif (is_numeric($value) && !is_string($value)) {
                                     // Numeric values (int/float) - use as-is
                                     $escaped_values[] = $value;
+                                } elseif ($is_binary[$col_name]) {
+                                    // Export binary data as hex, like mysqldump
+                                    $escaped_values[] = '0x' . bin2hex((string) $value);
                                 } else {
+                                    // String values - use wpdb->prepare for consistent escaping
+                                    $escaped_values[] = $wpdb->prepare('%s', $value);
+                                    // Prefer mysqli_real_escape_string when available (more robust than private API)
+                                    $value_str = (string) $value;
+                                    if (is_object($wpdb->dbh) && $wpdb->dbh instanceof \mysqli) {
+                                        $escaped = mysqli_real_escape_string($wpdb->dbh, $value_str);
+                                    } elseif (method_exists($wpdb, '_real_escape')) {
+                                        /** @phpstan-ignore-next-line - internal wpdb API */
+                                        $escaped = $wpdb->_real_escape($value_str);
+                                    } else {
+                                        $escaped = addslashes($value_str);
+                                    }
+                                    $escaped_values[] = "'" . $escaped . "'";
+                                }
+                            }
+                            $values[] = '(' . implode(',', $escaped_values) . ')';
+                            $tuple = '(' . implode(',', $escaped_values) . ')';
+                            $values[] = $tuple;
+                            $values_count++;
+                            $statement_bytes += strlen($tuple);
+                            // Flush INSERT in batches to avoid huge packets
+                            if ($values_count >= $max_rows_per_insert || $statement_bytes >= $max_statement_bytes) {
+                                fwrite($handle, "INSERT INTO `{$current_table_name}` ({$column_list}) VALUES ");
+                                fwrite($handle, implode(', ', $values) . ";\n");
+                                $values = [];
+                                $values_count = 0;
+                                $statement_bytes = 0;
+                            }
+                            // Track last PK for cursor
+                            $last_pk = $row[$order_column];
+                        }
+                        fwrite($handle, implode(',', $values));
+                        // Remaining values
+                        if ($values_count > 0) {
+                            fwrite($handle, "INSERT INTO `{$current_table_name}` ({$column_list}) VALUES ");
+                            fwrite($handle, implode(', ', $values) . ";\n");
+                        }
+                        unset($rows, $values);
+                    }
+                } else {
+                    // Fallback: OFFSET-based pagination (only when no single-column PK/unique key)
+                    // This is acceptable for small/medium tables but may be slow on very large tables
+                    $this->logger->warning('Processing table with OFFSET pagination (no single-column PK or unique key found)', [
+                        'table' => $current_table_name,
+                        'approximate_rows' => $approximate_rows,
+                        'chunk_size' => $chunk_size,
+                        'order_column' => $order_column,
+                    ]);
+                    $offset = 0;
+                    $order_by = " ORDER BY `{$order_column}`";
+                    // Use a simple loop that continues until no more rows are returned
+                    // (we don't need exact count since we check for empty results)
+                    while (true) {
+                        $chunk_query = "SELECT * FROM `{$current_table_name}`{$order_by} LIMIT {$chunk_size} OFFSET {$offset}";
+                        $rows = $wpdb->get_results($chunk_query, ARRAY_A);
+                        if (empty($rows)) {
+                            break;
+                        }
+                        $values = [];
+                        $values_count = 0;
+                        $statement_bytes = 0;
+                        foreach ($rows as $row) {
+                            $escaped_values = [];
+                            foreach ($column_names as $col_name) {
+                                $value = $row[$col_name] ?? null;
+                                if ($value === null) {
+                                    $escaped_values[] = 'NULL';
+                                } elseif ($is_binary[$col_name]) {
+                                    $escaped_values[] = '0x' . bin2hex((string) $value);
+                                } else {
+                                    // Prefer mysqli_real_escape_string when available (more robust than private API)
+                                    $value_str = (string) $value;
+                                    if (is_object($wpdb->dbh) && $wpdb->dbh instanceof \mysqli) {
+                                        $escaped = mysqli_real_escape_string($wpdb->dbh, $value_str);
+                                    } elseif (method_exists($wpdb, '_real_escape')) {
+                                        /** @phpstan-ignore-next-line - internal wpdb API */
+                                        $escaped = $wpdb->_real_escape($value_str);
+                                    } else {
+                                        $escaped = addslashes($value_str);
+                                    }
+                                    $escaped_values[] = "'" . $escaped . "'";
+                                }
+                            }
+                            $tuple = '(' . implode(',', $escaped_values) . ')';
+                            $values[] = $tuple;
+                            $values_count++;
+                            $statement_bytes += strlen($tuple);
+                            if ($values_count >= $max_rows_per_insert || $statement_bytes >= $max_statement_bytes) {
+                                fwrite($handle, "INSERT INTO `{$current_table_name}` ({$column_list}) VALUES ");
+                                fwrite($handle, implode(', ', $values) . ";\n");
+                                $values = [];
+                                $values_count = 0;
+                                $statement_bytes = 0;
+                            }
+                        }
+                        if ($values_count > 0) {
+                            fwrite($handle, "INSERT INTO `{$current_table_name}` ({$column_list}) VALUES ");
+                            fwrite($handle, implode(', ', $values) . ";\n");
+                        }
+                        // Break if we got fewer rows than chunk_size (end of table)
+                        if (count($rows) < $chunk_size) {
+                            break;
+                        }
                         $offset += $chunk_size;
-                        // Log progress every 10 chunks
-                        if (($offset / $chunk_size) % 10 === 0) {
-                            // $this->logger->info('Table backup progress', [
-                            //     'table' => $current_table_name,
-                            //     'processed_rows' => $offset,
-                            //     'total_rows' => $row_count,
-                            //     'progress_percent' => round(($offset / $row_count) * 100, 2)
-                            // ]);
+                        }
-                        // Clear memory
                         unset($rows, $values);
+                    }
+                    fwrite($handle, ";\n");
+                    $this->logger->info('Completed chunked processing for large table', [
+                        'table' => $current_table_name,
+                        'total_rows' => $row_count
+                    ]);
+                } else {
+                    // Small table - process all at once (original behavior)
+                    $rows = $wpdb->get_results("SELECT * FROM `{$current_table_name}`{$order_by}", ARRAY_A);
+                    if (!empty($rows)) {
+                        // Explicitly specify column names to ensure correct value mapping
+                        $column_list = '`' . implode('`, `', $column_names) . '`';
+                        fwrite($handle, "INSERT INTO `{$current_table_name}` ({$column_list}) VALUES ");
+                $values = [];
+                foreach ($rows as $row) {
+                    // Build values array in deterministic column order
+                    // Use wpdb->prepare for each value to ensure consistent escaping
+                    $escaped_values = [];
+                    foreach ($column_names as $col_name) {
+                        $value = $row[$col_name] ?? null;
+                        if ($value === null) {
+                            $escaped_values[] = 'NULL';
+                        } elseif (is_numeric($value) && !is_string($value)) {
+                            // Numeric values (int/float) - use as-is
+                            $escaped_values[] = $value;
+                        } else {
+                            // String values - use wpdb->prepare for consistent escaping
+                            $escaped_values[] = $wpdb->prepare('%s', $value);
+                        }
+                    }
+                    $values[] = '(' . implode(',', $escaped_values) . ')';
+                }
+                fwrite($handle, implode(',', $values) . ";\n");
+                    }
+                }
+                fwrite($handle, "UNLOCK TABLES;\n\n");
+            }
+        }
+                }
+            }
+            // Throttled progress updates (once every ~2s) so the external progress endpoint
+            // can show table-level progress during long DB dumps without excessive option writes.
+            if ($progress_option_key && $total_tables && (time() - $last_progress_update) >= 2) {
+                $backup_info = get_option($progress_option_key);
+                if (is_array($backup_info)) {
+                    $backup_info['db_tables_processed'] = $tables_processed;
+                    $backup_info['db_total_tables'] = $total_tables;
+                    $backup_info['db_current_table'] = $current_table_for_progress;
+                    $bytes_written = ftell($handle);
+                    if ($bytes_written !== false) {
+                        $backup_info['db_sql_size'] = (int)$bytes_written;
+                    }
+                    $backup_info['current_stage'] = $backup_info['current_stage'] ?? 'database';
+                    $backup_info['current_operation'] = sprintf(
+                        'Dumping database tables: %d/%d (%s)',
+                        $tables_processed,
+                        $total_tables,
+                        $current_table_for_progress
+                    );
+                    update_option($progress_option_key, $backup_info);
+                }
+                $last_progress_update = time();
+            }
+        }
+        // Restore session variables and finalize transaction
+        fwrite($handle, "\n");
+        fwrite($handle, "/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;\n");
+        fwrite($handle, "/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;\n");
+        fwrite($handle, "/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;\n");
+        fwrite($handle, "/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;\n");
+        fwrite($handle, "/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;\n");
+        fwrite($handle, "/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;\n");
+        fwrite($handle, "/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;\n");
+        fwrite($handle, "/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;\n");
+        // Ensure checks are re-enabled even if version comments are ignored
+        fwrite($handle, "SET FOREIGN_KEY_CHECKS=1;\n");
+        fwrite($handle, "SET UNIQUE_CHECKS=1;\n\n");
         fwrite($handle, "COMMIT;\n");
         fclose($handle);
+        // Final progress update for SQL dump stats.
+        if ($progress_option_key && $total_tables) {
+            $backup_info = get_option($progress_option_key);
+            if (is_array($backup_info)) {
+                $backup_info['db_tables_processed'] = $tables_processed;
+                $backup_info['db_total_tables'] = $total_tables;
+                $backup_info['db_current_table'] = null;
+                $backup_info['db_sql_size'] = file_exists($backup_file) ? (int)filesize($backup_file) : ($backup_info['db_sql_size'] ?? null);
+                $backup_info['current_stage'] = $backup_info['current_stage'] ?? 'database';
+                $backup_info['current_operation'] = 'Database SQL dump completed';
+                update_option($progress_option_key, $backup_info);
+            }
+        }
         $this->logger->info('Database backup SQL dump completed', [
             'backup_file' => $backup_file,
             'file_size' => filesize($backup_file)
+            'file_size' => filesize($backup_file),
         ]);
+    }
 …
     /**
+     * Create ZIP file with ZipArchive or PclZip fallback
+     *
+     * @param string $zip_file Path to output ZIP file
+     * @param string|array $source_files Single file path or array of file paths to add
+     * @param string $backup_id Backup ID for logging
+     * @param array $file_names Optional array of names to use inside ZIP (same order as source_files)
+     * @return bool True if ZIP was created successfully
+     * @throws \RuntimeException If both methods fail
+     */
+    private function create_zip_file($zip_file, $source_files, string $backup_id, array $file_names = []): bool
+    {
+        // Normalize source files to array
+        if (is_string($source_files)) {
+            $source_files = [$source_files];
+        }
+        // Method 1: Try ZipArchive (preferred)
+        if (class_exists('ZipArchive') || extension_loaded('zip')) {
+            try {
+                $zip = new \ZipArchive();
+                $zip_result = $zip->open($zip_file, \ZipArchive::CREATE | \ZipArchive::OVERWRITE);
+                if ($zip_result === TRUE) {
+                    foreach ($source_files as $index => $file) {
+                        if (file_exists($file)) {
+                            // Use provided name or basename
+                            $zip_name = isset($file_names[$index]) ? $file_names[$index] : basename($file);
+                            $zip->addFile($file, $zip_name);
+                        }
+                    }
+                    if ($zip->close()) {
+                        $this->logger->info('ZIP file created using ZipArchive', [
+                            'backup_id' => $backup_id,
+                            'zip_file' => $zip_file,
+                            'method' => 'ZipArchive'
+                        ]);
+                        return true;
+                    }
+                }
+            } catch (\Exception $e) {
+                $this->logger->warning('ZipArchive failed, trying PclZip fallback', [
+                    'backup_id' => $backup_id,
+                    'error' => $e->getMessage()
+                ]);
+            }
+        }
+        // Method 2: Try PclZip (WordPress includes this)
+        if (file_exists(ABSPATH . 'wp-admin/includes/class-pclzip.php')) {
+            try {
+                if (!class_exists('PclZip')) {
+                    require_once ABSPATH . 'wp-admin/includes/class-pclzip.php';
+                }
+                if (class_exists('PclZip')) {
+                    $zip = new \PclZip($zip_file);
+                    $files_to_add = [];
+                    $temp_files = []; // Track temp files for cleanup
+                    foreach ($source_files as $index => $file) {
+                        if (file_exists($file)) {
+                            $zip_name = isset($file_names[$index]) ? $file_names[$index] : basename($file);
+                            // If we need a custom name, create temp file with that name
+                            if (isset($file_names[$index]) && $file_names[$index] !== basename($file)) {
+                                $temp_dir = sys_get_temp_dir();
+                                $temp_file = $temp_dir . '/siteskite_' . uniqid() . '_' . $zip_name;
+                                if (@copy($file, $temp_file)) {
+                                    $files_to_add[] = $temp_file;
+                                    $temp_files[] = $temp_file;
+                                } else {
+                                    // Fallback: add original file
+                                    $files_to_add[] = $file;
+                                }
+                            } else {
+                                // Use original file
+                                $files_to_add[] = $file;
+                            }
+                        }
+                    }
+                    if (!empty($files_to_add)) {
+                        // Remove all paths so files are added with just their names
+                        $result = $zip->create($files_to_add, PCLZIP_OPT_REMOVE_ALL_PATH);
+                        // Clean up temp files
+                        foreach ($temp_files as $temp_file) {
+                            @unlink($temp_file);
+                        }
+                        if ($result !== 0) {
+                            $this->logger->info('ZIP file created using PclZip', [
+                                'backup_id' => $backup_id,
+                                'zip_file' => $zip_file,
+                                'method' => 'PclZip',
+                                'files_count' => count($files_to_add)
+                            ]);
+                            return true;
+                        } else {
+                            $error = $zip->errorInfo(true);
+                            $this->logger->warning('PclZip create failed', [
+                                'backup_id' => $backup_id,
+                                'error' => $error
+                            ]);
+                        }
+                    }
+                }
+            } catch (\Exception $e) {
+                $this->logger->warning('PclZip failed', [
+                    'backup_id' => $backup_id,
+                    'error' => $e->getMessage()
+                ]);
+            }
+        }
+        // All methods failed
+        throw new \RuntimeException(
+            'Unable to create ZIP file. ZipArchive and PclZip are not available. ' .
+            'Please contact your hosting provider to enable the PHP zip extension.'
+        );
+    }
+    /**
      * Create lock file for files backup
      */
 …
         $lock_file = SITESKITE_BACKUP_PATH . '/' . $backup_id . '_files.lock';
         // Check if lock file exists and is stale (older than 1 hour)
+        // Check if lock file exists and is stale
         if (file_exists($lock_file)) {
             $lock_age = time() - filemtime($lock_file);
+            if ($lock_age > 3600) {
+            // Check if process is actually running by reading PID from lock file
+            $lock_content = @file_get_contents($lock_file);
+            $is_process_running = false;
+            if ($lock_content !== false) {
+                $lines = explode("\n", trim($lock_content));
+                if (isset($lines[1]) && is_numeric($lines[1])) {
+                    $pid = (int)$lines[1];
+                    // Check if process is running (works on Unix-like systems)
+                    if (function_exists('posix_kill')) {
+                        $is_process_running = @posix_kill($pid, 0);
+                    } elseif (PHP_OS_FAMILY !== 'Windows') {
+                        // Fallback: check if /proc/PID exists (Linux)
+                        $is_process_running = file_exists("/proc/{$pid}");
+                    }
+                }
+            }
+            // Reduced timeout to 20 minutes (1200 seconds) for faster recovery
+            // If process is not running, consider lock stale after 5 minutes
+            $stale_threshold = $is_process_running ? 1200 : 300;
+            if ($lock_age > $stale_threshold) {
                 // Lock is stale, remove it
                 $this->logger->warning('Removing stale files backup lock file', [
                     'backup_id' => $backup_id,
                     'lock_file' => $lock_file,
+                    'lock_age_seconds' => $lock_age
+                    'lock_age_seconds' => $lock_age,
+                    'process_running' => $is_process_running,
+                    'stale_threshold' => $stale_threshold
                 ]);
                 @unlink($lock_file);
 …
                     'backup_id' => $backup_id,
                     'lock_file' => $lock_file,
+                    'lock_age_seconds' => $lock_age
+                    'lock_age_seconds' => $lock_age,
+                    'process_running' => $is_process_running
                 ]);
                 return false;
 …
         $fileSize = filesize($sqlPath);
         $this->logger->info('Database dump created', ['file_size' => $fileSize]);
+        // Seed detailed DB progress fields for the progress endpoint/UI.
+        // This helps the UI show real progress for large DBs (byte/chunk level), not just "completed".
+        $bi_seed = get_option(self::OPTION_PREFIX . $backup_id);
+        if (is_array($bi_seed)) {
+            $bi_seed['db_total_bytes'] = (int)$fileSize;
+            $bi_seed['db_bytes_processed'] = 0;
+            $bi_seed['db_chunks_processed'] = 0;
+            $bi_seed['db_chunks_total_estimate'] = null; // filled once chunk size known
+            $bi_seed['db_new_chunks_count'] = 0;
+            $bi_seed['db_reused_chunks_count'] = 0;
+            $bi_seed['current_stage'] = 'database';
+            $bi_seed['current_operation'] = 'Preparing incremental database chunks';
+            update_option(self::OPTION_PREFIX . $backup_id, $bi_seed);
+        }
         // IMPORTANT: Create manifest BEFORE creating chunks on disk
 …
         // Use centralized chunk size from config
         $chunkSize = $this->backup_config->chunkSizeBytes;
+        $chunks_total_estimate = $chunkSize > 0 ? (int)ceil($fileSize / $chunkSize) : null;
+        $last_db_progress_update_ts = 0;
         $stream = fopen($sqlPath, 'rb');
         if (!$stream) {
 …
+                }
+            }
+            // Throttled progress updates (once every ~2 seconds) to expose chunk/byte level progress.
+            if ((time() - (int)$last_db_progress_update_ts) >= 2) {
+                $bi = get_option(self::OPTION_PREFIX . $backup_id);
+                if (is_array($bi)) {
+                    $bi['db_total_bytes'] = (int)$fileSize;
+                    $bi['db_bytes_processed'] = (int)$bytes_processed;
+                    $bi['db_chunks_processed'] = count($chunkHashes);
+                    $bi['db_chunks_total_estimate'] = $chunks_total_estimate;
+                    $bi['db_new_chunks_count'] = count($new_chunks);
+                    $bi['db_reused_chunks_count'] = count($reused_chunks);
+                    $pct = ($fileSize > 0) ? (int)round(($bytes_processed / $fileSize) * 100) : 0;
+                    $bi['current_stage'] = 'database';
+                    $bi['current_operation'] = sprintf(
+                        'Processing incremental DB: %d%% (%s/%s)',
+                        $pct,
+                        size_format((int)$bytes_processed, 2),
+                        size_format((int)$fileSize, 2)
+                    );
+                    // Keep overall progress moving for db-only incremental backups (10 -> 70 during chunking).
+                    $existing_progress = (int)($bi['progress'] ?? 10);
+                    $scaled = 10 + (int)round(($pct / 100) * 60);
+                    $bi['progress'] = max($existing_progress, min(70, $scaled));
+                    update_option(self::OPTION_PREFIX . $backup_id, $bi);
+                }
+                $last_db_progress_update_ts = time();
+            }
+        }
         fclose($stream);
+        // Final progress update for chunking stats.
+        $bi = get_option(self::OPTION_PREFIX . $backup_id);
+        if (is_array($bi)) {
+            $bi['db_total_bytes'] = (int)$fileSize;
+            $bi['db_bytes_processed'] = (int)$bytes_processed;
+            $bi['db_chunks_processed'] = count($chunkHashes);
+            $bi['db_chunks_total_estimate'] = $chunks_total_estimate;
+            $bi['db_new_chunks_count'] = count($new_chunks);
+            $bi['db_reused_chunks_count'] = count($reused_chunks);
+            $bi['current_stage'] = 'database';
+            $bi['current_operation'] = 'Incremental DB chunking completed';
+            $bi['progress'] = max((int)($bi['progress'] ?? 10), 70);
+            update_option(self::OPTION_PREFIX . $backup_id, $bi);
+        }
         $this->logger->info('Database chunking completed', [
 …
+            }
+            $zip = new \ZipArchive();
+            $zipOpenResult = $zip->open($tempZipPath, \ZipArchive::CREATE | \ZipArchive::OVERWRITE);
+            if ($zipOpenResult !== true) {
+                $this->logger->error('Failed to open zip archive', [
+                    'backup_id' => $backup_id,
+                    'bundle_index' => $bundleIndex,
+                    'error_code' => $zipOpenResult
+                ]);
+                if (function_exists('wp_delete_file')) {
+                    wp_delete_file($tempZipPath);
+            // Try ZipArchive first, fallback to PclZip
+            $zip = null;
+            $pclzip = null;
+            if (class_exists('ZipArchive') || extension_loaded('zip')) {
+                try {
+                    $zip = new \ZipArchive();
+                } catch (\Exception $e) {
+                    $this->logger->warning('ZipArchive failed for bundle, trying PclZip', [
+                        'backup_id' => $backup_id,
+                        'bundle_index' => $bundleIndex,
+                        'error' => $e->getMessage()
+                    ]);
+                }
+            }
+            // Fallback to PclZip
+            if ($zip === null) {
+                if (file_exists(ABSPATH . 'wp-admin/includes/class-pclzip.php')) {
+                    if (!class_exists('PclZip')) {
+                        require_once ABSPATH . 'wp-admin/includes/class-pclzip.php';
+                    }
+                    if (class_exists('PclZip')) {
+                        $pclzip = new \PclZip($tempZipPath);
+                    } else {
+                        $this->logger->error('Neither ZipArchive nor PclZip available for bundle processing', [
+                            'backup_id' => $backup_id,
+                            'bundle_index' => $bundleIndex
+                        ]);
+                        continue; // Skip this bundle
+                    }
                 } else {
+                    @unlink($tempZipPath);
+                }
+                continue;
+                    $this->logger->error('Neither ZipArchive nor PclZip available for bundle processing', [
+                        'backup_id' => $backup_id,
+                        'bundle_index' => $bundleIndex
+                    ]);
+                    continue; // Skip this bundle
+                }
+            }
+            // Open/create ZIP
+            if ($zip !== null) {
+                $zipOpenResult = $zip->open($tempZipPath, \ZipArchive::CREATE | \ZipArchive::OVERWRITE);
+                if ($zipOpenResult !== true) {
+                    $this->logger->error('Failed to open zip archive', [
+                        'backup_id' => $backup_id,
+                        'bundle_index' => $bundleIndex,
+                        'error_code' => $zipOpenResult
+                    ]);
+                    if (function_exists('wp_delete_file')) {
+                        wp_delete_file($tempZipPath);
+                    } else {
+                        @unlink($tempZipPath);
+                    }
+                    continue;
+                }
+            }
 …
             $successfulChunks = 0;
+            // For PclZip, collect chunk files to add at once
+            $pclzip_chunk_files = [];
             $this->logger->debug('Starting to add chunks to bundle ZIP', [
                 'backup_id' => $backup_id,
                 'bundle_index' => $bundleIndex + 1,
+                'total_chunks_to_add' => count($bundleChunkHashes)
+                'total_chunks_to_add' => count($bundleChunkHashes),
+                'method' => $zip !== null ? 'ZipArchive' : 'PclZip'
             ]);
 …
                     if ($chunkData !== false && $chunkData !== null && $actualSize > 0 && $actualSize <= $expectedSize) {
                         // Add to zip with hash as filename
+                        $zip->addFromString($chunkHash . '.blob', $chunkData);
+                        if ($zip !== null) {
+                            // Use ZipArchive
+                            $zip->addFromString($chunkHash . '.blob', $chunkData);
+                        } elseif ($pclzip !== null) {
+                            // Use PclZip - write chunk to temp file with hash as name, collect for batch add
+                            $tempChunkFile = sys_get_temp_dir() . '/siteskite_' . $chunkHash . '.blob';
+                            if (file_put_contents($tempChunkFile, $chunkData) !== false) {
+                                $pclzip_chunk_files[] = $tempChunkFile;
+                            } else {
+                                $this->logger->warning('Failed to write chunk to temp file for PclZip', [
+                                    'backup_id' => $backup_id,
+                                    'chunk_hash' => $chunkHash
+                                ]);
+                                continue; // Skip this chunk
+                            }
+                        }
                         $bundleChunks[] = $chunkHash;
                         $bundleTotalSize += $actualSize;
 …
             ]);
+            $zip->close();
+            // Close ZIP (ZipArchive) or create ZIP with all chunks (PclZip)
+            if ($zip !== null) {
+                $zip->close();
+            } elseif ($pclzip !== null && !empty($pclzip_chunk_files)) {
+                // PclZip: create ZIP with all collected chunk files
+                @unlink($tempZipPath); // Remove if exists
+                $pclzip = new \PclZip($tempZipPath);
+                $result = $pclzip->create($pclzip_chunk_files, PCLZIP_OPT_REMOVE_ALL_PATH);
+                // Clean up temp chunk files
+                foreach ($pclzip_chunk_files as $temp_file) {
+                    @unlink($temp_file);
+                }
+                if ($result === 0) {
+                    $error = $pclzip->errorInfo(true);
+                    $this->logger->error('PclZip bundle creation failed', [
+                        'backup_id' => $backup_id,
+                        'bundle_index' => $bundleIndex,
+                        'error' => $error
+                    ]);
+                    continue; // Skip this bundle
+                }
+                $this->logger->debug('PclZip bundle created successfully', [
+                    'backup_id' => $backup_id,
+                    'bundle_index' => $bundleIndex,
+                    'chunks_count' => count($pclzip_chunk_files)
+                ]);
+            }
             if ($successfulChunks === 0) {
 …
+            }
+            // Check if backup has already failed with a permanent error (e.g., missing ZipArchive)
+            if (isset($backup_info['status']) && $backup_info['status'] === 'failed') {
+                $error = $backup_info['error'] ?? '';
+                // If error indicates missing ZipArchive, don't retry - clean up cron job
+                if (stripos($error, 'ZipArchive') !== false || stripos($error, 'zip extension') !== false) {
+                    $this->logger->info('Database backup failed with permanent error, cleaning up cron job', [
+                        'backup_id' => $backup_id,
+                        'error' => $error
+                    ]);
+                    $this->delete_backup_cron_job('process_database_backup_cron', $backup_id, $callback_url);
+                    unset($backup_info['cron_job_scheduled_db']);
+                    update_option(self::OPTION_PREFIX . $backup_id, $backup_info);
+                    return;
+                }
+            }
             // Check if backup is already in progress (lock file exists)
             $lock_file = SITESKITE_BACKUP_PATH . '/' . $backup_id . '_db.lock';
 …
             $this->process_database_backup($backup_id);
         } catch (\Exception $e) {
             $this->logger->error('Database backup cron failed', [
+            $this->logger->error('Database backup failed', [
                 'backup_id' => $backup_id,
+                'error' => $e->getMessage()
+            ]);
+            // On error, don't delete the recurring job - let it retry
+            // But check if backup is now completed (might have completed despite error)
+            $backup_info = get_option(self::OPTION_PREFIX . $backup_id);
+            if ($backup_info && isset($backup_info['status']) && $backup_info['status'] === 'completed') {
+                'error' => $e->getMessage(),
+                'trace' => $e->getTraceAsString()
+            ]);
+            // Mark backup as failed and send notification
+            $backup_info = get_option(self::OPTION_PREFIX . $backup_id, []);
+            if ($backup_info) {
+                $backup_info['status'] = 'failed';
+                $backup_info['error'] = $e->getMessage();
+                $backup_info['updated_at'] = time();
+                $backup_info['completed_at'] = time();
+                update_option(self::OPTION_PREFIX . $backup_id, $backup_info);
+                // Send failure notification
+                if ($callback_url) {
+                    $notification_data = [
+                        'backup_id' => $backup_id,
+                        'type' => $backup_info['type'] ?? 'database',
+                        'status' => 'failed',
+                        'progress' => $backup_info['progress'] ?? 0,
+                        'message' => 'Database backup failed: ' . $e->getMessage(),
+                        'current_stage' => $backup_info['current_stage'] ?? 'database_backup',
+                        'current_operation' => $backup_info['current_operation'] ?? 'Creating ZIP file',
+                        'started_at' => $backup_info['started_at'] ?? time(),
+                        'updated_at' => $backup_info['updated_at'],
+                        'completed_at' => $backup_info['completed_at'],
+                        'error' => $e->getMessage(),
+                        'process_type' => $backup_info['process_type'] ?? 'manual'
+                    ];
+                    if ($this->notification_manager) {
+                        $this->notification_manager->send_notification($notification_data);
+                    }
+                }
+                // Clean up cron job since backup has failed
                 $this->delete_backup_cron_job('process_database_backup_cron', $backup_id, $callback_url);
 …
                 unset($backup_info['cron_job_scheduled_db']);
                 update_option(self::OPTION_PREFIX . $backup_id, $backup_info);
+            } else {
+                // Backup info not found - just clean up the cron job
+                $this->delete_backup_cron_job('process_database_backup_cron', $backup_id, $callback_url);
+            }
+        }
 …
             if (file_exists($lock_file)) {
                 $lock_age = time() - filemtime($lock_file);
+                // If lock is fresh (less than 1 hour), backup is in progress
+                if ($lock_age < 3600) {
+                // Check if process is actually running by reading PID from lock file
+                $lock_content = @file_get_contents($lock_file);
+                $is_process_running = false;
+                if ($lock_content !== false) {
+                    $lines = explode("\n", trim($lock_content));
+                    if (isset($lines[1]) && is_numeric($lines[1])) {
+                        $pid = (int)$lines[1];
+                        // Check if process is running (works on Unix-like systems)
+                        if (function_exists('posix_kill')) {
+                            $is_process_running = @posix_kill($pid, 0);
+                        } elseif (PHP_OS_FAMILY !== 'Windows') {
+                            // Fallback: check if /proc/PID exists (Linux)
+                            $is_process_running = file_exists("/proc/{$pid}");
+                        }
+                    }
+                }
+                // Reduced timeout to 20 minutes (1200 seconds) for faster recovery from stuck processes
+                // If process is not running, consider lock stale after 5 minutes
+                $stale_threshold = $is_process_running ? 1200 : 300;
+                if ($lock_age < $stale_threshold) {
                     $this->logger->info('Files backup already in progress, skipping duplicate trigger', [
                         'backup_id' => $backup_id,
+                        'lock_age_seconds' => $lock_age
+                        'lock_age_seconds' => $lock_age,
+                        'process_running' => $is_process_running,
+                        'stale_threshold' => $stale_threshold
                     ]);
                     return; // Skip this run, but keep the recurring job for retry
+                }
+                // Lock is stale, log warning
+                $this->logger->warning('Stale lock file detected, will be cleaned up', [
+                    'backup_id' => $backup_id,
+                    'lock_age_seconds' => $lock_age,
+                    'process_running' => $is_process_running
+                ]);
                 // Stale lock will be handled by process_files_backup
+            }
 …
             // The recurring job will keep running until backup is complete
+            // Check if backup has already failed with a permanent error (e.g., missing ZipArchive)
+            if (isset($backup_info['status']) && $backup_info['status'] === 'failed') {
+                $error = $backup_info['error'] ?? '';
+                // If error indicates missing ZipArchive, don't retry - clean up cron job
+                if (stripos($error, 'ZipArchive') !== false || stripos($error, 'zip extension') !== false) {
+                    $this->logger->info('Files backup failed with permanent error, cleaning up cron job', [
+                        'backup_id' => $backup_id,
+                        'error' => $error
+                    ]);
+                    $this->delete_backup_cron_job('process_files_backup_cron', $backup_id, $callback_url);
+                    unset($backup_info['cron_job_scheduled_files']);
+                    update_option(self::OPTION_PREFIX . $backup_id, $backup_info);
+                    return;
+                }
+            }
             $this->process_files_backup($backup_id);
         } catch (\Exception $e) {
             $this->logger->error('Files backup cron failed', [
+            $this->logger->error('Files backup failed', [
                 'backup_id' => $backup_id,
                 'error' => $e->getMessage(),
 …
             ]);
+            // On error, don't delete the recurring job - let it retry
+            // But check if backup is now completed (might have completed despite error)
+            $backup_info = get_option(self::OPTION_PREFIX . $backup_id);
+            if ($backup_info && isset($backup_info['status']) && $backup_info['status'] === 'completed') {
+            // Mark backup as failed and send notification
+            $backup_info = get_option(self::OPTION_PREFIX . $backup_id, []);
+            if ($backup_info) {
+                $backup_info['status'] = 'failed';
+                $backup_info['error'] = $e->getMessage();
+                $backup_info['updated_at'] = time();
+                $backup_info['completed_at'] = time();
+                update_option(self::OPTION_PREFIX . $backup_id, $backup_info);
+                // Send failure notification
+                if ($callback_url) {
+                    $notification_data = [
+                        'backup_id' => $backup_id,
+                        'type' => $backup_info['type'] ?? 'files',
+                        'status' => 'failed',
+                        'progress' => $backup_info['progress'] ?? 0,
+                        'message' => 'Files backup failed: ' . $e->getMessage(),
+                        'current_stage' => $backup_info['current_stage'] ?? 'files_backup',
+                        'current_operation' => $backup_info['current_operation'] ?? 'Creating ZIP file',
+                        'started_at' => $backup_info['started_at'] ?? time(),
+                        'updated_at' => $backup_info['updated_at'],
+                        'completed_at' => $backup_info['completed_at'],
+                        'error' => $e->getMessage(),
+                        'process_type' => $backup_info['process_type'] ?? 'manual'
+                    ];
+                    if ($this->notification_manager) {
+                        $this->notification_manager->send_notification($notification_data);
+                    }
+                }
+                // Clean up cron job since backup has failed
                 $this->delete_backup_cron_job('process_files_backup_cron', $backup_id, $callback_url);
 …
                 unset($backup_info['cron_job_scheduled_files']);
                 update_option(self::OPTION_PREFIX . $backup_id, $backup_info);
+            } else {
+                // Backup info not found - just clean up the cron job
+                $this->delete_backup_cron_job('process_files_backup_cron', $backup_id, $callback_url);
+            }
+        }
 …
+            }
+            // Check if backup has already failed with a permanent error (e.g., missing ZipArchive)
+            if (isset($backup_info['status']) && $backup_info['status'] === 'failed') {
+                $error = $backup_info['error'] ?? '';
+                // If error indicates missing ZipArchive, don't retry - clean up cron job
+                if (stripos($error, 'ZipArchive') !== false || stripos($error, 'zip extension') !== false) {
+                    $this->logger->info('Full backup failed with permanent error, cleaning up cron job', [
+                        'backup_id' => $backup_id,
+                        'error' => $error
+                    ]);
+                    $this->delete_backup_cron_job('process_full_backup_final_zip_cron', $backup_id, $callback_url);
+                    return;
+                }
+            }
             // Check if backup is already completed
             if (isset($backup_info['status']) && $backup_info['status'] === 'completed') {
 …
             $final_zip = SITESKITE_BACKUP_PATH . '/' . $backup_id . '_full.zip';
+            $zip = new \ZipArchive();
+            $zip_result = $zip->open($final_zip, \ZipArchive::CREATE | \ZipArchive::OVERWRITE);
+            if ($zip_result !== TRUE) {
+                throw new \RuntimeException('Failed to create final zip file: ' . $zip_result);
+            }
+            // Add database ZIP
+            if (!$zip->addFile($db_file, 'database.zip')) {
+                $zip->close();
+                throw new \RuntimeException('Failed to add database.zip to final ZIP archive');
+            }
+            // Add files ZIP
+            if (!$zip->addFile($files_file, 'files.zip')) {
+                $zip->close();
+                throw new \RuntimeException('Failed to add files.zip to final ZIP archive');
+            }
+            if (!$zip->close()) {
+                throw new \RuntimeException('Failed to close final ZIP archive');
+            }
+            // Use helper method with ZipArchive/PclZip fallback
+            $this->create_zip_file($final_zip, [$db_file, $files_file], $backup_id, ['database.zip', 'files.zip']);
             // Verify final ZIP was created and is not empty
 …
         } catch (\Exception $e) {
             $this->logger->error('Failed to create final ZIP via cron', [
+            $this->logger->error('Full backup final ZIP creation failed', [
                 'backup_id' => $backup_id,
                 'error' => $e->getMessage(),
                 'trace' => $e->getTraceAsString()
             ]);
+            // Reschedule to retry
+            $this->schedule_cron_event(
+                'process_full_backup_final_zip_cron',
+                ['backup_id' => $backup_id, 'callback_url' => $callback_url],
+, // Retry in 5 minutes
+                "SiteSkite Process Full Backup Final ZIP Retry"
+            );
+            // Mark backup as failed and send notification
+            $backup_info = get_option(self::OPTION_PREFIX . $backup_id, []);
+            if ($backup_info) {
+                $backup_info['status'] = 'failed';
+                $backup_info['error'] = $e->getMessage();
+                $backup_info['updated_at'] = time();
+                $backup_info['completed_at'] = time();
+                update_option(self::OPTION_PREFIX . $backup_id, $backup_info);
+                // Send failure notification
+                if ($callback_url) {
+                    $notification_data = [
+                        'backup_id' => $backup_id,
+                        'type' => $backup_info['type'] ?? 'full',
+                        'status' => 'failed',
+                        'progress' => $backup_info['progress'] ?? 0,
+                        'message' => 'Full backup final ZIP creation failed: ' . $e->getMessage(),
+                        'current_stage' => $backup_info['current_stage'] ?? 'final_zip',
+                        'current_operation' => $backup_info['current_operation'] ?? 'Creating final ZIP file',
+                        'started_at' => $backup_info['started_at'] ?? time(),
+                        'updated_at' => $backup_info['updated_at'],
+                        'completed_at' => $backup_info['completed_at'],
+                        'error' => $e->getMessage(),
+                        'process_type' => $backup_info['process_type'] ?? 'manual'
+                    ];
+                    if ($this->notification_manager) {
+                        $this->notification_manager->send_notification($notification_data);
+                    }
+                }
+                // Clean up cron jobs since backup has failed
+                $this->delete_backup_cron_job('process_full_backup_final_zip_cron', $backup_id, $callback_url);
+                $this->delete_backup_cron_job('process_database_backup_cron', $backup_id, $callback_url);
+                $this->delete_backup_cron_job('process_files_backup_cron', $backup_id, $callback_url);
+                // Clear cron job scheduled flags
+                unset($backup_info['cron_job_scheduled_db']);
+                unset($backup_info['cron_job_scheduled_files']);
+                update_option(self::OPTION_PREFIX . $backup_id, $backup_info);
+            } else {
+                // Backup info not found - just clean up the cron job
+                $this->delete_backup_cron_job('process_full_backup_final_zip_cron', $backup_id, $callback_url);
+            }
+        }
+    }
 …
         } catch (\Exception $e) {
             $this->logger->error('Full backup cron failed', [
+                    'backup_id' => $backup_id,
+                'error' => $e->getMessage()
+            ]);
+                'backup_id' => $backup_id,
+                'error' => $e->getMessage(),
+                'trace' => $e->getTraceAsString()
+            ]);
+            // Mark backup as failed and send notification
+            $backup_info = get_option(self::OPTION_PREFIX . $backup_id, []);
+            if ($backup_info) {
+                $backup_info['status'] = 'failed';
+                $backup_info['error'] = $e->getMessage();
+                $backup_info['updated_at'] = time();
+                $backup_info['completed_at'] = time();
+                update_option(self::OPTION_PREFIX . $backup_id, $backup_info);
+                // Send failure notification
+                $callback_url = $backup_info['callback_url'] ?? null;
+                if ($callback_url) {
+                    $notification_data = [
+                        'backup_id' => $backup_id,
+                        'type' => $backup_info['type'] ?? 'full',
+                        'status' => 'failed',
+                        'progress' => $backup_info['progress'] ?? 0,
+                        'message' => 'Full backup failed: ' . $e->getMessage(),
+                        'current_stage' => $backup_info['current_stage'] ?? 'full_backup',
+                        'current_operation' => $backup_info['current_operation'] ?? 'Processing full backup',
+                        'started_at' => $backup_info['started_at'] ?? time(),
+                        'updated_at' => $backup_info['updated_at'],
+                        'completed_at' => $backup_info['completed_at'],
+                        'error' => $e->getMessage(),
+                        'process_type' => $backup_info['process_type'] ?? 'manual'
+                    ];
+                    if ($this->notification_manager) {
+                        $this->notification_manager->send_notification($notification_data);
+                    }
+                }
+                // Clean up cron jobs since backup has failed
+                $this->delete_backup_cron_job('process_full_backup_cron', $backup_id, $callback_url);
+                $this->delete_backup_cron_job('process_database_backup_cron', $backup_id, $callback_url);
+                $this->delete_backup_cron_job('process_files_backup_cron', $backup_id, $callback_url);
+                $this->delete_backup_cron_job('process_full_backup_final_zip_cron', $backup_id, $callback_url);
+                // Clear cron job scheduled flags
+                unset($backup_info['cron_job_scheduled_db']);
+                unset($backup_info['cron_job_scheduled_files']);
+                update_option(self::OPTION_PREFIX . $backup_id, $backup_info);
+            }
+        }
+    }

siteskite/trunk/includes/Cron/ExternalCronManager.php

-                      r3445137
+                      r3445801
      * Get trigger URL for action
      * Includes secret token as query parameter for services that don't support custom headers
+     * Also includes cache-busting parameters to prevent caching on heavily cached hosting
      */
     private function get_trigger_url(string $action): string
 …
         // Always get fresh token using the same method as validation
         $current_token = $this->get_secret_token();
         // Add secret token as query parameter as fallback (some services don't support custom headers)
         $url = add_query_arg('siteskite_key', $current_token, $url);
+        // Add cache-busting parameters to prevent caching on heavily cached hosting
+        // siteskite_cron=1: Identifier for cache exclusion rules
+        // nocache=<timestamp>: Unique timestamp to ensure each request is unique
+        $url = add_query_arg([
+            'siteskite_cron' => '1',
+            'nocache' => time()
+        ], $url);
         return $url;
+    }

siteskite/trunk/includes/Cron/HybridCronManager.php

-                      r3420528
+                      r3445801
 use function maybe_unserialize;
 use function site_url;
+use function add_query_arg;
 /**
 …
     /**
      * Get WordPress cron URL with secure SiteSkite token
+     * Format: wp-cron.php?doing_wp_cron&siteskite_key=SECURE_TOKEN
+     * Format: wp-cron.php?doing_wp_cron&siteskite_key=SECURE_TOKEN&siteskite_cron=1&nocache=TIMESTAMP
+     * Includes cache-busting parameters to prevent caching on heavily cached hosting
      */
     public function get_wp_cron_url(): string
+    {
         $secret_token = $this->external_cron_manager->get_secret_token();
+        return site_url('wp-cron.php?doing_wp_cron&siteskite_key=' . urlencode($secret_token));
+        $url = site_url('wp-cron.php');
+        // Add WordPress cron trigger parameter
+        $url = add_query_arg('doing_wp_cron', '', $url);
+        // Add secret token for authentication
+        $url = add_query_arg('siteskite_key', $secret_token, $url);
+        // Add cache-busting parameters to prevent caching on heavily cached hosting
+        // siteskite_cron=1: Identifier for cache exclusion rules
+        // nocache=<timestamp>: Unique timestamp to ensure each request is unique
+        $url = add_query_arg([
+            'siteskite_cron' => '1',
+            'nocache' => time()
+        ], $url);
+        return $url;
+    }

siteskite/trunk/includes/Restore/RestoreManager.php

-                      r3431615
+                      r3445801
             // Cleanup
             wp_delete_file($sql_file);
+            /**
+             * Important: a database restore can import the plugin's own status/options table rows
+             * (including `siteskite_restore_*`). That can overwrite the in-memory/previous restore
+             * status and scope (e.g. setting scope back to 'full'), which causes completion
+             * notifications to be suppressed for standalone database restores.
+             *
+             * Reset the restore status option right before the terminal status update so the
+             * notification logic uses the current scope ('database') and reliably fires.
+             */
+            delete_option(self::OPTION_PREFIX . $backup_id);
             // Update final status (suppress notification if this is an intermediate step in full restore)

siteskite/trunk/languages/siteskite.pot

r3445137	r3445801
2	2	msgid ""
3	3	msgstr ""
4		"Project-Id-Version: SiteSkite Link 1.2.1\n"
	4	"Project-Id-Version: SiteSkite Link 1.2.2\n"
5	5	"Report-Msgid-Bugs-To: https://wordpress.org/support/plugin/siteskite\n"
6	6	"POT-Creation-Date: 2024-01-01T00:00:00+00:00\n"

siteskite/trunk/readme.txt

-                      r3445142
+                      r3445801
 Tested up to: 6.9
 Requires PHP: 7.4
 Stable tag: 1.2.1
+Stable tag: 1.2.2
 License: GPLv2 or later
 License URI: https://www.gnu.org/licenses/gpl-2.0.html
 …
 ✔️ Roll back plugin/theme versions safely
 ✔️ Add team members & organize sites into workspaces
 ✔️ Use professional WP tools (Maintenance mode, Debug, Search & Replace, Indexing control, WP Reset & more)
+✔️ WP Canvas (Maintenance mode, Debug, Search & Replace, Indexing control, WP Reset & more)
 ✔️ Manage WP Admin Users & Roles
 ✔️ Track Core Web Vitals performance
 …
 == Changelog ==
+= 1.2.2 (22 January 2026) =
+* Improved: Backup PCLZIP Support
+* Improved: Backup performance on caching servers
+* Improved: Site Connection Experience
 = 1.2.1 (22 January 2026) =
 * Improved: Backup stability

siteskite/trunk/siteskite-link.php

-                      r3445137
+                      r3445801
  * Plugin URI: https://siteskite.com
  * Description: Link your WordPress site with SiteSkite for effortless updates, backups, monitoring, and maintenance—everything in one place.
  * Version: 1.2.1
+ * Version: 1.2.2
  * Requires at least: 5.3
  * Requires PHP: 7.4
 …
 // Plugin version
 define('SITESKITE_VERSION', '1.2.1');
+define('SITESKITE_VERSION', '1.2.2');
 // Plugin file, path, and URL

Note: See TracChangeset for help on using the changeset viewer.

Trac UI Preferences

Download in other formats: