Context Navigation

← Previous Changeset
Next Changeset →

Changeset 3453079

Timestamp:

02/03/2026 04:52:49 PM (5 weeks ago)

Author:

siteskite

Message:

Release 1.2.5 - PclZip fallback for restore when ZipArchive unavailable

Location:

siteskite/trunk

Files:

: 2 added
: 14 edited

assets/img/recover-mode.svg (added)
includes/API/FallbackAPI.php (modified) (8 diffs)
includes/API/RestAPI.php (modified) (2 diffs)
includes/Backup/BackupManager.php (modified) (19 diffs)
includes/Cleanup/CleanupManager.php (modified) (6 diffs)
includes/Core/Activator.php (modified) (1 diff)
includes/Core/AutoLoginController.php (modified) (5 diffs)
includes/Core/Plugin.php (modified) (6 diffs)
includes/Core/SiteSkiteSafetyCore.php (added)
includes/Cron/CronTriggerHandler.php (modified) (7 diffs)
includes/Cron/ExternalCronManager.php (modified) (3 diffs)
includes/Restore/RestoreManager.php (modified) (47 diffs)
languages/siteskite.pot (modified) (1 diff)
readme.txt (modified) (6 diffs)
siteskite-link.php (modified) (2 diffs)
uninstall.php (modified) (1 diff)

Legend:

: Unmodified
: Added
: Removed

siteskite/trunk/includes/API/FallbackAPI.php

-                      r3445801
+                      r3453079
 use SiteSkite\Schedule\ScheduleManager;
 use SiteSkite\WPCanvas\WPCanvasController;
+use SiteSkite\Cron\CronTriggerHandler;
 use WP_REST_Request;
 …
     private WPCanvasController $wp_canvas_controller;
     private RestAPI $rest_api;
+    private ?CronTriggerHandler $cron_trigger_handler;
     /**
 …
         RestoreManager $restore_manager,
         ScheduleManager $schedule_manager,
+        RestAPI $rest_api
+        RestAPI $rest_api,
+        ?CronTriggerHandler $cron_trigger_handler = null
     ) {
         $this->auth_manager = $auth_manager;
 …
         $this->schedule_manager = $schedule_manager;
         $this->rest_api = $rest_api;
+        $this->cron_trigger_handler = $cron_trigger_handler;
         $this->wp_canvas_controller = new WPCanvasController($this->logger, $this->auth_manager);
         $this->init();
 …
             // Create a mock WP_REST_Request from admin-ajax data
+            $rest_request = $this->create_rest_request($route, $method, $json_data);
+            // Verify authentication
+            $auth_result = $this->auth_manager->verify_request($rest_request);
+            if (is_wp_error($auth_result)) {
+                $this->logger->warning('Fallback API authentication failed', [
+                    'route' => $route,
+                    'error' => $auth_result->get_error_message()
+                ]);
+                ob_end_clean();
+                wp_send_json_error([
+                    'code' => $auth_result->get_error_code(),
+                    'message' => $auth_result->get_error_message(),
+                    'data' => ['status' => 401]
+                ], 401);
+                return;
+            // Pass raw JSON input for cron endpoints so they can parse the body correctly
+            $is_cron_endpoint = strpos($route, '/cron/') === 0;
+            $rest_request = $this->create_rest_request($route, $method, $json_data, $is_cron_endpoint ? $json_input : null);
+            // Cron endpoints use different authentication (X-SiteSkite-Cron-Secret)
+            // Skip regular API key authentication for cron endpoints - they handle auth internally
+            if (!$is_cron_endpoint) {
+                // Verify authentication for non-cron endpoints
+                $auth_result = $this->auth_manager->verify_request($rest_request);
+                if (is_wp_error($auth_result)) {
+                    $this->logger->warning('Fallback API authentication failed', [
+                        'route' => $route,
+                        'error' => $auth_result->get_error_message()
+                    ]);
+                    ob_end_clean();
+                    wp_send_json_error([
+                        'code' => $auth_result->get_error_code(),
+                        'message' => $auth_result->get_error_message(),
+                        'data' => ['status' => 401]
+                    ], 401);
+                    return;
+                }
+            }
 …
      * Create a WP_REST_Request from admin-ajax data
      */
     private function create_rest_request(string $route, string $method, ?array $json_data = null): WP_REST_Request
+    private function create_rest_request(string $route, string $method, ?array $json_data = null, ?string $raw_body = null): WP_REST_Request
+    {
         $request = new WP_REST_Request($method, '/' . self::API_NAMESPACE . $route);
 …
+        }
+        return $request;
+        // Extract and set X-SiteSkite-Cron-Secret header for cron endpoints
+        // PHP converts headers to uppercase in $_SERVER: X-SiteSkite-Cron-Secret -> HTTP_X_SITESKITE_CRON_SECRET
+        $cron_secret = null;
+        // Check $_SERVER directly first (most reliable)
+        if (isset($_SERVER['HTTP_X_SITESKITE_CRON_SECRET'])) {
+            $cron_secret = $_SERVER['HTTP_X_SITESKITE_CRON_SECRET'];
+        } else {
+            // Check converted headers array (case-insensitive search)
+            foreach ($headers as $header_name => $header_value) {
+                if (strcasecmp($header_name, 'X-SiteSkite-Cron-Secret') === 0) {
+                    $cron_secret = $header_value;
+                    break;
+                }
+            }
+        }
+        if ($cron_secret) {
+            // Set header with exact case that handler expects
+            $request->add_header('X-SiteSkite-Cron-Secret', $cron_secret);
+        }
+        // For cron endpoints, set the raw body so get_body() and get_json_params() work correctly
+        // This is needed because CronTriggerHandler uses these methods to parse the JSON body
+        if ($raw_body !== null && !empty($raw_body)) {
+            $request->set_body($raw_body);
+        }
+        return $request;
+    }
 …
             '/schedule/cleanup' => [[$this->schedule_manager, 'cleanup_all'], ['POST']],
         ];
+        // Add cron endpoints if handler is available
+        if ($this->cron_trigger_handler) {
+            $routes['/cron/trigger'] = [[$this->cron_trigger_handler, 'handle_trigger'], ['POST']];
+            $routes['/cron/check-continuity'] = [[$this->cron_trigger_handler, 'handle_continuity_check'], ['GET']];
+        }
         // Check if route exists

siteskite/trunk/includes/API/RestAPI.php

-                      r3431615
+                      r3453079
+                    ]
+                ]
+            ]
+        );
+        // Disable recovery mode (and clear restore-in-progress state). Use when user wants to go back to normal without restoring.
+        register_rest_route(
+            self::API_NAMESPACE,
+            '/recovery/disable',
+            [
+                'methods'             => WP_REST_Server::CREATABLE,
+                'callback'            => [$this, 'handle_recovery_disable'],
+                'permission_callback' => [$this->auth_manager, 'verify_request'],
+            ]
         );
 …
      * Handle force cleanup of corrupted backups
      */
+    /**
+     * Disable recovery mode and clear restore-in-progress state so the site loads all plugins again.
+     * Call when the user wants to go back to normal without completing a restore.
+     */
+    public function handle_recovery_disable(\WP_REST_Request $request): \WP_REST_Response
+    {
+        $this->restore_manager->clear_recovery_and_restore_state();
+        return new \WP_REST_Response([
+            'success' => true,
+            'message' => 'Recovery mode disabled. Next request will load all plugins.',
+        ], 200);
+    }
     public function handle_force_cleanup(\WP_REST_Request $request): \WP_REST_Response
+    {

siteskite/trunk/includes/Backup/BackupManager.php

-                      r3446096
+                      r3453079
         // Dependencies
         'node_modules',
-        'vendor',
         // IDE/Editor files
 …
         'wp-content/cache',
         'wp-content/uploads/cache',
-        'wp-content/cache/w3tc',
-        'wp-content/cache/wp-rocket',
-        'wp-content/cache/wp-super-cache',
-        'wp-content/cache/hyper-cache',
-        'wp-content/cache/comet-cache',
-        'wp-content/cache/endurance-page-cache',
-        'wp-content/cache/supercache',
-        'wp-content/cache/breeze',
-        'wp-content/cache/wp-optimize',
-        'wp-content/cache/autoptimize',
-        'wp-content/cache/fastest-cache',
-        'wp-content/cache/hummingbird',
-        'wp-content/cache/rocket',
-        'wp-content/cache/wp-fastest-cache',
-        'wp-content/cache/wp-super-cache',
-        'wp-content/cache/wp-cache',
-        'wp-content/cache/wp-minify',
-        'wp-content/cache/wp-ffpc',
-        'wp-content/cache/wp-file-cache',
-        'wp-content/cache/wp-object-cache',
-        'wp-content/cache/wp-total-cache',
-        'wp-content/cache/wp-w3tc',
-        'wp-content/cache/wp-w3-total-cache',
-        'wp-content/cache/wp-wp-super-cache',
-        'wp-content/cache/wp-wp-rocket',
-        'wp-content/cache/wp-litespeed',
-        'wp-content/cache/wp-breeze',
-        'wp-content/cache/wp-fastest',
-        'wp-content/cache/wp-hummingbird',
-        'wp-content/cache/wp-optimize',
-        'wp-content/cache/wp-autoptimize',
-        'wp-content/cache/wp-fastest-cache',
-        'wp-content/cache/wp-rocket',
-        'wp-content/cache/wp-super-cache',
-        'wp-content/cache/wp-w3tc',
-        'wp-content/cache/wp-w3-total-cache',
-        'wp-content/cache/wp-wp-super-cache',
-        'wp-content/cache/wp-wp-rocket',
-        'wp-content/cache/wp-litespeed',
-        'wp-content/cache/wp-breeze',
-        'wp-content/cache/wp-fastest',
-        'wp-content/cache/wp-hummingbird',
-        'wp-content/cache/wp-optimize',
-        'wp-content/cache/wp-autoptimize',
         'wp-content/nginx_cache',
 …
         // Temporary files
         '*.tmp',
+        '*.blob',
+        '*.zip',
+        '*.rar',
+        '*.7z',
+        '*.tar',
+        '*.gz',
+        '*.bz2',
+        '*.xz',
+        '*.git',
+        '*.tar.gz',
+        '*.tar.bz2',
+        '*.tar.xz',
+        '*.wpress',
+        '*.sgbp',
         '*.log',
+        'debug.log',
+        'error_log',
+        'backwpup',
+        "*.sql",
         '*.cache',
         '*.swp',
 …
         // Session files
         'wp-content/uploads/sess_',
+        'wp-content/uploads/sess_*',
         'wp-content/sessions',
 …
         if ($hook === 'siteskite_incremental_continue') {
             if ($this->external_cron_manager && $this->external_cron_manager->is_enabled()) {
+                // Normalize args to canonical [backup_id] so create/lookup/delete use the same key (prevents duplicate jobs)
+                $incremental_backup_id = $args[0] ?? $args['backup_id'] ?? null;
+                $canonical_args = $incremental_backup_id !== null ? [$incremental_backup_id] : $args;
                 // Check if job already exists to prevent duplicates
                 $existing_job_id = $this->external_cron_manager->get_job_id_by_action($hook, $args);
+                $existing_job_id = $this->external_cron_manager->get_job_id_by_action($hook, $canonical_args);
                 if ($existing_job_id) {
                     $this->logger->debug('Incremental continue recurring job already exists, skipping creation', [
 …
                     return;
+                }
                 // Use recurring job that runs every minute until work is complete
                 // The handler will automatically clean up the job when backup is complete
                 $job_id = $this->external_cron_manager->create_recurring_job(
                     $hook,
                     $args,
+                    $canonical_args,
                     'every_minute', // Run every minute
                     [],
 …
                 if ($this->external_cron_manager && $this->external_cron_manager->is_enabled()) {
+                    // Check both flag and external cron manager to prevent duplicates
+                    $existing_job_id = $this->external_cron_manager->get_job_id_by_action('process_database_backup_cron', ['backup_id' => $backup_id]);
+                    // Check both flag and external cron manager to prevent duplicates.
+                    // Use same args as stored at backup start (backup_id + callback_url) so we find the existing job.
+                    $lookup_args = ['backup_id' => $backup_id, 'callback_url' => $callback_url];
+                    $existing_job_id = $this->external_cron_manager->get_job_id_by_action('process_database_backup_cron', $lookup_args);
                     if (!$cron_job_scheduled_db && !$existing_job_id) {
                         $job_id = $this->external_cron_manager->create_recurring_job(
                             'process_database_backup_cron',
                             ['backup_id' => $backup_id, 'callback_url' => $callback_url],
+                            $lookup_args,
                             'every_minute',
                             [],
 …
             if ($this->external_cron_manager && $this->external_cron_manager->is_enabled()) {
+                // Check both flag and external cron manager to prevent duplicates
+                $existing_job_id = $this->external_cron_manager->get_job_id_by_action('process_files_backup_cron', ['backup_id' => $backup_id]);
+                // Check both flag and external cron manager to prevent duplicates.
+                // Use same args as stored at backup start (backup_id + callback_url) so we find the existing job.
+                $lookup_args = ['backup_id' => $backup_id, 'callback_url' => $callback_url];
+                $existing_job_id = $this->external_cron_manager->get_job_id_by_action('process_files_backup_cron', $lookup_args);
                 if (!$cron_job_scheduled_files && !$existing_job_id) {
                     $job_id = $this->external_cron_manager->create_recurring_job(
                         'process_files_backup_cron',
                         ['backup_id' => $backup_id, 'callback_url' => $callback_url],
+                        $lookup_args,
                         'every_minute',
                         [],
 …
             if (!$all_files_processed) {
+                // Files backup not complete - recurring cron job is already active
+                // It will continue processing in the next run
+                // Files backup not complete - recurring external cron job will continue
                 $this->logger->info('Files backup not complete, recurring cron will continue', [
                     'backup_id' => $backup_id,
 …
             // Determine ordering/PK information
+            // Use SHOW KEYS without WHERE/LIMIT (MariaDB does not support LIMIT on SHOW) and filter in PHP
             $order_column = $column_names[0];
+            $primary_key_rows = $wpdb->get_results("SHOW KEYS FROM `{$current_table_name}` WHERE Key_name = 'PRIMARY'", ARRAY_A);
+            $all_keys = $wpdb->get_results("SHOW KEYS FROM `{$current_table_name}`", ARRAY_A);
+            $primary_key_rows = $all_keys ? array_values(array_filter($all_keys, function ($r) {
+                return ($r['Key_name'] ?? '') === 'PRIMARY';
+            })) : [];
             $has_primary_key = !empty($primary_key_rows);
             $is_composite_pk = $has_primary_key && count($primary_key_rows) > 1;
 …
             // 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
+            );
+            $unique_key_rows = $all_keys ? array_values(array_filter($all_keys, function ($r) {
+                return (int)($r['Non_unique'] ?? 1) === 0 && ($r['Key_name'] ?? '') !== 'PRIMARY';
+            })) : [];
             $has_single_column_unique = false;
             $unique_key_column = null;
 …
             } 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
+                );
+                $unique_key = !empty($unique_key_rows) ? $unique_key_rows[0] : null;
                 if ($unique_key && !empty($unique_key['Column_name'])) {
                     $order_column = $unique_key['Column_name'];
 …
                         $existingBlobs = glob($subdir . '/*.blob');
                         foreach ($existingBlobs as $existingBlob) {
                             // Quick size check first (faster than full content comparison)
                             if (filesize($existingBlob) !== strlen($chunk)) {
+                              // Quick size check first (faster than full content comparison); skip if file gone (e.g. race with restore)
+                              if (!is_readable($existingBlob) || filesize($existingBlob) !== strlen($chunk)) {
                                 continue;
+                            }
 …
             // When no chunks to upload, check if file scan is complete and if backup should be completed
             $scan_progress_key = SITESKITE_OPTION_PREFIX . 'files_scan_progress_' . $backup_id;
+            $all_file_paths_key = SITESKITE_OPTION_PREFIX . 'all_file_paths_' . $backup_id;
             $scan_progress = get_option($scan_progress_key);
+            $scan_completed = $scan_progress && is_array($scan_progress) && ($scan_progress['scan_completed'] ?? false);
+            // If scan_progress option doesn't exist, check if all_file_paths was also deleted
+            // Both are deleted when scan completes, so if both are missing, scan is complete
+            if (!$scan_progress || !is_array($scan_progress)) {
+                $all_file_paths = get_option($all_file_paths_key);
+                // If both options are deleted/missing, scan was completed and cleaned up
+                $scan_completed = ($all_file_paths === false);
+            } else {
+                $scan_completed = (bool)($scan_progress['scan_completed'] ?? false);
+            }
             if ($scan_completed) {
 …
             } else {
                 // Scan not complete - log that scan needs to finish first
+                $files_processed = (int)($scan_progress['files_processed'] ?? 0);
+                $processed_paths = (array)($scan_progress['processed_paths'] ?? []);
+                $all_file_paths_key = SITESKITE_OPTION_PREFIX . 'all_file_paths_' . $backup_id;
+                $all_file_paths = get_option($all_file_paths_key, []);
+                $total_files = count($all_file_paths);
+                $remaining_files = $total_files - count($processed_paths);
+                if ($scan_progress && is_array($scan_progress)) {
+                    $files_processed = (int)($scan_progress['files_processed'] ?? 0);
+                    $processed_paths = (array)($scan_progress['processed_paths'] ?? []);
+                    $all_file_paths = get_option($all_file_paths_key, []);
+                    $total_files = count($all_file_paths);
+                    $remaining_files = $total_files - count($processed_paths);
+                } else {
+                    // Scan progress option doesn't exist but scan is not complete
+                    // This shouldn't happen, but handle gracefully
+                    $files_processed = 0;
+                    $total_files = 0;
+                    $remaining_files = 0;
+                }
                 $this->logger->info('No chunks to upload but scan not complete, scan will continue', [
 …
+            }
+            // Preserve backup info for completed backups so progress endpoint can still return status
+            // Only delete if backup is not completed
+            $backup_info = get_option(self::OPTION_PREFIX . $backup_id);
+            $is_completed = $backup_info && isset($backup_info['status']) && $backup_info['status'] === 'completed';
+            if (!$is_completed) {
+                if (\delete_option(self::OPTION_PREFIX . $backup_id)) {
+                    $deleted_options[] = 'backup_info';
+                }
+            } else {
+                // Keep backup info for completed backups, but mark it as cleaned up
+                $this->logger->debug('Preserving backup info for completed backup', [
+                    'backup_id' => $backup_id,
+                    'status' => $backup_info['status'] ?? 'unknown'
+                ]);
+            // Clean up SQL dump path option (if it still exists)
+            $sqlDumpKey = SITESKITE_OPTION_PREFIX . 'db_dump_path_' . $backup_id;
+            if (\delete_option($sqlDumpKey)) {
+                $deleted_options[] = 'db_dump_path';
+            }
+            // Clean up upload tracking flags (if they exist for incremental backups)
+            if (\delete_option(SITESKITE_OPTION_PREFIX . 'full_uploaded_' . $backup_id)) {
+                $deleted_options[] = 'full_uploaded';
+            }
+            if (\delete_option(SITESKITE_OPTION_PREFIX . 'files_uploaded_' . $backup_id)) {
+                $deleted_options[] = 'files_uploaded';
+            }
+            if (\delete_option(SITESKITE_OPTION_PREFIX . 'database_uploaded_' . $backup_id)) {
+                $deleted_options[] = 'database_uploaded';
+            }
+            // Clean up pending upload options (pattern: siteskite_pending_upload_{backup_id}_{provider})
+            global $wpdb;
+            $pending_upload_pattern = SITESKITE_OPTION_PREFIX . 'pending_upload_' . $backup_id . '_%';
+            $pending_upload_options = $wpdb->get_col($wpdb->prepare(
+                "SELECT option_name FROM {$wpdb->options} WHERE option_name LIKE %s",
+                $pending_upload_pattern
+            ));
+            foreach ($pending_upload_options as $option_name) {
+                if (\delete_option($option_name)) {
+                    $deleted_options[] = basename($option_name);
+                }
+            }
+            // Remove backup status option (same as classic backup cleanup)
+            // Progress endpoint can still access completed backup info via cloud manifests fallback
+            if (\delete_option(self::OPTION_PREFIX . $backup_id)) {
+                $deleted_options[] = 'backup_info';
+            }
 …
+            }
+            // Clean up hybrid cron job options (pattern: siteskite_hybrid_cron_*)
+            // Get all options and filter for hybrid cron jobs for this backup
+            $hybrid_cron_pattern = SITESKITE_OPTION_PREFIX . 'hybrid_cron_%';
+            $hybrid_cron_options = $wpdb->get_col($wpdb->prepare(
+                "SELECT option_name FROM {$wpdb->options} WHERE option_name LIKE %s",
+                $hybrid_cron_pattern
+            ));
+            foreach ($hybrid_cron_options as $option_name) {
+                // Check if this hybrid cron option is related to this backup
+                // Hybrid cron options may contain backup_id or be associated with it
+                $option_value = \get_option($option_name);
+                if (is_array($option_value) && isset($option_value['backup_id']) && $option_value['backup_id'] === $backup_id) {
+                    if (\delete_option($option_name)) {
+                        $deleted_options[] = basename($option_name);
+                    }
+                } elseif (strpos($option_name, $backup_id) !== false) {
+                    // If backup_id appears in option name, delete it
+                    if (\delete_option($option_name)) {
+                        $deleted_options[] = basename($option_name);
+                    }
+                }
+            }
             // Runtime and throttling transients
             if (function_exists('delete_transient')) {
 …
         if ($requires_files) {
             $scan_progress_key = SITESKITE_OPTION_PREFIX . 'files_scan_progress_' . $backup_id;
+            $all_file_paths_key = SITESKITE_OPTION_PREFIX . 'all_file_paths_' . $backup_id;
             $scan_progress = get_option($scan_progress_key);
+            if ($scan_progress && is_array($scan_progress)) {
+            // If scan_progress option doesn't exist, check if all_file_paths was also deleted
+            // Both are deleted when scan completes, so if both are missing, scan is complete
+            if (!$scan_progress || !is_array($scan_progress)) {
+                $all_file_paths = get_option($all_file_paths_key);
+                // If both options are deleted/missing, scan was completed and cleaned up
+                $scan_completed = ($all_file_paths === false);
+            } else {
                 $scan_completed = (bool)($scan_progress['scan_completed'] ?? false);
+                if (!$scan_completed) {
+            }
+            if (!$scan_completed) {
+                if ($scan_progress && is_array($scan_progress)) {
                     $files_processed = (int)($scan_progress['files_processed'] ?? 0);
                     $processed_paths = (array)($scan_progress['processed_paths'] ?? []);
-                    $all_file_paths_key = SITESKITE_OPTION_PREFIX . 'all_file_paths_' . $backup_id;
                     $all_file_paths = get_option($all_file_paths_key, []);
                     $total_files = count($all_file_paths);
+                    $this->logger->info('Cannot check completion: file scan not complete', [
+                        'backup_id' => $backup_id,
+                        'provider' => $provider,
+                        'backup_type' => $backup_type,
+                        'scan_completed' => $scan_completed,
+                        'files_processed' => $files_processed,
+                        'total_files' => $total_files,
+                        'remaining_files' => $total_files - count($processed_paths),
+                        'note' => 'File scan must be complete before backup can be marked as complete'
+                    ]);
+                    return false;
+                }
+                    $remaining_files = $total_files - count($processed_paths);
+                } else {
+                    // Scan progress option doesn't exist but scan is not complete
+                    // This shouldn't happen, but handle gracefully
+                    $files_processed = 0;
+                    $total_files = 0;
+                    $remaining_files = 0;
+                }
+                $this->logger->info('Cannot check completion: file scan not complete', [
+                    'backup_id' => $backup_id,
+                    'provider' => $provider,
+                    'backup_type' => $backup_type,
+                    'scan_completed' => $scan_completed,
+                    'files_processed' => $files_processed,
+                    'total_files' => $total_files,
+                    'remaining_files' => $remaining_files,
+                    'note' => 'File scan must be complete before backup can be marked as complete'
+                ]);
+                return false;
+            }
+        }
 …
                                 continue;
+                            }
+                            if (!is_readable($blobFile)) {
+                                continue;
+                            }
                             $chunksToUpload[$chunkHash] = [

siteskite/trunk/includes/Cleanup/CleanupManager.php

-                      r3443472
+                      r3453079
             $log_count = $this->cleanup_log_files();
+            // Clean up old manifest files
+            // Clean up classic backup manifest files (e.g. siteskite_backup_XXX_files.manifest)
+            $classic_manifest_count = $this->cleanup_classic_manifest_files();
+            // Clean up old manifest files (incremental manifests in uploads/siteskite-backups/manifests)
             $manifest_count = $this->cleanup_old_manifests();
 …
                 'backup_files' => $backup_count,
                 'log_files' => $log_count,
+                'classic_manifest_files' => $classic_manifest_count,
                 'manifest_files' => $manifest_count
             ]);
 …
     /**
+     * Clean up classic backup manifest files (e.g. siteskite_backup_XXX_files.manifest)
+     * from the backup directory when the siteskite cleanup cron runs.
+     */
+    private function cleanup_classic_manifest_files(): int {
+        $cleaned_count = 0;
+        $files = glob($this->backup_dir . '/*.manifest');
+        if ($files) {
+            foreach ($files as $file) {
+                if (file_exists($file) && wp_delete_file($file)) {
+                    $cleaned_count++;
+                    $this->logger->debug('Deleted classic manifest file', [
+                        'file' => basename($file)
+                    ]);
+                } else {
+                    $this->logger->warning('Failed to delete classic manifest file', [
+                        'file' => basename($file)
+                    ]);
+                }
+            }
+        }
+        return $cleaned_count;
+    }
+    /**
      * Clean up log files
      */
 …
      * Clean up backup files and logs
      */
     public function cleanup_backup(string $backup_id): void
+    {
 …
                         'file' => basename($file)
                     ]);
+                }
+            }
+            // Clean up classic backup manifest files (e.g. siteskite_backup_XXX_files.manifest)
+            $manifest_pattern = $this->backup_dir . '/' . $backup_id . '_*.manifest';
+            $manifest_files = glob($manifest_pattern);
+            if ($manifest_files) {
+                foreach ($manifest_files as $manifest_file) {
+                    if (file_exists($manifest_file) && wp_delete_file($manifest_file)) {
+                        $this->logger->debug('Removed manifest file', [
+                            'file' => basename($manifest_file)
+                        ]);
+                    }
+                }
+            }
 …
+        }
+    }
     /**
      * Clean up restore files and logs

siteskite/trunk/includes/Core/Activator.php

-                      r3389896
+                      r3453079
         // Flush rewrite rules
         flush_rewrite_rules();
+        // Ensure safety mu-plugin and recovery script exist (skips broken plugins, enables recovery when site is broken)
+        require_once __DIR__ . '/SiteSkiteSafetyCore.php';
+        SiteSkiteSafetyCore::ensure_exists();
+        SiteSkiteSafetyCore::ensure_recovery_script_exists();
+        SiteSkiteSafetyCore::ensure_recovery_disable_script_exists();
+        $api_key = get_option('siteskite_api_key', '');
+        if ($api_key !== '') {
+            $site_url = function_exists('home_url') ? home_url() : null;
+            SiteSkiteSafetyCore::write_recovery_key_file($api_key, $site_url);
+        }
+    }
+}

siteskite/trunk/includes/Core/AutoLoginController.php

-                      r3389896
+                      r3453079
 use function add_action;
+use function add_filter;
 use function admin_url;
 use function do_action;
+use function esc_html__;
 use function esc_url_raw;
 use function get_option;
 use function get_users;
+use function home_url;
 use function is_user_logged_in;
 use function is_wp_error;
 use function sanitize_text_field;
 use function wp_die;
-use function wp_redirect;
 use function wp_remote_get;
 use function wp_remote_retrieve_body;
+use function wp_safe_redirect;
 use function wp_set_auth_cookie;
 use function wp_set_current_user;
+use function wp_unslash;
 class AutoLoginController
+{
+    private const AUTOLOGIN_ENDPOINT = 'siteskite-autologin';
     public function register(): void
+    {
+        // Register custom autologin endpoint - fires early to bypass security plugins
+        add_action('init', [$this, 'add_rewrite_rule'], 1);
+        add_action('template_redirect', [$this, 'handle_autologin_endpoint'], 1);
+        // Legacy support: handle token on any page (lower priority)
         add_action('wp_loaded', [$this, 'maybe_auto_login']);
+        add_action('login_init', [$this, 'handle_token_login']);
+        add_action('wp_loaded', [$this, 'handle_token_login'], 5);
+    }
+    /**
+     * Add rewrite rule for custom autologin endpoint
+     */
+    public function add_rewrite_rule(): void
+    {
+        add_rewrite_rule(
+            '^' . self::AUTOLOGIN_ENDPOINT . '/?$',
+            'index.php?siteskite_autologin=1',
+            'top'
+        );
+        // Add query var for rewrite rule
+        add_filter('query_vars', function($vars) {
+            $vars[] = 'siteskite_autologin';
+            return $vars;
+        });
+    }
+    /**
+     * Handle the custom autologin endpoint
+     * Fires early via template_redirect to bypass security plugins
+     */
+    public function handle_autologin_endpoint(): void
+    {
+        // Check if this is our autologin endpoint
+        $request_uri = isset($_SERVER['REQUEST_URI']) ? sanitize_text_field(wp_unslash($_SERVER['REQUEST_URI'])) : '';
+        $is_autologin_endpoint = false;
+        // Check rewrite rule query var
+        if (get_query_var('siteskite_autologin') === '1') {
+            $is_autologin_endpoint = true;
+        }
+        // Fallback: check request URI directly (works even if rewrite rules aren't flushed)
+        elseif (strpos($request_uri, '/' . self::AUTOLOGIN_ENDPOINT) !== false) {
+            $is_autologin_endpoint = true;
+        }
+        if (!$is_autologin_endpoint) {
+            return;
+        }
+        // Handle the autologin
+        $this->process_autologin();
+    }
+    /**
+     * Get the appropriate admin redirect URL, compatible with  Security Hide Backend
+     *
+     *
+     * @return string Admin dashboard URL or home URL as fallback
+     */
+    private function get_admin_redirect_url(): string
+    {
+        // Check if  Security ( Security) Hide Backend is enabled
+        $hide_backend_enabled = false;
+        $custom_login_slug = '';
+        // Check for  Security /  Security settings
+        //  Security stores settings in '' option
+        $itsec_settings = get_option('itsec_settings', []);
+        if (is_array($itsec_settings) && !empty($itsec_settings)) {
+            // Check for hide-backend module
+            if (isset($itsec_settings['hide-backend']['enabled']) && $itsec_settings['hide-backend']['enabled'] === true) {
+                $hide_backend_enabled = true;
+                // Get custom login slug if set
+                if (isset($itsec_settings['hide-backend']['slug'])) {
+                    $custom_login_slug = sanitize_text_field($itsec_settings['hide-backend']['slug']);
+                }
+            }
+        }
+        // After successful authentication, redirect to admin dashboard
+        //  Security only blocks unauthenticated access, not authenticated users
+        // So admin_url() will work fine for logged-in users
+        $admin_url = admin_url();
+        // If custom login slug exists and we want to be extra safe, we could construct:
+        // home_url('/' . $custom_login_slug) but this is the login URL, not admin
+        // Since user is already authenticated, admin_url() is the correct destination
+        return $admin_url;
+    }
 …
                 wp_set_current_user($user->ID, $user->user_login);
                 do_action('wp_login', $user->user_login, $user);
+                wp_redirect(admin_url());
+                // Get redirect URL - compatible with  Security Hide Backend
+                // After authentication, admin_url() works fine since authenticated users aren't blocked
+                $redirect_url = $this->get_admin_redirect_url();
+                // Allow redirect parameter if provided (takes priority)
+                if (isset($_GET['redirect']) && !empty($_GET['redirect'])) {
+                    $custom_redirect = esc_url_raw(wp_unslash($_GET['redirect']));
+                    // Validate that it's an absolute URL
+                    if (filter_var($custom_redirect, FILTER_VALIDATE_URL)) {
+                        $redirect_url = $custom_redirect;
+                    }
+                }
+                wp_safe_redirect($redirect_url);
                 exit;
+            }
 …
+    }
+    public function handle_token_login(): void
+    {
+    /**
+     * Process autologin with token validation
+     * Centralized method used by both endpoint and legacy token handler
+     */
+    private function process_autologin(): void
+    {
+        // Check if user is already logged in
+        if (is_user_logged_in()) {
+            // Already logged in, redirect to admin
+            $redirect_url = $this->get_admin_redirect_url();
+            if (isset($_GET['redirect']) && !empty($_GET['redirect'])) {
+                $custom_redirect = esc_url_raw(wp_unslash($_GET['redirect']));
+                if (filter_var($custom_redirect, FILTER_VALIDATE_URL)) {
+                    $redirect_url = $custom_redirect;
+                }
+            }
+            wp_safe_redirect($redirect_url);
+            exit;
+        }
+        // Check for token parameter
         // phpcs:ignore WordPress.Security.NonceVerification.Recommended
+        if (!isset($_GET['token'])) {
+            return;
+        if (!isset($_GET['token']) || empty($_GET['token'])) {
+            wp_die(
+                esc_html__('Token parameter is required. Usage: /siteskite-autologin?token=YOUR_TOKEN', 'siteskite'),
+                esc_html__('Missing Token', 'siteskite'),
+                ['response' => 400]
+            );
+        }
 …
         $stored_token = get_option('siteskite_api_key', '');
+        if (empty($stored_token)) {
+            wp_die(
+                esc_html__('Auto-login is not configured. Please set your API key in SiteSkite settings.', 'siteskite'),
+                esc_html__('Configuration Error', 'siteskite'),
+                ['response' => 500]
+            );
+        }
         if ($token !== $stored_token) {
+            wp_die(esc_html__('Invalid token. Please try again.', 'siteskite'));
+            wp_die(
+                esc_html__('Invalid token. Please check your token and try again.', 'siteskite'),
+                esc_html__('Invalid Token', 'siteskite'),
+                ['response' => 403]
+            );
+        }
 …
         if (empty($admin_users)) {
+            wp_die(esc_html__('No administrator user found to log in.', 'siteskite'));
+            wp_die(
+                esc_html__('No administrator user found to log in.', 'siteskite'),
+                esc_html__('User Error', 'siteskite'),
+                ['response' => 500]
+            );
+        }
         $user = $admin_users[0];
         wp_set_current_user($user->ID);
+        wp_set_auth_cookie($user->ID);
+        wp_redirect(admin_url());
+        wp_set_auth_cookie($user->ID, true);
+        do_action('wp_login', $user->user_login, $user);
+        // Get redirect URL - compatible with  Security Hide Backend
+        // After authentication, admin_url() works fine since authenticated users aren't blocked
+        $redirect_url = $this->get_admin_redirect_url();
+        // Allow redirect parameter if provided (takes priority)
+        if (isset($_GET['redirect']) && !empty($_GET['redirect'])) {
+            $custom_redirect = esc_url_raw(wp_unslash($_GET['redirect']));
+            // Validate that it's an absolute URL
+            if (filter_var($custom_redirect, FILTER_VALIDATE_URL)) {
+                $redirect_url = $custom_redirect;
+            }
+        }
+        wp_safe_redirect($redirect_url);
         exit;
+    }
+    /**
+     * Legacy token login handler - works on any page with ?token parameter
+     */
+    public function handle_token_login(): void
+    {
+        // Skip if already on autologin endpoint (handled by handle_autologin_endpoint)
+        $request_uri = isset($_SERVER['REQUEST_URI']) ? sanitize_text_field(wp_unslash($_SERVER['REQUEST_URI'])) : '';
+        if (strpos($request_uri, '/' . self::AUTOLOGIN_ENDPOINT) !== false) {
+            return;
+        }
+        // phpcs:ignore WordPress.Security.NonceVerification.Recommended
+        if (!isset($_GET['token'])) {
+            return;
+        }
+        // Use centralized autologin processor
+        $this->process_autologin();
+    }
+}

siteskite/trunk/includes/Core/Plugin.php

-                      r3431615
+                      r3453079
     private function init_components(): void {
         try {
+            // Ensure safety mu-plugin and recovery script exist (skips broken plugins, enables recovery when site is broken)
+            SiteSkiteSafetyCore::ensure_exists();
+            SiteSkiteSafetyCore::ensure_recovery_script_exists();
+            SiteSkiteSafetyCore::ensure_recovery_disable_script_exists();
+            // Upgrade recovery key file to include site_url if API key is set (so recovery auth works without re-saving)
+            $api_key = get_option('siteskite_api_key', '');
+            if ($api_key !== '' && function_exists('home_url')) {
+                SiteSkiteSafetyCore::write_recovery_key_file($api_key, home_url());
+            }
             $this->logger = new Logger();
             $this->progress_tracker = new ProgressTracker($this->logger);
 …
         add_action('admin_init', [$this, 'register_settings']);
         add_action('admin_enqueue_scripts', [$this, 'enqueue_admin_assets']);
+        add_action('admin_head', [$this, 'maybe_print_recovery_mode_admin_bar_styles'], 1);
+        add_action('wp_head', [$this, 'maybe_print_recovery_mode_admin_bar_styles'], 1);
+        // Keep recovery key file in sync with API key so recovery endpoint can validate without loading WordPress
+        add_action('update_option_siteskite_api_key', [$this, 'sync_recovery_key_file'], 10, 3);
         // Add global HTTP header augmentation for all outgoing plugin requests
 …
         ]);
+    }
+    /**
+     * Sync recovery key file when API key is updated so recovery endpoint can validate without loading WordPress.
+     *
+     * @param mixed $old_value Old option value
+     * @param mixed $value New option value
+     * @param string $option Option name
+     */
+    public function sync_recovery_key_file($old_value, $value, $option): void {
+        if ($option === 'siteskite_api_key' && is_string($value)) {
+            $site_url = function_exists('home_url') ? home_url() : null;
+            SiteSkiteSafetyCore::write_recovery_key_file($value, $site_url);
+        }
+    }
 …
             'disconnectFailed' => esc_html__('Failed to disconnect. Please try again.', 'siteskite')
         ]);
+    }
+    /**
+     * When recovery mode is active, print CSS to style the WordPress admin bar and sidebar green so users see they are in recovery mode.
+     */
+    public function maybe_print_recovery_mode_admin_bar_styles(): void {
+        if (! SiteSkiteSafetyCore::is_recovery_mode()) {
+            return;
+        }
+        $green = '#1d7a43';
+        $green_dark = '#166534';
+        ?>
+        <style id="siteskite-recovery-mode-styles">
+        /* Admin bar (top toolbar) */
+        <?php if (is_admin_bar_showing()) : ?>
+        #wpadminbar,
+        #wpadminbar .quicklinks .menupop ul {
+            background: <?php echo esc_attr($green); ?> !important;
+        }
+        #wpadminbar .ab-item,
+        #wpadminbar a.ab-item,
+        #wpadminbar > #wp-toolbar span.ab-label,
+        #wpadminbar > #wp-toolbar span.noticon {
+            color: #fff !important;
+        }
+        #wpadminbar .ab-item:hover,
+        #wpadminbar a.ab-item:hover,
+        #wpadminbar li:hover > .ab-item,
+        #wpadminbar li.hover > .ab-item {
+            background: <?php echo esc_attr($green_dark); ?> !important;
+            color: #fff !important;
+        }
+        #wpadminbar .menupop .ab-sub-wrapper {
+            background: <?php echo esc_attr($green); ?> !important;
+        }
+        #wpadminbar .ab-submenu .ab-item {
+            color: rgba(255,255,255,0.9) !important;
+        }
+        #wpadminbar:before {
+            content: '';
+            display: block;
+            position: absolute;
+            left: 0;
+            right: 0;
+            top: 0;
+            height: 3px;
+            background: #fff;
+            opacity: 0.4;
+        }
+        <?php endif; ?>
+        /* Admin sidebar (dashboard left menu) */
+        <?php if (is_admin()) : ?>
+        #adminmenuwrap,
+        #adminmenu,
+        #adminmenu .wp-submenu {
+            background: <?php echo esc_attr($green); ?> !important;
+        }
+        #adminmenu .wp-menu-name,
+        #adminmenu a.wp-has-current-submenu .wp-submenu .wp-submenu-head,
+        #adminmenu .wp-submenu a {
+            color: rgba(255,255,255,0.95) !important;
+        }
+        #adminmenu li.wp-has-submenu.wp-not-current-submenu:hover,
+        #adminmenu li.wp-has-submenu.wp-not-current-submenu.opensub:hover {
+            background: <?php echo esc_attr($green_dark); ?> !important;
+        }
+        #adminmenu li.current,
+        #adminmenu li.wp-has-current-submenu {
+            background: <?php echo esc_attr($green_dark); ?> !important;
+        }
+        #adminmenu .wp-menu-image:before {
+            color: rgba(255,255,255,0.9) !important;
+        }
+        #adminmenu a:hover .wp-menu-image:before,
+        #adminmenu li.current .wp-menu-image:before {
+            color: #fff !important;
+        }
+        #adminmenu .wp-submenu li:hover a {
+            color: #fff !important;
+        }
+        <?php endif; ?>
+        </style>
+        <?php
+    }
 …
                     $this->restore_manager,
                     $this->schedule_manager,
+                    $this->rest_api
+                    $this->rest_api,
+                    $this->cron_trigger_handler
                 );
 …
                     $this->restore_manager,
                     $this->schedule_manager,
+                    $this->rest_api
+                    $this->rest_api,
+                    $this->cron_trigger_handler
                 );

siteskite/trunk/includes/Cron/CronTriggerHandler.php

-                      r3431615
+                      r3453079
         try {
             // Enhanced security: Verify secret token from header or query parameter
+            // Check header with different case variations (case-insensitive matching)
             $header_secret = $request->get_header('X-SiteSkite-Cron-Secret');
+            if (empty($header_secret)) {
+                // Try lowercase version in case server normalizes headers
+                $header_secret = $request->get_header('X-Siteskite-Cron-Secret');
+            }
+            if (empty($header_secret)) {
+                // Try all lowercase
+                $header_secret = $request->get_header('x-siteskite-cron-secret');
+            }
             $query_secret = $request->get_param('siteskite_key');
 …
             $args = $body['args'] ?? [];
+            // Normalize incremental continue args to canonical [backup_id] so lookup/delete match stored job key (prevents duplicate jobs)
+            if ($action === 'siteskite_incremental_continue' && is_array($args)) {
+                $backup_id = $args[0] ?? $args['backup_id'] ?? null;
+                if ($backup_id !== null) {
+                    $args = [$backup_id];
+                }
+            }
             if (empty($action)) {
                 $this->logger->error('Missing action in cron trigger', [
 …
             // External cron handles scheduling directly
+            // Check if job should be deleted after successful run
+            if ($this->cron_manager->should_delete_after_first_run($action, $args)) {
+            // Never delete siteskite_incremental_continue after first run - it must keep running until backup completion cleanup
+            $is_incremental_continue = ($action === 'siteskite_incremental_continue');
+            $should_delete = !$is_incremental_continue && $this->cron_manager->should_delete_after_first_run($action, $args);
+            if ($should_delete) {
                 $job_id = $this->cron_manager->get_job_id_by_action($action, $args);
                 if ($job_id) {
 …
                 return $this->handle_incremental_restore($args);
             case 'siteskite_cleanup_restore_status':
                 return $this->handle_restore_cleanup($args);
             case 'siteskite_cleanup_incremental_restore_records':
                 return $this->handle_incremental_restore_cleanup($args);
 …
      * Handle restore cleanup
      */
     private function handle_restore_cleanup(array $args): array
+    {
 …
         ];
+    }
     /**
      * Handle incremental restore records cleanup
 …
         try {
             // Enhanced security: Verify secret token from header or query parameter
+            // Check header with different case variations (case-insensitive matching)
             $secret = $request->get_header('X-SiteSkite-Cron-Secret');
+            if (empty($secret)) {
+                // Try lowercase version in case server normalizes headers
+                $secret = $request->get_header('X-Siteskite-Cron-Secret');
+            }
+            if (empty($secret)) {
+                // Try all lowercase
+                $secret = $request->get_header('x-siteskite-cron-secret');
+            }
             if (empty($secret)) {
                 $secret = $request->get_param('siteskite_key');

siteskite/trunk/includes/Cron/ExternalCronManager.php

-                      r3445801
+                      r3453079
         // For immediate execution (delay = 0), create recurring job that runs every 1 minute
         // This job will be deleted after first successful execution
+        // process_files_backup_cron must keep running every minute until backup completes - do NOT delete after first run
         if ($delay_seconds === 0) {
             $job_id = $this->create_recurring_job($action, $args, 'every_minute', [], $title);
+            // Mark job for deletion after first successful run
+            if ($job_id) {
+            // Mark job for deletion after first run only for one-off actions (not process_files_backup_cron)
+            $is_files_backup_continuation = ($action === 'process_files_backup_cron');
+            if ($job_id && !$is_files_backup_continuation) {
                 $key = $this->generate_job_key($action, $args);
                 $jobs = get_option(self::OPTION_JOBS, []);
 …
     /**
+    * Check if REST API is actually functional (not just that rest_url() works)
+    *
+    * @return bool True if REST API is functional, false otherwise
+    */
+   private function is_rest_api_functional(): bool
+   {
+       // Check if REST API is explicitly disabled via filter
+       if (has_filter('rest_enabled', '__return_false')) {
+           return false;
+       }
+       // Check if rest_api_init has fired (routes are registered)
+       // This is the most reliable indicator that REST API is actually working
+       // If rest_api_init hasn't fired, routes aren't registered yet, so REST API won't work
+       // even though rest_url() might still generate a URL
+       if (!did_action('rest_api_init')) {
+           return false;
+       }
+       // Check if REST API server class exists
+       if (!class_exists('WP_REST_Server')) {
+           return false;
+       }
+       // Check if REST API routes can be registered (check if rest_api_init hook has callbacks)
+       global $wp_filter;
+       if (isset($wp_filter['rest_api_init']) && empty($wp_filter['rest_api_init']->callbacks)) {
+           return false;
+       }
+       // If we get here, REST API should be functional
+       return true;
+   }
+    /**
      * Get trigger URL for action
      * Includes secret token as query parameter for services that don't support custom headers
 …
     private function get_trigger_url(string $action): string
+    {
+        $url = rest_url('siteskite/v1/cron/trigger');
+        // 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);
+              // Check if REST API is actually functional, otherwise use fallback admin-ajax endpoint
+            if ($this->is_rest_api_functional()) {
+                // Use REST API endpoint (JSON format)
+                $url = rest_url(\SiteSkite\API\RestAPI::API_NAMESPACE . '/cron/trigger');
+                $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
+                $url = add_query_arg([
+                    'siteskite_cron' => '1',
+                    'nocache' => time()
+                ], $url);
+            } else {
+                // Use fallback admin-ajax endpoint
+                $url = admin_url('admin-ajax.php');
+                $current_token = $this->get_secret_token();
+                // Add required parameters for fallback API
+                $url = add_query_arg([
+                    'action' => 'siteskite_api',
+                    'route' => '/cron/trigger',
+                    'siteskite_key' => $current_token,
+                    'siteskite_cron' => '1',
+                    'nocache' => time()
+                ], $url);
+            }
         return $url;

siteskite/trunk/includes/Restore/RestoreManager.php

-                      r3445801
+                      r3453079
     private const CHUNK_SIZE = 2 * 1024 * 1024; // 2MB chunks
     private const RESTORE_TIMEOUT = 300; // 5 minutes
+    /** Chunk size for streaming SQL import (1MB) - avoids loading 100MB+ dumps into memory */
+    private const DB_IMPORT_READ_CHUNK_BYTES = 1024 * 1024;
+    /** Retry transient DB errors (lock wait, timeout, connection) up to this many times per query */
+    private const DB_IMPORT_QUERY_RETRY_ATTEMPTS = 3;
+    /** Milliseconds to sleep between retries */
+    private const DB_IMPORT_QUERY_RETRY_SLEEP_MS = 500;
+    /** Extend time limit every N queries to prevent script timeout on large restores */
+    private const DB_IMPORT_EXTEND_TIME_LIMIT_EVERY = 500;
+    /** Flush wpdb and update progress every N queries */
+    private const DB_IMPORT_PROGRESS_INTERVAL = 250;
+    /** Max buffer size (bytes) - if exceeded, process up to last statement boundary to avoid OOM on huge single INSERT */
+    private const DB_IMPORT_MAX_BUFFER_BYTES = 20 * 1024 * 1024;
     private const OPTION_PREFIX = SITESKITE_OPTION_PREFIX . 'restore_';
     private const EXCLUDED_PATHS = [
 …
         'wp-content/uploads/siteskite-logs',
         'wp-content/debug.log',
         'wp-content/plugins/siteskite-link',
+        'wp-content/plugins/siteskite',
         'wp-content/upgrade',
         'wp-content/uploads/backup*',
 …
             update_option($restore_params_key, $restore_params);
+            // Clear webhook_sent for this backup/scope so when cron runs it doesn't see a previous run as "already completed"
+            // and skip the restore (fixes files-only / database-only incremental restore being interrupted by old webhook).
+            $this->prepare_incremental_restore_run($manifestId, $scope);
             // Initialize restore status
             $this->update_restore_status($manifestId, [
 …
             ], true);
+            // Clear webhook_sent for this backup/scope so the restore runs and isn't seen as "already completed".
+            // Without this, a previous run's webhook record (e.g. siteskite_restore_webhook_sent_*_files) can
+            // interrupt files-only (and database-only) incremental restores.
+            $this->prepare_incremental_restore_run($manifestId, $scope);
             switch ($scope) {
 …
             // Cleanup progress tracking data
             $this->clear_incremental_restore_progress($manifestId);
+            $this->clear_restore_in_progress_and_guard();
         } catch (\Throwable $e) {
+            $this->clear_restore_in_progress_and_guard();
             $this->logger->error('Incremental restore cron failed', [
                 'manifest_id' => $manifestId,
 …
             ]);
             // Package into a ZIP to reuse existing restore_database logic
+            // Package into a ZIP to reuse existing restore_database logic (ZipArchive or PclZip fallback)
             $zip_path = $this->restore_dir . '/incdb_' . $manifestId . '.zip';
+            $zip = new \ZipArchive();
+            if ($zip->open($zip_path, \ZipArchive::CREATE | \ZipArchive::OVERWRITE) !== true) {
+            try {
+                $this->create_zip_with_single_file($zip_path, $sql_path, basename($sql_path));
+            } catch (\RuntimeException $e) {
                 if (file_exists($sql_path)) {
                     wp_delete_file($sql_path);
+                }
+                throw new \RuntimeException('Failed to create ZIP for database incremental restore');
+            }
+            $zip->addFile($sql_path, basename($sql_path));
+            $zip->close();
+                throw new \RuntimeException('Failed to create ZIP for database incremental restore: ' . $e->getMessage());
+            }
             // Switch to restoring stage for database
 …
+        }
+        // Fail if any chunks are not in bundles
+        // Chunks not in bundle metadata: try fallback to single-blob download (objects_prefix/xx/hash.blob)
+        // Some manifests (e.g. parent with 0 bundles) or older backups may store chunks as standalone blobs
         if (!empty($chunksNotInBundles)) {
             $this->logger->error('Chunks not found in bundle metadata', [
+            $this->logger->warning('Some chunks not in bundle metadata, attempting fallback single-blob download', [
                 'chunks_not_in_bundles' => count($chunksNotInBundles),
                 'sample_hashes' => array_slice($chunksNotInBundles, 0, 5)
             ]);
-            throw new \RuntimeException('Some chunks are not available in bundles. Bundle metadata is required for restore.');
+        }
 …
                 // This matches how ObjectStore stores bundles: objects/sha256/{first2chars}/bundle_{hash}.zip
                 $bundlePath = $objects_prefix . '/' . substr($bundleHash, 0, 2) . '/' . $bundleKey . '.zip';
+                // Extra logging to debug hosting-specific path / download issues
+                $this->logger->info('Attempting to download bundle for incremental restore', [
+                    'provider'       => $provider,
+                    'bundle_hash'    => $bundleHash,
+                    'bundle_key'     => $bundleKey,
+                    'bundle_path'    => $bundlePath,
+                    'objects_prefix' => $objects_prefix,
+                    'chunks_in_bundle' => count($chunkHashes),
+                ]);
                 $bundleData = $this->download_object_from_provider($provider, $bundlePath, $request);
 …
+                }
                 file_put_contents($tempFile, $bundleData);
+                $this->logger->info('Bundle temp file created', [
+                    'bundle_hash' => $bundleHash,
+                    'temp_file'   => $tempFile,
+                    'file_exists' => file_exists($tempFile),
+                    'file_size'   => file_exists($tempFile) ? filesize($tempFile) : null,
+                    'sys_temp_dir'=> sys_get_temp_dir(),
+                ]);
                 $downloadedBundles[$bundleHash] = $tempFile;
                 $tempFiles[] = $tempFile;
 …
                 ]);
+                // Extract chunks from bundle
+                $zip = new \ZipArchive();
+                if ($zip->open($tempFile) === true) {
+                // Extract chunks from bundle (ZipArchive or PclZip fallback)
+                try {
+                    $zip = $this->open_zip_for_restore($tempFile);
+                    $this->logger->info('Opened bundle ZIP', [
+                        'bundle_hash' => $bundleHash,
+                        'temp_file'   => $tempFile,
+                        'num_files'   => $zip->numFiles,
+                    ]);
                     foreach ($chunkHashes as $chunkHash) {
                         $entryName = $chunkHash . '.blob';
 …
+                    }
                     $zip->close();
                 } else {
+                } catch (\RuntimeException $e) {
                     $this->logger->error('Failed to open bundle ZIP file', [
                         'bundle_hash' => $bundleHash,
+                        'temp_file' => $tempFile
+                        'temp_file' => $tempFile,
+                        'error' => $e->getMessage()
                     ]);
                     $failedBundles[] = $bundleHash;
 …
+        }
+        // Fallback 1: chunks not in chunk_to_bundle may still be inside an already-downloaded bundle
+        // (e.g. parent manifest has 0 bundles so no mapping, but chunks live in child manifest bundles)
+        $chunksStillMissingAfterBundles = [];
+        foreach ($chunksNotInBundles as $hash) {
+            $foundInBundle = false;
+            foreach ($downloadedBundles as $bundleHash => $tempFile) {
+                if (!is_file($tempFile)) {
+                    continue;
+                }
+                try {
+                    $zip = $this->open_zip_for_restore($tempFile);
+                    $chunkData = $zip->getFromName($hash . '.blob');
+                    $zip->close();
+                    if ($chunkData !== false) {
+                        $results[$hash] = $chunkData;
+                        $foundInBundle = true;
+                        $this->logger->info('Found chunk in already-downloaded bundle (not in chunk_to_bundle)', [
+                            'chunk_hash' => substr($hash, 0, 16) . '...',
+                            'bundle_hash' => substr($bundleHash, 0, 16) . '...'
+                        ]);
+                        break;
+                    }
+                } catch (\RuntimeException $e) {
+                    continue;
+                }
+            }
+            if (!$foundInBundle) {
+                $chunksStillMissingAfterBundles[] = $hash;
+            }
+        }
+        // Fallback 1b: missing chunks may be in a bundle we did not need for mapped chunks (e.g. third bundle in chain)
+        $bundlesDownloaded = array_keys($downloadedBundles);
+        foreach (array_keys($bundleMetadata) as $bundleHash) {
+            if (in_array($bundleHash, $bundlesDownloaded, true) || empty($chunksStillMissingAfterBundles)) {
+                continue;
+            }
+            $bundleInfo = $bundleMetadata[$bundleHash];
+            $bundleKey = $bundleInfo['bundle_key'] ?? 'bundle_' . $bundleHash;
+            $bundlePath = $objects_prefix . '/' . substr($bundleHash, 0, 2) . '/' . $bundleKey . '.zip';
+            $bundleData = $this->download_object_from_provider($provider, $bundlePath, $request);
+            if ($bundleData === null || $bundleData === '') {
+                continue;
+            }
+            $tempFile = (function_exists('\wp_tempnam')) ? \wp_tempnam('siteskite_bundle_') : (sys_get_temp_dir() . '/siteskite_bundle_' . uniqid('', true) . '.zip');
+            if ($tempFile === false) {
+                $tempFile = sys_get_temp_dir() . '/siteskite_bundle_' . uniqid('', true) . '.zip';
+            }
+            file_put_contents($tempFile, $bundleData);
+            $tempFiles[] = $tempFile;
+            try {
+                $zip = $this->open_zip_for_restore($tempFile);
+                foreach ($chunksStillMissingAfterBundles as $idx => $hash) {
+                    $chunkData = $zip->getFromName($hash . '.blob');
+                    if ($chunkData !== false) {
+                        $results[$hash] = $chunkData;
+                        unset($chunksStillMissingAfterBundles[$idx]);
+                        $this->logger->info('Found chunk in extra bundle (not in chunk_to_bundle)', [
+                            'chunk_hash' => substr($hash, 0, 16) . '...',
+                            'bundle_hash' => substr($bundleHash, 0, 16) . '...'
+                        ]);
+                    }
+                }
+                $zip->close();
+                $chunksStillMissingAfterBundles = array_values($chunksStillMissingAfterBundles);
+            } catch (\RuntimeException $e) {
+                // Skip this bundle on open failure
+            }
+        }
         // Cleanup temp files
         foreach ($tempFiles as $tempFile) {
 …
+        }
+        // Fail if any bundles failed to download or chunks are missing
+        // Fallback 2: try single-blob download for any still missing (standalone blob in cloud)
+        foreach ($chunksStillMissingAfterBundles as $hash) {
+            $objectPath = $objects_prefix . '/' . substr($hash, 0, 2) . '/' . $hash . '.blob';
+            $chunkData = $this->download_object_from_provider($provider, $objectPath, $request);
+            if ($chunkData !== null && $chunkData !== '') {
+                $results[$hash] = $chunkData;
+                $this->logger->debug('Downloaded chunk via fallback single-blob', [
+                    'chunk_hash' => substr($hash, 0, 16) . '...',
+                    'object_path' => $objectPath
+                ]);
+            } else {
+                $this->logger->warning('Fallback single-blob download failed for chunk', [
+                    'chunk_hash' => substr($hash, 0, 16) . '...',
+                    'object_path' => $objectPath
+                ]);
+                $missingChunks[] = $hash;
+            }
+        }
+        // Fail if any bundles failed to download or chunks are still missing (after bundle + fallback)
         if (!empty($failedBundles) || !empty($missingChunks)) {
             $this->logger->error('Bundle download/extraction failed', [
+            $this->logger->error('Bundle download/extraction or fallback failed', [
                 'failed_bundles' => count($failedBundles),
                 'missing_chunks' => count($missingChunks),
+                'bundles' => $failedBundles
+            ]);
+            throw new \RuntimeException('Failed to download or extract chunks from bundles. Bundle-based restore is required.');
+                'bundles' => $failedBundles,
+                'missing_sample' => array_slice($missingChunks, 0, 5)
+            ]);
+            throw new \RuntimeException(
+                'Failed to download or extract chunks. Missing: ' . count($missingChunks) . ' chunk(s) after bundle download and single-blob fallback.'
+            );
+        }
         $this->logger->info('Bundle-based download completed', [
             'total_requested' => count($hashes),
+            'total_retrieved' => count($results)
+            'total_retrieved' => count($results),
+            'from_bundles_mapped' => count($hashes) - count($chunksNotInBundles),
+            'from_fallback_bundles_or_blobs' => count($chunksNotInBundles)
         ]);
 …
+            }
+            // Read the downloaded file
+            $data = file_get_contents($temp_file);
+            // Read the downloaded file with extra diagnostics for hosting differences
+            $data = @file_get_contents($temp_file);
+            $data_size = is_string($data) ? strlen($data) : -1;
+            $this->logger->info('download_object_from_provider read temp file', [
+                'provider'     => $provider,
+                'object_path'  => $objectPath,
+                'temp_file'    => $temp_file,
+                'data_size'    => $data_size,
+                'file_exists'  => file_exists($temp_file),
+                'file_size'    => file_exists($temp_file) ? filesize($temp_file) : null,
+                'sys_temp_dir' => sys_get_temp_dir(),
+            ]);
+            if ($data === false || $data_size === 0) {
+                $this->logger->warning('download_object_from_provider returned empty data', [
+                    'provider'    => $provider,
+                    'object_path' => $objectPath,
+                    'temp_file'   => $temp_file,
+                    'file_exists' => file_exists($temp_file),
+                    'file_size'   => file_exists($temp_file) ? filesize($temp_file) : null,
+                ]);
+            }
             wp_delete_file($temp_file);
             return $data;
 …
         fclose($fh);
         // Package into a ZIP to reuse existing restore_database logic
+        // Package into a ZIP to reuse existing restore_database logic (ZipArchive or PclZip fallback)
         $zip_path = $this->restore_dir . '/incdb_' . $manifestId . '.zip';
+        $zip = new \ZipArchive();
+        if ($zip->open($zip_path, \ZipArchive::CREATE | \ZipArchive::OVERWRITE) !== true) {
+            throw new \RuntimeException('Failed to create ZIP for database incremental restore');
+        }
+        $zip->addFile($sql_path, basename($sql_path));
+        $zip->close();
+        $this->create_zip_with_single_file($zip_path, $sql_path, basename($sql_path));
         // Import using existing path
 …
+    {
         try {
+            // Clear webhook sent keys for all possible scopes when starting a new restore
+            // This allows retries to send notifications again
+            $scopes = ['files', 'database', 'full'];
+            foreach ($scopes as $scope) {
+                $webhook_sent_key = 'siteskite_restore_webhook_sent_' . $backup_id . '_' . $scope;
+                delete_option($webhook_sent_key);
+            }
+            // If a duplicate cron fires after restore already completed (e.g. file cleaned up), skip so we
+            // don't overwrite completion with "Failed to open backup file" / error and don't clear webhook_sent.
+            // Use multiple sources of truth: option (completed/cleanup), webhook_sent from DB, filesystem state file.
+            $scope = ($type === 'database' || $type === 'files') ? $type : 'full';
+            if ($this->is_restore_finalized($backup_id, $scope)) {
+                $this->logger->info('Restore already finalized for this backup_id/scope, skipping duplicate cron execution', [
+                    'backup_id' => $backup_id,
+                    'scope' => $scope
+                ]);
+                return;
+            }
+            // If another process_restore is already running for this backup_id+scope (e.g. at 301/321 queries),
+            // skip so we don't start a second attempt. Lock is file-based so it survives DB import overwriting options.
+            if ($this->is_restore_running_lock_active($backup_id, $scope)) {
+                $this->logger->info('Restore already in progress for this backup_id/scope, skipping second attempt', [
+                    'backup_id' => $backup_id,
+                    'scope' => $scope
+                ]);
+                return;
+            }
+            $this->prepare_classic_restore_run($backup_id, $scope);
             // Set a flag at the start of restore
             $this->update_option_bc(SITESKITE_OPTION_PREFIX . 'restore_in_progress', SITESKITE_OPTION_PREFIX . 'restore_in_progress', true);
+            $this->ensure_restore_guard_mu_plugin();
             // Check if this is an incremental restore
             if ($this->is_incremental_restore($backup_id, $type, $download_url)) {
+                $this->clear_restore_running_lock($backup_id, $scope);
                 $this->process_incremental_restore($backup_id, $type, $download_url);
                 return;
 …
             ], $suppress_notification);
+            // TRICK: Save final state to JSON file before cleanup so external app can still poll it
+            // Get the final restore info before it's deleted
+            $final_restore_info = get_option(self::OPTION_PREFIX . $backup_id, []);
+            if (!empty($final_restore_info) && isset($final_restore_info['status']) && $final_restore_info['status'] === 'completed') {
+                // Build final progress data similar to get_restore_progress response
+                $final_restore_type = $final_restore_info['type'] ?? $type;
+                $final_scope = $final_restore_info['scope'] ?? $type;
+                $final_progress_data = [
+                    'status' => 'completed',
+                    'progress' => 100,
+                    'message' => $final_restore_info['message'] ?? 'Restore completed successfully',
+                    'backup_id' => $backup_id,
+                    'completed_at' => $final_restore_info['completed_at'] ?? time(),
+                    'operation_type' => 'restore',
+                    'is_restore' => true,
+                    'type' => $final_restore_type,
+                    'scope' => $final_scope
+                ];
+                // Add classic restore progress
+                $classic_restore_progress = $this->get_classic_restore_progress($backup_id, $final_restore_info, $final_restore_type);
+                $final_progress_data['classic_restore'] = $classic_restore_progress;
+                // Ensure all progress shows as completed
+                if (isset($final_progress_data['classic_restore']['database'])) {
+                    $final_progress_data['classic_restore']['database']['status'] = 'completed';
+                    $final_progress_data['classic_restore']['database']['complete'] = true;
+                    $final_progress_data['classic_restore']['database']['progress_percent'] = 100.0;
+                }
+                if (isset($final_progress_data['classic_restore']['files'])) {
+                    $final_progress_data['classic_restore']['files']['status'] = 'completed';
+                    $final_progress_data['classic_restore']['files']['complete'] = true;
+                    $final_progress_data['classic_restore']['files']['progress_percent'] = 100.0;
+                }
+                if (isset($final_progress_data['classic_restore']['full'])) {
+                    $final_progress_data['classic_restore']['full']['status'] = 'completed';
+                    $final_progress_data['classic_restore']['full']['complete'] = true;
+                    $final_progress_data['classic_restore']['full']['overall_progress'] = 100.0;
+                }
+                $this->save_last_classic_restore_state_to_file($backup_id, $final_progress_data);
+            }
+            // Clear the in progress flag
+            delete_option(SITESKITE_OPTION_PREFIX . 'restore_in_progress');
+            delete_option(SITESKITE_OPTION_PREFIX . 'restore_in_progress');
+            $this->build_and_save_completed_restore_state_file($backup_id, $type);
+            $this->finish_classic_restore_run($backup_id, $scope);
             $this->cleanup_manager->cleanup_restore_files($backup_id);
         } catch (\Exception $e) {
+            delete_option(SITESKITE_OPTION_PREFIX . 'restore_in_progress');
+            delete_option(SITESKITE_OPTION_PREFIX . 'restore_in_progress');
+            $this->finish_classic_restore_run($backup_id, $scope);
             $this->update_restore_status($backup_id, [
                 'status' => 'error',
 …
     /**
+     * Ensure PclZip class is loaded (WordPress wp-admin/includes/class-pclzip.php).
+     * Used as fallback when ZipArchive extension is not available for restore extraction.
+     *
+     * @throws \RuntimeException If PclZip file does not exist or class not available
+     */
+    private function ensure_pclzip_loaded(): void
+    {
+        if (class_exists('PclZip')) {
+            return;
+        }
+        $path = ABSPATH . 'wp-admin/includes/class-pclzip.php';
+        if (!file_exists($path)) {
+            throw new \RuntimeException(
+                'ZipArchive is not available and PclZip could not be loaded (missing: wp-admin/includes/class-pclzip.php). ' .
+                'Please enable the PHP zip extension or use a full WordPress installation.'
+            );
+        }
+        require_once $path;
+        if (!class_exists('PclZip')) {
+            throw new \RuntimeException(
+                'ZipArchive is not available and PclZip could not be loaded. ' .
+                'Please enable the PHP zip extension.'
+            );
+        }
+    }
+    /**
+     * Open a ZIP file for reading (extract/list). Uses ZipArchive when available, otherwise PclZip.
+     * Caller must call close() when done.
+     *
+     * @param string $zip_path Full path to the ZIP file
+     * @return object Object with: numFiles (int), getNameIndex(int $i), extractTo(string $path, string|array|null $entries = null), getFromName(string $name), close()
+     * @throws \RuntimeException If ZIP cannot be opened or neither ZipArchive nor PclZip is available
+     */
+    private function open_zip_for_restore(string $zip_path)
+    {
+        if (class_exists('ZipArchive') || extension_loaded('zip')) {
+            $zip = new \ZipArchive();
+            if ($zip->open($zip_path) === true) {
+                return $zip;
+            }
+        }
+        $this->ensure_pclzip_loaded();
+        $pclzip = new \PclZip($zip_path);
+        $list = $pclzip->listContent();
+        if ($list === 0 || !is_array($list)) {
+            $err = $pclzip->errorInfo(true);
+            throw new \RuntimeException('Failed to open ZIP file for restore: ' . (is_string($err) ? $err : 'unknown error'));
+        }
+        $numFiles = count($list);
+        $filenames = [];
+        foreach ($list as $entry) {
+            $filenames[] = isset($entry['filename']) ? $entry['filename'] : (isset($entry['stored_filename']) ? $entry['stored_filename'] : '');
+        }
+        return new class($pclzip, $filenames, $numFiles, $this->restore_dir) {
+            private $pclzip;
+            private $filenames;
+            public $numFiles;
+            private $restore_dir;
+            public function __construct($pclzip, $filenames, $numFiles, $restore_dir)
+            {
+                $this->pclzip = $pclzip;
+                $this->filenames = $filenames;
+                $this->numFiles = $numFiles;
+                $this->restore_dir = $restore_dir;
+            }
+            public function getNameIndex(int $i): string
+            {
+                return $this->filenames[$i] ?? '';
+            }
+            public function extractTo(string $path, $entries = null): bool
+            {
+                if ($entries === null) {
+                    $result = $this->pclzip->extract(\PCLZIP_OPT_PATH, $path);
+                } elseif (is_array($entries)) {
+                    $result = $this->pclzip->extract(\PCLZIP_OPT_PATH, $path, \PCLZIP_OPT_BY_NAME, $entries);
+                } else {
+                    $result = $this->pclzip->extract(\PCLZIP_OPT_PATH, $path, \PCLZIP_OPT_BY_NAME, $entries);
+                }
+                return $result !== 0;
+            }
+            public function getFromName(string $name)
+            {
+                $temp_dir = $this->restore_dir . '/pclzip_' . uniqid('', true);
+                if (!wp_mkdir_p($temp_dir)) {
+                    return false;
+                }
+                $result = $this->pclzip->extract(\PCLZIP_OPT_PATH, $temp_dir, \PCLZIP_OPT_BY_NAME, $name);
+                if ($result === 0) {
+                    if (is_dir($temp_dir)) {
+                        array_map('wp_delete_file', glob($temp_dir . '/*'));
+                        @rmdir($temp_dir);
+                    }
+                    return false;
+                }
+                $extracted_file = $temp_dir . '/' . $name;
+                if (!file_exists($extracted_file)) {
+                    $extracted_file = $temp_dir . '/' . basename($name);
+                }
+                $content = file_exists($extracted_file) ? file_get_contents($extracted_file) : false;
+                if (is_dir($temp_dir)) {
+                    array_map('wp_delete_file', glob($temp_dir . '/*'));
+                    @rmdir($temp_dir);
+                }
+                return $content;
+            }
+            public function close(): bool
+            {
+                return true;
+            }
+        };
+    }
+    /**
+     * Create a ZIP file containing a single file (for incremental DB restore when ZipArchive is unavailable).
+     *
+     * @param string $zip_path Path for the new ZIP file
+     * @param string $file_path Path to the file to add
+     * @param string $entry_name Name of the entry inside the ZIP
+     * @throws \RuntimeException If creation fails
+     */
+    private function create_zip_with_single_file(string $zip_path, string $file_path, string $entry_name): void
+    {
+        if (class_exists('ZipArchive') || extension_loaded('zip')) {
+            $zip = new \ZipArchive();
+            if ($zip->open($zip_path, \ZipArchive::CREATE | \ZipArchive::OVERWRITE) === true) {
+                if ($zip->addFile($file_path, $entry_name) && $zip->close()) {
+                    return;
+                }
+                $zip->close();
+            }
+        }
+        $this->ensure_pclzip_loaded();
+        $pclzip = new \PclZip($zip_path);
+        $result = $pclzip->create($file_path, \PCLZIP_OPT_REMOVE_ALL_PATH);
+        if ($result === 0) {
+            $err = $pclzip->errorInfo(true);
+            throw new \RuntimeException('Failed to create ZIP for restore: ' . (is_string($err) ? $err : 'unknown error'));
+        }
+    }
+    /**
      * Extract file from full backup package if specific file not found
+     *
+     *
      * @param string $file_name The requested file name (e.g., siteskite_backup_XXX_db.zip)
      * @param string $destination Final destination path for the extracted file (will be updated to actual extracted file path)
 …
         ]);
+        // Extract the needed file from full.zip
+        $zip = new \ZipArchive();
+        if ($zip->open($full_zip_path) !== true) {
+        // Extract the needed file from full.zip (ZipArchive or PclZip fallback)
+        try {
+            $zip = $this->open_zip_for_restore($full_zip_path);
+        } catch (\RuntimeException $e) {
             if (file_exists($full_zip_path)) {
                 wp_delete_file($full_zip_path);
+            }
             throw new \RuntimeException('Failed to open full backup package');
+            throw new \RuntimeException('Failed to open full backup package: ' . $e->getMessage());
+        }
 …
     /**
+     * Execute a single restore query with retries for transient errors (lock wait, timeout, connection).
+     *
+     * @param \wpdb $wpdb WordPress database instance
+     * @param string $query SQL query to execute
+     * @param bool $is_incremental Whether this is an incremental restore (duplicate key errors are acceptable)
+     * @return bool True if query succeeded or was ignorable; false if failed after retries
+     */
+    private function execute_restore_query_with_retry($wpdb, string $query, bool $is_incremental): bool
+    {
+        $attempt = 0;
+        $max_attempts = self::DB_IMPORT_QUERY_RETRY_ATTEMPTS;
+        $sleep_ms = self::DB_IMPORT_QUERY_RETRY_SLEEP_MS;
+        while ($attempt < $max_attempts) {
+            // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery,WordPress.DB.DirectDatabaseQuery.NoCaching,WordPress.DB.PreparedSQL.NotPrepared
+            $result = $wpdb->query($query);
+            if ($result !== false) {
+                return true;
+            }
+            $last_error = $wpdb->last_error;
+            $is_duplicate = (
+                strpos($last_error, 'Duplicate entry') !== false ||
+                strpos($last_error, 'PRIMARY') !== false
+            );
+            if ($is_duplicate && $is_incremental) {
+                return true;
+            }
+            $is_transient = (
+                stripos($last_error, 'Lock wait timeout') !== false ||
+                stripos($last_error, 'Deadlock') !== false ||
+                stripos($last_error, 'connection') !== false ||
+                stripos($last_error, 'gone away') !== false ||
+                stripos($last_error, 'max_allowed_packet') !== false ||
+                stripos($last_error, 'try again') !== false
+            );
+            if (!$is_transient || $attempt === $max_attempts - 1) {
+                $this->logger->warning('Query failed', [
+                    'query' => substr($query, 0, 100) . '...',
+                    'error' => $last_error,
+                    'attempt' => $attempt + 1,
+                ]);
+                return false;
+            }
+            $attempt++;
+            usleep($sleep_ms * 1000);
+        }
+        return false;
+    }
+    /**
+     * Import SQL file using streaming read so large dumps (100MB–1GB+) don't exhaust memory or time out.
+     * Parses statements from a chunked buffer and executes with retries and periodic time-limit extension.
+     *
+     * @param string $sql_file Path to extracted .sql file
+     * @param string $backup_id Backup/restore ID
+     * @param bool $is_incremental Whether this is an incremental restore
+     * @return int Number of queries executed successfully (for progress/completion)
+     */
+    private function import_sql_file_streaming(
+        string $sql_file,
+        string $backup_id,
+        bool $is_incremental
+    ): int {
+        global $wpdb;
+        $file_size = (int) @filesize($sql_file);
+        if ($file_size <= 0) {
+            throw new \RuntimeException('SQL file is empty or unreadable');
+        }
+        $fh = fopen($sql_file, 'rb');
+        if ($fh === false) {
+            throw new \RuntimeException('Failed to open SQL file for streaming');
+        }
+        $chunk_size = self::DB_IMPORT_READ_CHUNK_BYTES;
+        $buffer = '';
+        $bytes_read = 0;
+        $total_queries = 0;
+        $progress_interval = self::DB_IMPORT_PROGRESS_INTERVAL;
+        $extend_every = self::DB_IMPORT_EXTEND_TIME_LIMIT_EVERY;
+        try {
+            while (!feof($fh)) {
+                $chunk = fread($fh, $chunk_size);
+                if ($chunk === false) {
+                    break;
+                }
+                $bytes_read += strlen($chunk);
+                $buffer .= $chunk;
+                // Cap buffer size: if one huge statement exceeds limit, process up to last ;\n to avoid OOM
+                $max_buf = self::DB_IMPORT_MAX_BUFFER_BYTES;
+                if (strlen($buffer) > $max_buf) {
+                    $last_delim = strrpos($buffer, ";\n");
+                    if ($last_delim === false) {
+                        $last_delim = strrpos($buffer, ";\r\n");
+                    }
+                    if ($last_delim !== false) {
+                        $to_process = substr($buffer, 0, $last_delim + 1);
+                        $buffer = substr($buffer, $last_delim + 1);
+                        $buffer = ltrim($buffer, "\r\n");
+                        $statements = preg_split('/;\s*\r?\n/', $to_process, -1, PREG_SPLIT_NO_EMPTY);
+                        if ($statements !== false) {
+                            foreach ($statements as $raw) {
+                                $query = trim($raw);
+                                if ($query === '') continue;
+                                if ($is_incremental && stripos($query, 'DROP TABLE') === 0) continue;
+                                if ($is_incremental && preg_match('/^\s*INSERT\s+INTO\s+/i', $query)) {
+                                    $query = preg_replace('/^\s*INSERT\s+INTO\s+/i', 'INSERT IGNORE INTO ', $query);
+                                }
+                                if (!$this->is_safe_restore_query($query)) continue;
+                                $this->execute_restore_query_with_retry($wpdb, $query, $is_incremental);
+                                $total_queries++;
+                                if ($total_queries % $extend_every === 0) {
+                                    if (function_exists('set_time_limit')) set_time_limit(30);
+                                    $wpdb->flush();
+                                }
+                                if ($total_queries % $progress_interval === 0 || $total_queries === 1) {
+                                    $pct = $file_size > 0 ? min(100, (int) (($bytes_read / $file_size) * 100)) : 0;
+                                    $progress_pct = min(90, 60 + (int) (($bytes_read / $file_size) * 30));
+                                    $this->update_restore_status($backup_id, [
+                                        'progress' => $progress_pct,
+                                        'db_queries_processed' => $total_queries,
+                                        'current_operation' => sprintf(
+                                            'Restoring database: %d queries processed (~%d%% of file)',
+                                            $total_queries,
+                                            $pct
+                                        ),
+                                    ]);
+                                }
+                            }
+                        }
+                    }
+                }
+                // Extract complete statements (delimited by ; followed by newline)
+                $statements = preg_split('/;\s*\r?\n/', $buffer, -1, PREG_SPLIT_NO_EMPTY);
+                if ($statements === false) {
+                    continue;
+                }
+                // Last segment may be incomplete (no trailing ;\n yet)
+                $last = array_pop($statements);
+                $buffer = $last !== '' ? $last : '';
+                foreach ($statements as $raw) {
+                    $query = trim($raw);
+                    if ($query === '') {
+                        continue;
+                    }
+                    if ($is_incremental && stripos($query, 'DROP TABLE') === 0) {
+                        $this->logger->warning('Skipping DROP TABLE during incremental restore', [
+                            'query_preview' => substr($query, 0, 80) . '...',
+                            'backup_id' => $backup_id,
+                        ]);
+                        continue;
+                    }
+                    if ($is_incremental && preg_match('/^\s*INSERT\s+INTO\s+/i', $query)) {
+                        $query = preg_replace('/^\s*INSERT\s+INTO\s+/i', 'INSERT IGNORE INTO ', $query);
+                    }
+                    if (!$this->is_safe_restore_query($query)) {
+                        $this->logger->warning('Unsafe query skipped during restore', [
+                            'query' => substr($query, 0, 100) . '...',
+                        ]);
+                        continue;
+                    }
+                    $this->execute_restore_query_with_retry($wpdb, $query, $is_incremental);
+                    $total_queries++;
+                    if ($total_queries % $extend_every === 0) {
+                        if (function_exists('set_time_limit')) {
+                            set_time_limit(30);
+                        }
+                        $wpdb->flush();
+                    }
+                    if ($total_queries % $progress_interval === 0 || $total_queries === 1) {
+                        $pct = $file_size > 0 ? min(100, (int) (($bytes_read / $file_size) * 100)) : 0;
+                        $progress = 60 + (int) (($bytes_read / $file_size) * 30);
+                        $progress = min(90, (int) $progress);
+                        $this->update_restore_status($backup_id, [
+                            'progress' => $progress,
+                            'db_queries_processed' => $total_queries,
+                            'current_operation' => sprintf(
+                                'Restoring database: %d queries processed (~%d%% of file)',
+                                $total_queries,
+                                $pct
+                            ),
+                        ]);
+                    }
+                }
+            }
+            // Process any remaining buffer (last statement(s) after final ;\n or EOF)
+            if ($buffer !== '') {
+                $statements = preg_split('/;\s*\r?\n/', $buffer, -1, PREG_SPLIT_NO_EMPTY);
+                if ($statements !== false) {
+                    foreach ($statements as $raw) {
+                        $query = trim($raw);
+                        if ($query === '') {
+                            continue;
+                        }
+                        if ($is_incremental && stripos($query, 'DROP TABLE') === 0) {
+                            continue;
+                        }
+                        if ($is_incremental && preg_match('/^\s*INSERT\s+INTO\s+/i', $query)) {
+                            $query = preg_replace('/^\s*INSERT\s+INTO\s+/i', 'INSERT IGNORE INTO ', $query);
+                        }
+                        if (!$this->is_safe_restore_query($query)) {
+                            continue;
+                        }
+                        $this->execute_restore_query_with_retry($wpdb, $query, $is_incremental);
+                        $total_queries++;
+                    }
+                }
+            }
+        } finally {
+            fclose($fh);
+        }
+        return $total_queries;
+    }
+    /**
      * Restore database
+     *
 …
         try {
+            // Snapshot SiteSkite connection keys and permalink FIRST (before any DB writes or import)
+            // so portal connection survives after DB import; original code captured these before running SQL
+            $connection_keys_to_preserve = [
+                SITESKITE_OPTION_PREFIX . 'api_key',
+                'siteskite_callback_url',
+                'siteskite_cron_secret_token',
+            ];
+            $connection_keys_before = [];
+            foreach ($connection_keys_to_preserve as $opt_key) {
+                $val = get_option($opt_key, null);
+                if ($val !== null && $val !== '') {
+                    $connection_keys_before[ $opt_key ] = $val;
+                }
+            }
+            $original_permalink = get_option('permalink_structure');
             // Update status to show database restore starting
             $this->update_restore_status($backup_id, [
 …
             ]);
-            $original_permalink = get_option('permalink_structure');
             $this->logger->info('permalink: ', [
                 'Permalink' => $original_permalink
             ]);
+            // Extract SQL file from ZIP
+            $zip = new \ZipArchive();
+            if ($zip->open($download_url) !== true) {
+                throw new \RuntimeException('Failed to open backup file');
+            if (!$this->check_database_restore_file_readable($backup_id, $download_url)) {
+                return;
+            }
+            try {
+                $zip = $this->open_zip_for_restore($download_url);
+            } catch (\RuntimeException $e) {
+                if ($this->is_restore_finalized($backup_id, 'database')) {
+                    $this->logger->info('Failed to open backup file but restore already finalized, skipping (duplicate cron)', [
+                        'backup_id' => $backup_id
+                    ]);
+                    return;
+                }
+                throw new \RuntimeException('Failed to open backup file: ' . $e->getMessage());
+            }
 …
             $sql_file = $this->restore_dir . '/temp_' . $backup_id . '.sql';
             $zip->extractTo($this->restore_dir, $sql_filename);
+            $extract_ok = $zip->extractTo($this->restore_dir, $sql_filename);
             $zip->close();
+            if ($extract_ok === false) {
+                throw new \RuntimeException('Failed to extract SQL file from backup');
+            }
             // Rename extracted file to our temp name if needed
 …
+            }
             // Update status for SQL processing
+            // Update status for SQL processing (streaming import avoids loading full file into memory)
             $this->update_restore_status($backup_id, [
                 'progress' => 50,
+                'current_operation' => 'Reading SQL file'
+            ]);
+            // Read SQL file
+            $sql_contents = file_get_contents($sql_file);
+            if ($sql_contents === false) {
+                throw new \RuntimeException('Failed to read SQL file');
+            }
+            // Detect if this is an incremental restore
+                'current_operation' => 'Importing database (streaming)'
+            ]);
+            // Detect if this is an incremental restore (before any file read)
             // Incremental restores use file paths like '/incdb_' or manifest IDs
             $is_incremental = (strpos($download_url, '/incdb_') !== false) ||
+            $is_incremental = (strpos($download_url, '/incdb_') !== false) ||
                              (strpos($download_url, 'incdb_') !== false) ||
                              (strpos($backup_id, 'database:') === 0);
+            // For incremental restores, clean up ALL existing restore-related records BEFORE importing
+            // This prevents duplicate notifications from old restore records in the database
+            // We delete ALL restore-related records completely - they will be recreated as needed
+            // For incremental restores, clean up existing restore-related records for THIS job BEFORE importing
             if ($is_incremental) {
                 $this->logger->info('Cleaning up ALL existing restore-related records before database import', [
+                $this->logger->info('Cleaning up existing restore-related records for this job before database import', [
                     'backup_id' => $backup_id
                 ]);
-                // Clean up ALL restore-related records completely (preserve webhook flags)
                 $this->cleanup_restore_records($backup_id, true);
+            }
-            // For incremental restores, modify INSERT statements to handle duplicates
             if ($is_incremental) {
+                // Convert INSERT INTO to INSERT IGNORE INTO to handle duplicate keys
+                // This prevents "Duplicate entry" errors for incremental restores
+                $sql_contents = preg_replace(
+                    '/^INSERT\s+INTO\s+/im',
+                    'INSERT IGNORE INTO ',
+                    $sql_contents
+                );
+                $this->logger->info('Modified SQL for incremental restore (using INSERT IGNORE)', [
+                $this->logger->info('Using streaming import with INSERT IGNORE for incremental restore', [
                     'backup_id' => $backup_id,
                     'download_url' => basename($download_url)
 …
+            }
+            // Split into queries
+            $queries = array_filter(
+                explode(";\n", $sql_contents),
+                'trim'
+            );
+            $total_queries = count($queries);
+            // Store total queries for progress tracking
+            $this->update_restore_status($backup_id, [
+                'db_total_queries' => $total_queries,
+                'db_queries_processed' => 0
+            ]);
+            // Update status for database restore
+            $this->update_restore_status($backup_id, [
+                'progress' => 60,
+                'current_operation' => 'Restoring database tables'
+            ]);
+            // Process queries
+            foreach ($queries as $index => $query) {
+                $query = trim($query);
+                if (empty($query)) continue;
+                // Validate query for security - only allow specific SQL operations
+                if (!$this->is_safe_restore_query($query)) {
+                    $this->logger->warning('Unsafe query skipped during restore', [
+                        'query' => substr($query, 0, 100) . '...'
+                    ]);
+                    continue;
+                }
+                // Execute query
+                // Note: This is for SQL restore operations via REST API
+                // Queries are validated for safety before execution
+                // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery,WordPress.DB.DirectDatabaseQuery.NoCaching,WordPress.DB.PreparedSQL.NotPrepared
+                $result = $wpdb->query($query);
+                if ($result === false) {
+                    // For incremental restores, duplicate key errors are expected and can be ignored
+                    // as we're using INSERT IGNORE, but log other errors
+                    $is_duplicate_error = (
+                        strpos($wpdb->last_error, 'Duplicate entry') !== false ||
+                        strpos($wpdb->last_error, 'PRIMARY') !== false
+                    );
+                    if (!$is_duplicate_error || !$is_incremental) {
+                        $this->logger->warning('Query failed', [
+                            'query' => substr($query, 0, 100) . '...',
+                            'error' => $wpdb->last_error,
+                            'is_incremental' => $is_incremental
+                        ]);
+                    }
+                }
+                // Update progress every 10% or 100 queries
+                if ($index % max(ceil($total_queries / 10), 100) === 0) {
+                    $progress = 60 + (($index / $total_queries) * 30); // Progress from 60% to 90%
+                    $this->update_restore_status($backup_id, [
+                        'progress' => (int)$progress,
+                        'db_queries_processed' => $index + 1,
+                        'current_operation' => sprintf(
+                            'Restoring database: %d/%d queries processed',
+                            $index + 1,
+                            $total_queries
+                        )
+                    ]);
+                }
+                // Prevent timeouts on large restores
+                if (($index + 1) % 1000 === 0) {
+                    // Note: This is necessary for large database restore operations via REST API
+                    // phpcs:ignore Squiz.PHP.DiscouragedFunctions.Discouraged
+                    if (function_exists('set_time_limit')) {
+                        // phpcs:ignore Squiz.PHP.DiscouragedFunctions.Discouraged
+                        set_time_limit(30);
+                    }
+                    $wpdb->flush();
+                }
+            }
+            // For incremental restores, clean up ALL imported restore-related records AFTER database import
+            // Stream SQL file in chunks: no full-file load, retries on transient errors, time-limit extension
+            $total_queries = $this->import_sql_file_streaming($sql_file, $backup_id, $is_incremental);
+            // For incremental restores, clean up imported restore-related records for THIS job after import
             // but BEFORE status update (which triggers notifications)
-            // This prevents duplicate notifications from restore records that were imported from the backup
-            // We delete ALL restore-related records completely - they will be recreated by the status update below
             if ($is_incremental) {
                 $this->logger->info('Cleaning up ALL imported restore-related records after database import', [
+                $this->logger->info('Cleaning up imported restore-related records for this job after database import', [
                     'backup_id' => $backup_id
                 ]);
-                // Clean up ALL restore-related records completely (no preservation)
-                // This removes any restore records that were imported from the backup
                 $this->cleanup_restore_records($backup_id, true);
+            }
+            // Cleanup
+            // Restore SiteSkite connection keys so portal connection survives even if SQL had older/empty values
+            foreach ($connection_keys_before as $opt_key => $value) {
+                update_option($opt_key, $value, true);
+            }
+            if (!empty($connection_keys_before)) {
+                $this->logger->info('Restored SiteSkite connection keys after database import', [
+                    'backup_id' => $backup_id,
+                    'keys_restored' => array_keys($connection_keys_before)
+                ]);
+            }
             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)
+            $this->update_restore_status($backup_id, [
+                'status' => 'completed',
+                'progress' => 100,
+                'completed_at' => time(),
+                'current_operation' => 'Database restore completed successfully',
+                'scope' => 'database',
+                'db_queries_processed' => $total_queries,
+                'db_restore_complete' => true
+            ], $suppress_notification);
+            $this->persist_database_restore_completed($backup_id, $total_queries, $suppress_notification);
             global $wpdb;
 …
             ]);
+            // Open ZIP file
+            $zip = new \ZipArchive();
+            if ($zip->open($download_url) !== true) {
+                throw new \RuntimeException('Failed to open backup file');
+            }
+            // Open ZIP file (ZipArchive or PclZip fallback)
+            $zip = $this->open_zip_for_restore($download_url);
             // Get total files and prepare file list
 …
+            }
+            // Extract main zip containing both database and files zips
+            $zip = new \ZipArchive();
+            if ($zip->open($download_url) !== true) {
+            // Extract main zip containing both database and files zips (ZipArchive or PclZip fallback)
+            try {
+                $zip = $this->open_zip_for_restore($download_url);
+            } catch (\RuntimeException $e) {
                 $this->logger->error('Failed to open backup file', [
                     'backup_id' => $backup_id,
                     'file_path' => $download_url,
                     'file_exists' => file_exists($download_url),
+                    'file_size' => file_exists($download_url) ? filesize($download_url) : 0
+                    'file_size' => file_exists($download_url) ? filesize($download_url) : 0,
+                    'error' => $e->getMessage()
                 ]);
                 throw new \RuntimeException('Failed to open backup file');
+                throw new \RuntimeException('Failed to open backup file: ' . $e->getMessage());
+            }
             // Extract both database and files zips to temp directory
+            $zip->extractTo($temp_dir);
+            $extract_ok = $zip->extractTo($temp_dir);
+            if ($extract_ok === false) {
+                $zip->close();
+                throw new \RuntimeException('Failed to extract backup file to temp directory');
+            }
             // Debug: List all files in the extracted directory
 …
+                    }
+                    // Extra diagnostics: log when copying a zero-byte file from restore directory
+                    $source_size = @filesize($source_path);
+                    if ($source_size === 0) {
+                        $this->logger->warning('Copying zero-byte file from restore directory', [
+                            'source' => $source_path,
+                            'destination' => $destination_path
+                        ]);
+                    }
                     // Use WP_Filesystem to copy file
                     if ($wp_filesystem->copy($source_path, $destination_path, true)) {
 …
+            }
+            // If we have restore info but not completed, return current status
+            $completed_fallback = $this->get_completed_restore_response_if_stale($backup_id, $restore_info, $restore_type, $is_classic_restore);
+            if ($completed_fallback !== null) {
+                return $completed_fallback;
+            }
+            // Return current in-progress status
             if ($restore_info) {
                 $response = [
 …
             ];
+        }
+    }
+    /**
+     * If restore actually completed but option was overwritten (e.g. by SQL import), return completed response.
+     * Checks webhook_sent (all scopes) and state file so frontend sees completion when option is stale.
+     *
+     * @param string $backup_id Backup ID
+     * @param array|null $restore_info Current option value (may be stale)
+     * @param string $restore_type Type from option or request
+     * @param bool $is_classic_restore Whether this is classic (not incremental) restore
+     * @return array|null Completed response array or null if no completion evidence
+     */
+    private function get_completed_restore_response_if_stale(?string $backup_id, $restore_info, string $restore_type, bool $is_classic_restore): ?array
+    {
+        if (!$backup_id) {
+            return null;
+        }
+        $webhook_check = $this->check_restore_completion_webhook($backup_id, null);
+        if ($webhook_check['found']) {
+            $this->logger->debug('Restore completion confirmed via webhook_sent fallback', [
+                'backup_id' => $backup_id,
+                'scope' => $webhook_check['scope']
+            ]);
+            $fallback_scope = $webhook_check['scope'];
+            $response = [
+                'status' => 'completed',
+                'progress' => 100,
+                'message' => 'Restore completed successfully',
+                'backup_id' => $backup_id,
+                'completed_at' => time(),
+                'operation_type' => 'restore',
+                'is_restore' => true,
+                'type' => $restore_type,
+                'scope' => $fallback_scope
+            ];
+            if ($is_classic_restore && $restore_info) {
+                $response['classic_restore'] = $this->get_classic_restore_progress(
+                    $backup_id,
+                    array_merge($restore_info ?: [], ['status' => 'completed', 'progress' => 100, 'scope' => $fallback_scope]),
+                    $restore_type
+                );
+            }
+            return $response;
+        }
+        if ($is_classic_restore) {
+            $last_state = $this->get_last_classic_restore_state_from_file($backup_id);
+            if ($last_state !== null && isset($last_state['status']) && $last_state['status'] === 'completed') {
+                $this->logger->debug('Restore completion confirmed via state file (option was stale)', [
+                    'backup_id' => $backup_id
+                ]);
+                return $last_state;
+            }
+        }
+        return null;
+    }
 …
                 throw new \RuntimeException('Missing required parameters: backup_id and type are required');
+            }
+            // User explicitly started a new restore: clear completion state so this run proceeds.
+            // Otherwise DB records (webhook_sent, state file, option "completed") would make the cron skip or frontend see "completed".
+            $this->clear_restore_completion_state_for_retry($backup_id);
+            // Reset restore option so is_restore_finalized and progress API don't return "completed" during this run.
+            $this->update_restore_status($backup_id, [
+                'status' => 'downloading',
+                'progress' => 10,
+                'current_operation' => 'Preparing download',
+                'scope' => $type
+            ]);
             // Create restore directory - extract clean filename from URL
 …
+            }
+            // Clear notification flag if starting a new restore (status changing from completed/failed to a new status)
+            // Clear notification flag if starting a new restore (status changing from completed/failed to a new status).
+            // Do NOT clear when new_status is 'cleanup' - cleanup is a phase of the same restore, not a new one.
+            // Clearing here would remove the webhook_sent key and break front-end completion detection.
             $old_status = $restore_info['status'] ?? '';
             $new_status = $status_update['status'] ?? $old_status;
             if (in_array($old_status, ['completed', 'failed'], true) &&
                 !in_array($new_status, ['completed', 'failed'], true) &&
+                $new_status !== $old_status) {
+                $new_status !== $old_status &&
+                $new_status !== 'cleanup') {
                 // New restore starting - clear the notification flags
                 // Clear the old notification sent key (for backward compatibility)
 …
+            }
+            // Clean up ALL backup info records that are restore-related
+            // Clean up backup info records for THIS manifest only (never global wildcards)
+            $backup_info_like = SITESKITE_OPTION_PREFIX . 'backup_' . $manifestId . '%';
             // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery,WordPress.DB.DirectDatabaseQuery.NoCaching
+            $result = $wpdb->query(
+                "DELETE FROM {$wpdb->options} WHERE option_name LIKE 'siteskite_backup_siteskite_backup_%'"
+            );
+            $result = $wpdb->query($wpdb->prepare(
+                "DELETE FROM {$wpdb->options} WHERE option_name LIKE %s",
+                $backup_info_like
+            ));
             if ($result !== false && $result > 0) {
                 $deleted_count += $result;
+            }
             // Clean up restore progress and provider status records
             $patterns = [
                 SITESKITE_OPTION_PREFIX . 'progress_siteskite_backup_%',
                 SITESKITE_OPTION_PREFIX . 'incremental_progress_siteskite_backup_%',
                 SITESKITE_OPTION_PREFIX . 'dropbox_status_siteskite_backup_%',
                 SITESKITE_OPTION_PREFIX . 'gdrive_status_siteskite_backup_%',
                 SITESKITE_OPTION_PREFIX . 'backblaze_b2_status_siteskite_backup_%',
                 SITESKITE_OPTION_PREFIX . 'pcloud_status_siteskite_backup_%',
                 SITESKITE_OPTION_PREFIX . 'aws_status_siteskite_backup_%',
                 SITESKITE_OPTION_PREFIX . 'full_backup_lock_siteskite_backup_%',
                 SITESKITE_OPTION_PREFIX . 'last_stage_siteskite_backup_%',
+            // Clean up restore progress and provider status records for THIS manifest only
+            $manifest_patterns = [
+                SITESKITE_OPTION_PREFIX . 'progress_' . $manifestId . '%',
+                SITESKITE_OPTION_PREFIX . 'incremental_progress_' . $manifestId . '%',
+                SITESKITE_OPTION_PREFIX . 'dropbox_status_' . $manifestId . '%',
+                SITESKITE_OPTION_PREFIX . 'gdrive_status_' . $manifestId . '%',
+                SITESKITE_OPTION_PREFIX . 'backblaze_b2_status_' . $manifestId . '%',
+                SITESKITE_OPTION_PREFIX . 'pcloud_status_' . $manifestId . '%',
+                SITESKITE_OPTION_PREFIX . 'aws_status_' . $manifestId . '%',
+                SITESKITE_OPTION_PREFIX . 'full_backup_lock_' . $manifestId . '%',
+                SITESKITE_OPTION_PREFIX . 'last_stage_' . $manifestId . '%',
             ];
             foreach ($patterns as $pattern) {
+            foreach ($manifest_patterns as $pattern) {
                 // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery,WordPress.DB.DirectDatabaseQuery.NoCaching
                 $result = $wpdb->query($wpdb->prepare(
 …
     /**
+     * Read option value directly from DB (bypasses object cache).
+     * Use when we must see the value set by another request (e.g. duplicate cron after first run completed).
+     *
+     * @param string $option_name Option name
+     * @return string|false Option value or false if not found
+     */
+    private function get_option_from_db(string $option_name)
+    {
+        global $wpdb;
+        // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching
+        $value = $wpdb->get_var($wpdb->prepare(
+            "SELECT option_value FROM {$wpdb->options} WHERE option_name = %s LIMIT 1",
+            $option_name
+        ));
+        return $value !== null ? $value : false;
+    }
+    /**
+     * Check if restore is finalized (completed or cleanup) using multiple sources of truth.
+     * Use this to skip duplicate cron: DB import can overwrite wp_options, so we also check
+     * webhook_sent (written after import) and the filesystem state file (immune to DB overwrite).
+     *
+     * @param string $backup_id Backup ID
+     * @param string $scope Scope: 'database', 'files', or 'full'
+     * @return bool True if restore is already finalized for this backup_id/scope
+     */
+    private function is_restore_finalized(string $backup_id, string $scope): bool
+    {
+        $status_key = self::OPTION_PREFIX . $backup_id;
+        $status_raw = $this->get_option_from_db($status_key);
+        if ($status_raw !== false) {
+            $info = @unserialize($status_raw);
+            if (is_array($info) && !empty($info['status']) && in_array($info['status'], ['completed', 'cleanup'], true)) {
+                $stored_scope = $info['scope'] ?? '';
+                if ($stored_scope === $scope || $scope === 'full' || $stored_scope === 'full') {
+                    return true;
+                }
+            }
+        }
+        $webhook_key = 'siteskite_restore_webhook_sent_' . $backup_id . '_' . $scope;
+        $webhook_val = $this->get_option_from_db($webhook_key);
+        if ($webhook_val !== false && $webhook_val !== '' && is_numeric($webhook_val) && (int) $webhook_val > 0) {
+            return true;
+        }
+        $last = $this->get_last_classic_restore_state_from_file($backup_id);
+        if (is_array($last) && !empty($last['status']) && $last['status'] === 'completed') {
+            $file_scope = $last['scope'] ?? '';
+            if ($file_scope === $scope || $scope === 'full' || $file_scope === 'full') {
+                return true;
+            }
+        }
+        // Database phase already finished (all queries processed) but status not yet "completed"
+        // (e.g. option overwritten by SQL import before final update). Skip second attempt.
+        if (($scope === 'database' || $scope === 'full') && $status_raw !== false) {
+            $info = @unserialize($status_raw);
+            if (is_array($info)) {
+                $processed = (int)($info['db_queries_processed'] ?? 0);
+                $total = (int)($info['db_total_queries'] ?? 0);
+                if ($total > 0 && $processed >= $total) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Path for the per-backup_id+scope running lock file (filesystem, not overwritten by DB import).
+     *
+     * @param string $backup_id Backup ID
+     * @param string $scope Scope: 'database', 'files', or 'full'
+     * @return string Lock file path
+     */
+    private function get_restore_running_lock_path(string $backup_id, string $scope): string
+    {
+        $safe = preg_replace('/[^a-zA-Z0-9_\-]/', '_', $backup_id);
+        return $this->restore_dir . '/.restore_running_' . $safe . '_' . $scope . '.lock';
+    }
+    /**
+     * Check if a restore is already in progress for this backup_id+scope (lock file exists and is recent).
+     *
+     * @param string $backup_id Backup ID
+     * @param string $scope Scope: 'database', 'files', or 'full'
+     * @param int $max_age_seconds Lock older than this is ignored (default 90 minutes)
+     * @return bool True if another run is in progress
+     */
+    private function is_restore_running_lock_active(string $backup_id, string $scope, int $max_age_seconds = 5400): bool
+    {
+        $path = $this->get_restore_running_lock_path($backup_id, $scope);
+        if (!file_exists($path)) {
+            return false;
+        }
+        $mtime = (int) @filemtime($path);
+        return $mtime > 0 && (time() - $mtime) < $max_age_seconds;
+    }
+    /**
+     * Set the running lock so duplicate process_restore calls skip.
+     *
+     * @param string $backup_id Backup ID
+     * @param string $scope Scope: 'database', 'files', or 'full'
+     */
+    private function set_restore_running_lock(string $backup_id, string $scope): void
+    {
+        $path = $this->get_restore_running_lock_path($backup_id, $scope);
+        if (function_exists('wp_mkdir_p')) {
+            wp_mkdir_p(dirname($path));
+        }
+        // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_file_put_contents
+        @file_put_contents($path, (string) time());
+    }
+    /**
+     * Clear the running lock after restore finishes (success or failure).
+     *
+     * @param string $backup_id Backup ID
+     * @param string $scope Scope: 'database', 'files', or 'full'
+     */
+    private function clear_restore_running_lock(string $backup_id, string $scope): void
+    {
+        $path = $this->get_restore_running_lock_path($backup_id, $scope);
+        if (file_exists($path)) {
+            wp_delete_file($path);
+        }
+    }
+    /**
+     * Prepare for a classic restore run: set running lock and clear webhook_sent so notifications can be sent again.
+     *
+     * @param string $backup_id Backup ID
+     * @param string $scope Scope: 'database', 'files', or 'full'
+     */
+    private function prepare_classic_restore_run(string $backup_id, string $scope): void
+    {
+        $this->set_restore_running_lock($backup_id, $scope);
+        foreach (['files', 'database', 'full'] as $s) {
+            delete_option('siteskite_restore_webhook_sent_' . $backup_id . '_' . $s);
+        }
+    }
+    /**
+     * Prepare for an incremental restore run: clear webhook_sent for this backup/scope so the restore runs
+     * and notifications can be sent. Without this, a previous run's webhook record can make the restore
+     * appear "already completed" and interrupt files-only (and database-only) incremental restores.
+     *
+     * @param string $manifestId Manifest ID (e.g. siteskite_backup_6981efd23f312_incremental)
+     * @param string $scope Scope: 'database', 'files', or 'full'
+     */
+    private function prepare_incremental_restore_run(string $manifestId, string $scope): void
+    {
+        $backup_id = $this->extract_backup_id_from_manifest_id($manifestId) ?? $manifestId;
+        $scopes_to_clear = ($scope === 'full') ? ['files', 'database', 'full'] : [$scope];
+        foreach ($scopes_to_clear as $s) {
+            delete_option('siteskite_restore_webhook_sent_' . $backup_id . '_' . $s);
+        }
+        if (function_exists('wp_cache_delete')) {
+            foreach ($scopes_to_clear as $s) {
+                wp_cache_delete('siteskite_restore_webhook_sent_' . $backup_id . '_' . $s, 'options');
+            }
+        }
+    }
+    /**
+     * Finish a classic restore run: clear running lock, restore_in_progress option, and restore guard mu-plugin.
+     *
+     * @param string $backup_id Backup ID
+     * @param string $scope Scope: 'database', 'files', or 'full'
+     */
+    private function finish_classic_restore_run(string $backup_id, string $scope): void
+    {
+        $this->clear_restore_in_progress_and_guard();
+        $this->clear_restore_running_lock($backup_id, $scope);
+    }
+    /**
+     * Clear restore_in_progress option and remove the restore guard mu-plugin so plugins load again.
+     */
+    private function clear_restore_in_progress_and_guard(): void
+    {
+        $this->clear_recovery_and_restore_state();
+    }
+    /**
+     * Clear recovery mode (flag file) and any restore-in-progress state (options + restore guard mu-plugin).
+     * Use this when the user wants to disable recovery / go back to normal without completing a restore.
+     * Safe to call from REST or elsewhere; idempotent.
+     */
+    public function clear_recovery_and_restore_state(): void
+    {
+        delete_option(SITESKITE_OPTION_PREFIX . 'restore_in_progress');
+        delete_option('siteskite_restore_in_progress');
+        $this->remove_restore_guard_mu_plugin();
+        \SiteSkite\Core\SiteSkiteSafetyCore::clear_recovery_mode();
+    }
+    /**
+     * Path to the must-use plugin that prevents loading other plugins during restore.
+     * Prevents fatals when DB lists active plugins whose files were deleted (e.g. test restore).
+     *
+     * @return string Absolute path to mu-plugin file
+     */
+    private function get_restore_guard_mu_plugin_path(): string
+    {
+        $content_dir = defined('WP_CONTENT_DIR') ? WP_CONTENT_DIR : (dirname(__DIR__, 2) . '/wp-content');
+        return $content_dir . '/mu-plugins/siteskite-restore-guard.php';
+    }
+    /**
+     * Create the restore guard must-use plugin so subsequent requests don't load plugins during restore.
+     * Prevents "Failed to open stream" fatals when active_plugins lists plugins that aren't on disk yet.
+     */
+    private function ensure_restore_guard_mu_plugin(): void
+    {
+        $path = $this->get_restore_guard_mu_plugin_path();
+        $dir  = dirname($path);
+        if (!is_dir($dir) && function_exists('wp_mkdir_p')) {
+            wp_mkdir_p($dir);
+        }
+        if (!is_writable($dir) && file_exists($path)) {
+            return;
+        }
+        $siteskite_basename = defined('SITESKITE_FILE') && function_exists('plugin_basename')
+            ? plugin_basename(SITESKITE_FILE)
+            : 'siteskite/siteskite-link.php';
+        $content = <<<PHP
+<?php
+// SiteSkite restore guard: during restore only load SiteSkite so missing plugin files do not cause fatals.
+if (!defined('ABSPATH')) {
+    return;
+}
+\$only_siteskite = ['{$siteskite_basename}'];
+add_filter('pre_option_active_plugins', function (\$pre, \$option, \$default) use (\$only_siteskite) {
+    return get_option('siteskite_restore_in_progress') ? \$only_siteskite : \$pre;
+}, 1, 3);
+add_filter('pre_site_option_active_sitewide_plugins', function (\$pre, \$option, \$default) use (\$only_siteskite) {
+    if (!get_option('siteskite_restore_in_progress')) {
+        return \$pre;
+    }
+    return \$only_siteskite ? [ \$only_siteskite[0] => time() ] : \$pre;
+}, 1, 3);
+PHP;
+        // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_file_put_contents
+        @file_put_contents($path, $content);
+    }
+    /**
+     * Remove the restore guard must-use plugin so plugins load normally again.
+     */
+    private function remove_restore_guard_mu_plugin(): void
+    {
+        $path = $this->get_restore_guard_mu_plugin_path();
+        if (file_exists($path) && is_writable($path)) {
+            wp_delete_file($path);
+        }
+    }
+    /**
+     * Check if database restore file exists and is readable.
+     * If file is missing and restore is already finalized, logs and returns false (caller should return).
+     *
+     * @param string $backup_id Backup ID
+     * @param string $download_url Path to database zip
+     * @return bool False if caller should return early (file missing and finalized); true if file is ok
+     */
+    private function check_database_restore_file_readable(string $backup_id, string $download_url): bool
+    {
+        if (is_readable($download_url) && filesize($download_url)) {
+            return true;
+        }
+        if ($this->is_restore_finalized($backup_id, 'database')) {
+            $this->logger->info('Backup file no longer present but restore already finalized, skipping (duplicate cron)', [
+                'backup_id' => $backup_id
+            ]);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Persist database restore completed state (option cache clear + full payload).
+     * Survives SQL import overwriting the option by writing a complete payload.
+     *
+     * @param string $backup_id Backup ID
+     * @param int $total_queries Total queries executed
+     * @param bool $suppress_notification Whether to suppress completion notification
+     */
+    private function persist_database_restore_completed(string $backup_id, int $total_queries, bool $suppress_notification = false): void
+    {
+        $option_key = self::OPTION_PREFIX . $backup_id;
+        if (function_exists('wp_cache_delete')) {
+            wp_cache_delete($option_key, 'options');
+        }
+        $this->update_restore_status($backup_id, [
+            'status' => 'completed',
+            'progress' => 100,
+            'completed_at' => time(),
+            'message' => 'Database restore completed successfully',
+            'current_operation' => 'Database restore completed successfully',
+            'scope' => 'database',
+            'db_total_queries' => $total_queries,
+            'db_queries_processed' => $total_queries,
+            'db_restore_complete' => true
+        ], $suppress_notification);
+    }
+    /**
+     * Build and save completed classic restore state to file (for progress API fallback when option is overwritten).
+     *
+     * @param string $backup_id Backup ID
+     * @param string $type Restore type (database, files, full)
+     */
+    private function build_and_save_completed_restore_state_file(string $backup_id, string $type): void
+    {
+        $final_restore_info = get_option(self::OPTION_PREFIX . $backup_id, []);
+        $final_restore_type = $final_restore_info['type'] ?? $type;
+        $final_scope = $final_restore_info['scope'] ?? $type;
+        $final_progress_data = [
+            'status' => 'completed',
+            'progress' => 100,
+            'message' => $final_restore_info['message'] ?? 'Restore completed successfully',
+            'backup_id' => $backup_id,
+            'completed_at' => $final_restore_info['completed_at'] ?? time(),
+            'operation_type' => 'restore',
+            'is_restore' => true,
+            'type' => $final_restore_type,
+            'scope' => $final_scope
+        ];
+        $classic_restore_progress = $this->get_classic_restore_progress(
+            $backup_id,
+            array_merge($final_restore_info ?: [], ['status' => 'completed', 'progress' => 100, 'scope' => $final_scope]),
+            $final_restore_type
+        );
+        $final_progress_data['classic_restore'] = $classic_restore_progress;
+        if (isset($final_progress_data['classic_restore']['database'])) {
+            $final_progress_data['classic_restore']['database']['status'] = 'completed';
+            $final_progress_data['classic_restore']['database']['complete'] = true;
+            $final_progress_data['classic_restore']['database']['progress_percent'] = 100.0;
+        }
+        if (isset($final_progress_data['classic_restore']['files'])) {
+            $final_progress_data['classic_restore']['files']['status'] = 'completed';
+            $final_progress_data['classic_restore']['files']['complete'] = true;
+            $final_progress_data['classic_restore']['files']['progress_percent'] = 100.0;
+        }
+        if (isset($final_progress_data['classic_restore']['full'])) {
+            $final_progress_data['classic_restore']['full']['status'] = 'completed';
+            $final_progress_data['classic_restore']['full']['complete'] = true;
+            $final_progress_data['classic_restore']['full']['overall_progress'] = 100.0;
+        }
+        $this->save_last_classic_restore_state_to_file($backup_id, $final_progress_data);
+    }
+    /**
      * Check if restore was completed by checking webhook sent flags
+     *
      * @param string $backup_id Backup ID (not manifest ID)
+     * @param bool $from_db If true, read webhook_sent from DB to bypass cache (use at start of process_restore)
      * @return array{found: bool, scope: string|null} Whether webhook was found and the scope
      */
     private function check_restore_completion_webhook(string $backup_id, ?string $scope = null): array
+    private function check_restore_completion_webhook(string $backup_id, ?string $scope = null, bool $from_db = false): array
+    {
         // If scope is specified, only check that scope
 …
             $webhook_sent_key = 'siteskite_restore_webhook_sent_' . $backup_id . '_' . $check_scope;
+            // Clear options cache to ensure we get the latest value
+            if (function_exists('wp_cache_delete')) {
+                wp_cache_delete($webhook_sent_key, 'options');
+            }
+            // Check if webhook was sent (value is a timestamp, so it should be numeric > 0)
+            $webhook_value = get_option($webhook_sent_key, false);
+            if ($from_db) {
+                $webhook_value = $this->get_option_from_db($webhook_sent_key);
+            } else {
+                if (function_exists('wp_cache_delete')) {
+                    wp_cache_delete($webhook_sent_key, 'options');
+                }
+                $webhook_value = get_option($webhook_sent_key, false);
+            }
             if ($webhook_value !== false && $webhook_value !== '' && is_numeric($webhook_value) && $webhook_value > 0) {
                 return ['found' => true, 'scope' => $check_scope];
 …
     private function check_restore_completion_status(string $manifestId, ?string $scope = null): array
+    {
+        // Clear options cache so we read from DB (avoids stale cache after SQL import or duplicate cron)
+        $option_key = self::OPTION_PREFIX . $manifestId;
+        if (function_exists('wp_cache_delete')) {
+            wp_cache_delete($option_key, 'options');
+        }
+        $backup_id = $this->extract_backup_id_from_manifest_id($manifestId) ?? $manifestId;
+        if ($scope) {
+            $webhook_key = 'siteskite_restore_webhook_sent_' . $backup_id . '_' . $scope;
+            if (function_exists('wp_cache_delete')) {
+                wp_cache_delete($webhook_key, 'options');
+            }
+        } else {
+            foreach (['database', 'files', 'full'] as $s) {
+                if (function_exists('wp_cache_delete')) {
+                    wp_cache_delete('siteskite_restore_webhook_sent_' . $backup_id . '_' . $s, 'options');
+                }
+            }
+        }
         // Check restore status first
         $existing_status = get_option(self::OPTION_PREFIX . $manifestId);
+        $existing_status = get_option($option_key);
         if (!empty($existing_status) && is_array($existing_status) && isset($existing_status['status'])) {
             if ($existing_status['status'] === 'completed') {
 …
+        }
         // Check webhook sent flags (scope-aware)
         $backup_id = $this->extract_backup_id_from_manifest_id($manifestId) ?? $manifestId;
         $webhook_check = $this->check_restore_completion_webhook($backup_id, $scope);
+        // Check webhook sent flags (scope-aware) - backup_id already set above.
+        // Read from DB so we see value set by a previous request (e.g. duplicate cron after first run completed).
+        $webhook_check = $this->check_restore_completion_webhook($backup_id, $scope, true);
         if ($webhook_check['found']) {
 …
+                            }
+                            $code = (int) wp_remote_retrieve_response_code($chunk_response);
+                            if ($code < 200 || $code >= 300) {
+                                $this->logger->warning('Chunk download returned non-2xx', [
+                                    'chunk_hash' => substr($chunk_hash, 0, 16) . '...',
+                                    'http_code' => $code,
+                                    'file_path' => $file_path
+                                ]);
+                                continue;
+                            }
                             $chunk_data = wp_remote_retrieve_body($chunk_response);
+                            $chunk_data = is_string($chunk_data) ? $chunk_data : '';
+                            if ($chunk_data === '') {
+                                $this->logger->warning('Chunk body empty (hosting may strip or buffer response)', [
+                                    'chunk_hash' => substr($chunk_hash, 0, 16) . '...',
+                                    'file_path' => $file_path,
+                                    'http_code' => $code
+                                ]);
+                                continue;
+                            }
                             // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fwrite -- Required for file chunk streaming
+                            fwrite($file_handle, $chunk_data);
+                            $written = fwrite($file_handle, $chunk_data);
+                            if ($written !== strlen($chunk_data)) {
+                                $this->logger->warning('fwrite wrote fewer bytes than chunk (hosting disk/limits?)', [
+                                    'expected' => strlen($chunk_data),
+                                    'written' => $written,
+                                    'file_path' => $file_path
+                                ]);
+                            }
+                        }
+                        // Flush so data is on disk before close (hosting compatibility)
+                        if (is_resource($file_handle)) {
+                            fflush($file_handle);
+                        }
                         // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- Required for file chunk streaming
                         fclose($file_handle);
+                        // Extra diagnostics: log reconstructed file size and chunk coverage
+                        $size_on_disk = file_exists($target_file) ? filesize($target_file) : null;
+                        $this->logger->info('Reconstructed file from chunks with provider', [
+                            'backup_id'         => $backup_id,
+                            'provider'          => $provider,
+                            'file_path'         => $file_path,
+                            'target_file'       => $target_file,
+                            'chunks_expected'   => count($chunk_hashes),
+                            'chunks_downloaded' => count(array_intersect($chunk_hashes, array_keys($downloaded_chunks))),
+                            'size_on_disk'      => $size_on_disk,
+                        ]);
                         // Set file modification time
                         if (isset($file_info['mtime'])) {
 …
+                            }
+                            $chunk_data = $downloaded_chunks[$chunk_hash];
                             // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fwrite -- Required for file chunk streaming
+                            fwrite($file_handle, $downloaded_chunks[$chunk_hash]);
+                            $written = fwrite($file_handle, $chunk_data);
+                            if ($written !== strlen($chunk_data)) {
+                                $this->logger->warning('fwrite wrote fewer bytes than chunk (provider)', [
+                                    'expected' => strlen($chunk_data),
+                                    'written' => $written,
+                                    'file_path' => $file_path
+                                ]);
+                            }
+                        }
+                        if (is_resource($file_handle)) {
+                            fflush($file_handle);
+                        }
                         // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- Required for file chunk streaming
                         fclose($file_handle);
+                        // Extra diagnostics: log reconstructed adaptive file size and chunk coverage
+                        $size_on_disk = file_exists($target_file) ? filesize($target_file) : null;
+                        $this->logger->info('Reconstructed adaptive file with provider', [
+                            'provider'          => $provider,
+                            'file_path'         => $file_path,
+                            'target_file'       => $target_file,
+                            'chunks_expected'   => count($chunk_hashes),
+                            'chunks_downloaded' => count(array_intersect($chunk_hashes, array_keys($downloaded_chunks))),
+                            'size_on_disk'      => $size_on_disk,
+                        ]);
                         // Set file modification time
                         $file_info = $filtered_manifest['files'][$file_path] ?? [];
 …
                         foreach ($chunk_hashes as $chunk_hash) {
                             if (isset($downloaded_chunks[$chunk_hash])) {
+                                $chunk_data = $downloaded_chunks[$chunk_hash];
                                 // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fwrite -- Required for file chunk streaming
+                                fwrite($file_handle, $downloaded_chunks[$chunk_hash]);
+                                $written = fwrite($file_handle, $chunk_data);
+                                if ($written !== strlen($chunk_data)) {
+                                    $this->logger->warning('fwrite wrote fewer bytes than chunk (adaptive provider)', [
+                                        'expected' => strlen($chunk_data),
+                                        'written' => $written,
+                                        'file_path' => $file_path
+                                    ]);
+                                }
+                            }
+                        }
+                        if (is_resource($file_handle)) {
+                            fflush($file_handle);
+                        }
                         // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- Required for file chunk streaming
                         fclose($file_handle);
 …
+                        }
+                        $code = (int) wp_remote_retrieve_response_code($chunk_response);
+                        if ($code < 200 || $code >= 300) {
+                            $this->logger->warning('Chunk download returned non-2xx (adaptive)', [
+                                'chunk_hash' => substr($chunk_hash, 0, 16) . '...',
+                                'http_code' => $code,
+                                'file_path' => $file_path
+                            ]);
+                            continue;
+                        }
                         $chunk_data = wp_remote_retrieve_body($chunk_response);
+                        $chunk_data = is_string($chunk_data) ? $chunk_data : '';
+                        if ($chunk_data === '') {
+                            $this->logger->warning('Chunk body empty (adaptive)', [
+                                'chunk_hash' => substr($chunk_hash, 0, 16) . '...',
+                                'file_path' => $file_path
+                            ]);
+                            continue;
+                        }
                         // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fwrite -- Required for file chunk streaming
+                        fwrite($file_handle, $chunk_data);
+                    }
+                        $written = fwrite($file_handle, $chunk_data);
+                        if ($written !== strlen($chunk_data)) {
+                            $this->logger->warning('fwrite wrote fewer bytes than chunk (adaptive)', [
+                                'expected' => strlen($chunk_data),
+                                'written' => $written,
+                                'file_path' => $file_path
+                            ]);
+                        }
+                    }
+                    // Flush so data is on disk before close (hosting compatibility)
+                    if (is_resource($file_handle)) {
+                        fflush($file_handle);
+                    }
                     // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- Required for file chunk streaming
                     fclose($file_handle);
 …
                 file_put_contents($temp_archive, $archive_data);
+                // Extract archive
+                $zip = new \ZipArchive();
+                if ($zip->open($temp_archive) === TRUE) {
+                    $zip->extractTo($restore_dir);
+                // Extract archive (ZipArchive or PclZip fallback)
+                try {
+                    $zip = $this->open_zip_for_restore($temp_archive);
+                    $num_files = $zip->numFiles;
+                    $extract_ok = $zip->extractTo($restore_dir);
                     $zip->close();
+                    $this->logger->info('Extracted batch archive', [
+                        'batch_id' => $batch_id,
+                        'files_extracted' => $zip->numFiles
+                    ]);
+                } else {
+                    if ($extract_ok !== false) {
+                        $this->logger->info('Extracted batch archive', [
+                            'batch_id' => $batch_id,
+                            'files_extracted' => $num_files
+                        ]);
+                    } else {
+                        $this->logger->error('Failed to extract batch archive', [
+                            'batch_id' => $batch_id,
+                            'temp_archive' => $temp_archive
+                        ]);
+                    }
+                } catch (\RuntimeException $e) {
                     $this->logger->error('Failed to open batch archive', [
                         'batch_id' => $batch_id,
+                        'temp_archive' => $temp_archive
+                        'temp_archive' => $temp_archive,
+                        'error' => $e->getMessage()
                     ]);
+                }
 …
     private function is_safe_restore_query(string $query): bool
+    {
         // Remove comments and normalize whitespace
+        // Remove line comments (-- to EOL)
         $query = preg_replace('/--.*$/m', '', $query);
+        $query = trim($query);
+        // MySQL conditional comments /*!40101 SET ... */: extract inner part so we can allow safe SET/options
+        while (preg_match('/^\s*\/\*![\d]*\s*(.*?)\*\//s', $query, $m)) {
+            $inner = trim($m[1]);
+            $query = $inner . substr($query, strlen($m[0]));
+            $query = trim($query);
+        }
+        // Remove remaining block comments (non-conditional)
         $query = preg_replace('/\/\*.*?\*\//s', '', $query);
         $query = trim($query);
         if (empty($query)) {
             return false;
 …
         $allowed_operations = [
             'CREATE TABLE',
             'DROP TABLE',
+            'DROP TABLE IF EXISTS',
             'INSERT IGNORE INTO',
             'INSERT INTO',
             'UPDATE ',
-            'DELETE FROM',
-            'ALTER TABLE',
             'CREATE INDEX',
-            'DROP INDEX',
             'LOCK TABLES',
             'UNLOCK TABLES',
 …
     private function validate_query_security(string $query): bool
+    {
+        // Block potentially dangerous operations
+        // Only check dangerous patterns in the statement header (first ~400 chars).
+        // INSERT/UPDATE data can contain words like TRUNCATE or RENAME; we must not reject based on payload.
+        $header_len = 400;
+        $query_header = strlen($query) > $header_len ? substr($query, 0, $header_len) : $query;
         $dangerous_patterns = [
             '/\bDROP\s+DATABASE\b/i',
 …
         foreach ($dangerous_patterns as $pattern) {
             if (preg_match($pattern, $query)) {
+            if (preg_match($pattern, $query_header)) {
                 return false;
+            }
+        }
         // Block queries that try to access system tables
+        // Block queries that try to access system tables (check full query)
         $system_tables = [
             'mysql.',
 …
     /**
+     * Clear completion state for a backup_id so a user-initiated second restore can run.
+     * Call this when the user explicitly starts a new restore (e.g. "Restore" again).
+     * Clears webhook_sent, state file, and running lock so is_restore_finalized is false and progress doesn't return "completed".
+     *
+     * @param string $backup_id Backup ID
+     */
+    public function clear_restore_completion_state_for_retry(string $backup_id): void
+    {
+        $scopes = ['files', 'database', 'full'];
+        foreach ($scopes as $scope) {
+            $webhook_sent_key = 'siteskite_restore_webhook_sent_' . $backup_id . '_' . $scope;
+            delete_option($webhook_sent_key);
+            $this->clear_restore_running_lock($backup_id, $scope);
+        }
+        $this->remove_last_classic_restore_state_from_file($backup_id);
+        $this->logger->info('Cleared restore completion state for retry', [
+            'backup_id' => $backup_id
+        ]);
+    }
+    /**
      * Remove last classic restore state from JSON file
      * Similar to remove_last_restore_state_from_file but for classic restores (uses backup_id instead of manifestId)

siteskite/trunk/languages/siteskite.pot

r3446096	r3453079
2	2	msgid ""
3	3	msgstr ""
4		"Project-Id-Version: SiteSkite Link 1.2.3\n"
	4	"Project-Id-Version: SiteSkite Link 1.2.5\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

-                      r3446096
+                      r3453079
 Tested up to: 6.9
 Requires PHP: 7.4
 Stable tag: 1.2.3
+Stable tag: 1.2.5
 License: GPLv2 or later
 License URI: https://www.gnu.org/licenses/gpl-2.0.html
 …
 == Changelog ==
+= 1.2.3 (23 January 2026) =
+* Improved: Backup performance
+= 1.2.5 (03 February 2026) =
+* New: Recovery Mode: Regain WordPress admin access after fatal errors or failed updates.”
+* Improved: 1 Click WP Admin Login
+* Improved: Site Connection Experience (RestAPI Fallback)
+* Improved: Smart Cron Jobs
+* Improved: Classic Backup & Restore
+* Improved: Cache Busting
+* Improved: Site Data Syncing
+* Improved: Add new site connection experience
+* Improved: Incremental Backup & Restore
+* Fixed: Trigger new database when restore job done
+* Fixed: Trigger new database when making files only backup
+= 1.2.3 (25 January 2026) =
+Improved: Backup performance
 …
 = 1.0.7 (13 December 2025) =
 * Added: Better Backup management
+* New: Better Backup management
 * Improved: Backup performance
 = 1.0.6 (10 December 2025) =
 * Added: pCloud Auth based Authentication
+* New: pCloud Auth based Authentication
 * Improved: Backup performance
 …
 * Initial release
 == Upgrade Notice ==
+= 1.0.9 =
+* Fixed: Subdirectory site paths now preserved when adding domain
+= 1.2.5 (03 February 2026) =
+* New: Recovery Mode: Regain WordPress admin access after fatal errors or failed updates.”
+* Improved: 1 Click WP Admin Login
+* Improved: Site Connection Experience (RestAPI Fallback)
+* Improved: Smart Cron Jobs
+* Improved: Classic Backup & Restore
+* Improved: Cache Busting
+* Improved: Incremental Backup & Restore
+* Improved: Incremental/Classic Backup & Restore DB records cleanup
+* Fixed: Trigger new database when restore job done
+* Fixed: Trigger new database when making files only backup.
+= 1.2.3 (25 January 2026) =
+Improved: Backup performance
+= 1.2.2 (23 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
+= 1.2.0 (20 January 2026) =
+* New: Create Sandbox site from existing backup
+* New: Create Blueprints via Sandbox site
+* Improved: Backup performance
+* Improved: Site data sync
+* Improved: UI/UX - Site thumbnail and logo
+= 1.1.0 (1 January 2026) =
+* Improvied: Classic & Incremental Backup performance
+* New: Blueprints, Create reusable sandbox sites from blueprints. ·  https://knowledgebase.siteskite.com/articles/siteskite-blueprints
+* New: Preety Error logs: Error log, Debug log, or Custom error log paths.
+* Improvements: Overall SiteSkite platform performance.
+= 1.0.9 (25 December 2025) =
+* Fixed: Subdirectory site paths now preserved when adding domain (e.g., abc.com/newsite instead of abc.com)
 = 1.0.8 (16 December 2025) =
 …
 = 1.0.7 (13 December 2025) =
 * Added: Better Backup management
+* New: Better Backup management
 * Improved: Backup performance
 = 1.0.6 (10 December 2025) =
 * Added: pCloud Auth based Authentication
+* New: pCloud Auth based Authentication
 * Improved: Backup performance
 …
 * Improved: Notifications
 = 1.0.3 (15 November 2025) =
 * Improved: SiteSkite WPCanvas Improvements
+= 1.0.3 (18 November 2025) =
+* Improved: WPCanvas Improvements
 = 1.0.2 (15 November 2025) =
 * Improved: Backup & Restore Service for CDN enabled sites
 = 1.0.1 =
+= 1.0.1 (08 November 2025) =
 * Admin view update
 = 1.0.0 =
+First release of SiteSkite Link. Connect your WordPress site to SiteSkite for backups, updates, monitoring, and more.
+* Initial release

siteskite/trunk/siteskite-link.php

-                      r3446096
+                      r3453079
  * 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.3
+ * Version: 1.2.5
  * Requires at least: 5.3
  * Requires PHP: 7.4
 …
 // Plugin version
 define('SITESKITE_VERSION', '1.2.3');
+define('SITESKITE_VERSION', '1.2.5');
 // Plugin file, path, and URL

siteskite/trunk/uninstall.php

-                      r3389896
+                      r3453079
 // Clear any rewrite rules
+flush_rewrite_rules();
+flush_rewrite_rules();
+// Remove SiteSkite safety mu-plugin and wp-content/siteskite/ (recovery script, key, flag)
+$content_dir = defined('WP_CONTENT_DIR') ? WP_CONTENT_DIR : dirname(dirname(__DIR__));
+$siteskite_dir = $content_dir . '/siteskite';
+$files = [
+    $content_dir . '/mu-plugins/siteskite-plugin-safety.php',
+    $siteskite_dir . '/siteskite-recovery.php',
+    $siteskite_dir . '/siteskite-recovery-disable.php',
+    $siteskite_dir . '/siteskite-recovery-key.php',
+    $siteskite_dir . '/recovery.flag',
+];
+foreach ($files as $file) {
+    if (file_exists($file) && is_writable($file)) {
+        wp_delete_file($file);
+    }
+}
+if (is_dir($siteskite_dir) && @rmdir($siteskite_dir)) {
+    // Removed empty wp-content/siteskite/
+}

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

Trac UI Preferences

Plugin Directory