Changeset 3418578

siteskite/trunk/assets/css/admin.css

-                      r3390201
+                      r3418578
     color: #1d2327;
+}
+/* External Cron Settings Styles */
+.siteskite-external-cron {
+    margin-top: 30px;
+}
+.siteskite-external-cron h2 {
+    margin-top: 0;
+    margin-bottom: 10px;
+    font-size: 1.3em;
+    color: #1d2327;
+}
+.siteskite-external-cron .form-field {
+    margin-bottom: 20px;
+}
+.siteskite-external-cron .form-field label {
+    font-weight: 600;
+    margin-bottom: 8px;
+}
+.siteskite-external-cron .form-field input[type="checkbox"] {
+    margin-right: 8px;
+}
+.siteskite-external-cron .api-key-container {
+    margin-top: 5px;
+}
+.siteskite-external-cron .description {
+    font-style: normal;
+    color: #646970;
+    margin-top: 5px;
+}
+.siteskite-external-cron .description strong {
+    color: #1d2327;
+}

siteskite/trunk/includes/API/RestAPI.php

-                      r3400843
+                      r3418578
 use SiteSkite\Restore\RestoreManager;
 use SiteSkite\Schedule\ScheduleManager;
+use SiteSkite\Cron\CronTriggerHandler;
 use SiteSkite\WPCanvas\WPCanvasController;
 …
     private RestoreManager $restore_manager;
     private ScheduleManager $schedule_manager;
+    private ?CronTriggerHandler $cron_trigger_handler = null;
     private WPCanvasController $wp_canvas_controller;
 …
         Logger $logger,
         RestoreManager $restore_manager,
+        ScheduleManager $schedule_manager
+        ScheduleManager $schedule_manager,
+        ?CronTriggerHandler $cron_trigger_handler = null
     ) {
         $this->auth_manager = $auth_manager;
 …
         $this->restore_manager = $restore_manager;
         $this->schedule_manager = $schedule_manager;
+        $this->cron_trigger_handler = $cron_trigger_handler;
         $this->cleanup_manager = $cleanup_manager;
         $this->wp_canvas_controller = new WPCanvasController($this->logger, $this->auth_manager);
 …
         );
+        // Cron trigger endpoint (for external cron service)
+        if ($this->cron_trigger_handler) {
+            register_rest_route(
+                self::API_NAMESPACE,
+                '/cron/trigger',
+                [
+                    'methods' => WP_REST_Server::CREATABLE,
+                    'callback' => [$this->cron_trigger_handler, 'handle_trigger'],
+                    'permission_callback' => '__return_true', // Authentication via secret token in header
+                    // Don't validate args here - we handle validation in the callback
+                    // This allows cron-job.org to send JSON body without WordPress REST API validation issues
+                    'args' => []
+                ]
+            );
+        }

siteskite/trunk/includes/Backup/BackupManager.php

-                      r3416301
+                      r3418578
 use SiteSkite\Cloud\BackblazeB2Manager;
 use SiteSkite\Cloud\PCloudManager;
+use SiteSkite\Cron\ExternalCronManager;
 use SiteSkite\Backup\Incremental\BackupConfig;
 use SiteSkite\Backup\Incremental\Chunker;
 …
 use SiteSkite\Backup\Incremental\Impl\PCloudObjectStore;
 use SiteSkite\Backup\Incremental\Impl\S3ObjectStore;
+use SiteSkite\Core\Utils;
 use function get_option;
 use function update_option;
 …
     private PCloudManager $pcloud_manager;
+    /**
+     * @var ExternalCronManager|null External cron manager instance
+     */
+    private ?ExternalCronManager $external_cron_manager = null;
     // Backup directory is now accessed via SITESKITE_BACKUP_PATH constant
 …
     private const BACKUP_TIMEOUT = 300; // 5 minutes
     private const EXCLUDED_PATHS = [
         '.git',
+       '.git',
         'node_modules',
         'wpcodeboxide',
+        'vdconnect-*',
+        'litespeed',
         'backup-migration-*',
         'wp-content/cache',
 …
         'wp-content/rb-plugins',
         'wp-content/nginx_cache',
+        'wp-content/wpvivid_*',
+        'wp-content/wpvividbackups',
         //temporary test
         //'wp-content/plugins',
         //'wp-admin',
         //'wp-includes',
+        'wp-content/plugins',
+        'wp-admin',
+        'wp-includes',
 …
      * @param AWSManager $aws_manager AWS manager instance
      * @param \SiteSkite\Backup\Incremental\IncrementalStatus $incremental_status Incremental status manager instance
+     * @param ExternalCronManager|null $external_cron_manager External cron manager instance
      */
     public function __construct(
 …
         PCloudManager $pcloud_manager,
         AWSManager $aws_manager,
+        \SiteSkite\Backup\Incremental\IncrementalStatus $incremental_status
+        \SiteSkite\Backup\Incremental\IncrementalStatus $incremental_status,
+        ?ExternalCronManager $external_cron_manager = null
     ) {
         $this->s3_manager = $s3_manager;
 …
         $this->aws_manager = $aws_manager;
         $this->incremental_status = $incremental_status;
+        $this->external_cron_manager = $external_cron_manager;
         $this->init_backup_directory();
 …
             throw new \RuntimeException('Failed to create backup directory');
+        }
+    }
+    /**
+     * Schedule cron event (uses external cron if enabled, otherwise WordPress cron)
+     */
+    private function schedule_cron_event(string $hook, array $args, int $delay_seconds = 0, string $title = ''): void
+    {
+        // Try external cron first if enabled
+        if ($this->external_cron_manager && $this->external_cron_manager->is_enabled()) {
+            // Check if job already exists to prevent duplicates
+            $existing_job_id = $this->external_cron_manager->get_job_id_by_action($hook, $args);
+            if ($existing_job_id) {
+                $this->logger->debug('Cron job already exists, skipping creation', [
+                    'hook' => $hook,
+                    'existing_job_id' => $existing_job_id
+                ]);
+                return;
+            }
+            // For incremental continuation jobs, always use recurring "every_minute" job that deletes after first run
+            // This ensures the job runs as soon as possible and is cleaned up automatically
+            if ($hook === 'siteskite_incremental_continue') {
+                $job_id = $this->external_cron_manager->create_recurring_job($hook, $args, 'every_minute', [], $title);
+                if ($job_id) {
+                    // Mark job for deletion after first successful run
+                    $this->external_cron_manager->mark_job_for_deletion_after_first_run($hook, $args);
+                    $this->logger->debug('Scheduled external cron event (recurring, auto-delete)', [
+                        'hook' => $hook,
+                        'job_id' => $job_id,
+                        'type' => 'recurring_every_minute'
+                    ]);
+                    return;
+                } else {
+                    $this->logger->warning('Failed to schedule external cron, falling back to WordPress cron', [
+                        'hook' => $hook
+                    ]);
+                }
+            } else {
+                // For other jobs, use normal single event scheduling
+                $job_id = $this->external_cron_manager->schedule_single_event($hook, $args, $delay_seconds, $title);
+                if ($job_id) {
+                    $this->logger->debug('Scheduled external cron event', [
+                        'hook' => $hook,
+                        'delay' => $delay_seconds,
+                        'job_id' => $job_id
+                    ]);
+                    return;
+                } else {
+                    $this->logger->warning('Failed to schedule external cron, falling back to WordPress cron', [
+                        'hook' => $hook
+                    ]);
+                }
+            }
+        }
+        // Fallback to WordPress cron
+        wp_schedule_single_event(time() + $delay_seconds, $hook, $args);
+    }
 …
             // Schedule the actual backup process to run immediately after this request
+            wp_schedule_single_event(
+                time(),
+            $this->schedule_cron_event(
                 'process_' . $type . '_backup_cron',
+                [
                     'backup_id' => $backup_id,
                     'callback_url' => $callback_url
+                ]
+                ],
+, // Will be converted to recurring job for external cron, immediate for WordPress cron
+                "SiteSkite Process {$type} Backup"
             );
 …
             // Schedule cleanup
                 if (!wp_next_scheduled('siteskite_cleanup_backup_files', [$backup_id])) {
                     wp_schedule_single_event(time() + 300, 'siteskite_cleanup_backup_files', [$backup_id]);
+                    $this->schedule_cron_event('siteskite_cleanup_backup_files', [$backup_id], 300, "SiteSkite Cleanup Backup Files");
+            }
 …
             // Schedule cleanup
                     if (!wp_next_scheduled('siteskite_cleanup_backup_files', [$backup_id])) {
                         wp_schedule_single_event(time() + 300, 'siteskite_cleanup_backup_files', [$backup_id]);
+                        $this->schedule_cron_event('siteskite_cleanup_backup_files', [$backup_id], 300, "SiteSkite Cleanup Backup Files");
+                    }
 …
                 $status_data = $resolved;
                 // If credentials are stale, refresh via centralized approach
                 $credentials_age = time() - ($status_data['initialized_at'] ?? 0);
                 if ($credentials_age > 3600) {
+                // Check if credentials are stale using expiration metadata (if available) or fallback to hardcoded threshold
+                $needs_refresh = $this->should_refresh_credentials($status_data, $provider, $backup_id);
+                if ($needs_refresh) {
                     $this->refresh_credentials_for_incremental($backup_id, $provider);
                     return;
 …
             // Schedule cleanup for classic full backup
             if (!wp_next_scheduled('siteskite_cleanup_backup_files', [$backup_id])) {
                 wp_schedule_single_event(time() + 300, 'siteskite_cleanup_backup_files', [$backup_id]);
+                $this->schedule_cron_event('siteskite_cleanup_backup_files', [$backup_id], 300, "SiteSkite Cleanup Backup Files");
+            }
 …
             'file_size' => $backup_info['file_size'] ?? 0
         ]);
+        // Clean up any pending incremental continuation jobs for this backup
+        if ($this->external_cron_manager && $this->external_cron_manager->is_enabled()) {
+            $deleted_count = $this->external_cron_manager->delete_jobs_by_backup_id('siteskite_incremental_continue', $backup_id);
+            if ($deleted_count > 0) {
+                $this->logger->info('Cleaned up incremental continuation jobs after backup completion', [
+                    'backup_id' => $backup_id,
+                    'deleted_count' => $deleted_count
+                ]);
+            }
+        }
+        // Also clear WordPress cron events for this backup
+        wp_clear_scheduled_hook('siteskite_incremental_continue', [$backup_id]);
             // For full backups, retry any pending uploads now that _full.zip is ready
 …
+    }
     /**
      * Execute provider-specific upload logic
 …
     private function execute_provider_upload(string $backup_id, string $provider, string $file_path, array $status_data): array
+    {
+        // Get user_id and site_host for folder structure: {user_id}/{site_host}/{backup_id}_{type}.zip
+        $user_id = Utils::get_user_id();
+        $site_host = wp_parse_url(get_option('siteurl'), PHP_URL_HOST) ?: 'site';
+        $file_name = basename($file_path);
+        // Construct the target path with user_id and site_host folders
+        $target_path = $user_id . '/' . $site_host . '/' . $file_name;
         switch ($provider) {
             case 'aws_s3':
 …
                     throw new \RuntimeException('Missing AWS S3 presigned URL');
+                }
+                // For AWS S3, the AWSManager will construct the S3 key with site_host folder structure
                 return $this->aws_manager->upload_file_to_s3_presigned($presigned_url, $file_path);
 …
                     throw new \RuntimeException('Missing Dropbox access_token');
+                }
+                // For Dropbox, construct path as: {base_folder}/{user_id}/{site_host}/{filename}
+                $base_folder = $status_data['folder'] ?? $status_data['target_directory'] ?? '';
+                // Construct the full folder path: base_folder/user_id/site_host
+                $dropbox_target_folder = !empty($base_folder)
+                    ? rtrim($base_folder, '/') . '/' . $user_id . '/' . $site_host
+                    : $user_id . '/' . $site_host;
                 return $this->dropbox_manager->upload_file(
                     $file_path,
                     $status_data['access_token'],
                     $status_data['folder'] ?? $status_data['target_directory'] ?? null
+                    $dropbox_target_folder
                 );
 …
                     throw new \RuntimeException('Missing Google Drive access_token');
+                }
+                // For Google Drive, find or create the user_id/site_host folder structure under the base folder
+                $base_folder_id = $status_data['google_drive_folder_id'] ?? null;
+                // Use find_or_create_folder_by_path to create the full path: user_id/site_host
+                $folder_path = $user_id . '/' . $site_host;
+                $target_folder_id = $this->google_drive_manager->find_or_create_folder_by_path($access_token, $folder_path, $base_folder_id);
+                if (!$target_folder_id) {
+                    throw new \RuntimeException('Failed to create Google Drive folder structure: ' . $folder_path);
+                }
                 return $this->google_drive_manager->upload_file(
                     $file_path,
                     $access_token,
                     $status_data['google_drive_folder_id'] ?? null
+                    $target_folder_id
                 );
 …
                     throw new \RuntimeException('Missing Backblaze B2 credentials (keyID/applicationKey/bucketName)');
+                }
+                // For Backblaze B2, use the target_path (user_id/site_host/filename) as the file name
                 return $this->backblaze_b2_manager->upload_file(
                     $file_path,
 …
                     (string)$status_data['applicationKey'],
                     (string)$status_data['bucketName'],
                     basename($file_path)
+                    $target_path
                 );
 …
                     throw new \RuntimeException('Missing pCloud credentials (folderName/access_token)');
+                }
+                // For pCloud, construct the remote path relative to folderName: {folderName}/{user_id}/{site_host}/{filename}
+                // The folderName is the base folder, and we create user_id/site_host structure inside it
+                $pcloud_remote_path = $folder_name . '/' . $user_id . '/' . $site_host . '/' . $file_name;
                 return $this->pcloud_manager->upload_file(
                     $file_path,
                     $folder_name,
                     $access_token,
                     $status_data['remote_path'] ?? null
+                    $pcloud_remote_path
                 );
 …
                         try { $coordinator->saveRemoteIndex($remoteIndex, $provider); } catch (\Throwable $t) { /* ignore */ }
                         try { $this->update_incremental_progress($backup_id, $progress); } catch (\Throwable $t) { /* ignore */ }
+                        if (function_exists('wp_schedule_single_event')) {
+                            \wp_schedule_single_event(time() + 60, 'siteskite_incremental_continue', [$backup_id]);
+                        }
+                        $this->schedule_cron_event('siteskite_incremental_continue', [$backup_id], 60, "SiteSkite Incremental Continue");
                         return $uploadedBytes; // Halt this pass to avoid spamming 401s
+                    }
 …
                 'total_files' => $totalFiles,
                 'has_deferred_chunks' => $hasDeferredChunks,
+                'deferred_count' => count($remainingDeferred)
+            ]);
+                'deferred_count' => count($remainingDeferred),
+                'files_processed_this_cycle' => count($filesToProcess)
+            ]);
+            // Check if we processed 150 files in this cycle (indicating more files to process)
+            $filesProcessedThisCycle = count($filesToProcess);
+            $processed150Files = $filesProcessedThisCycle >= 150;
             // Schedule next chunk if not completed and more files to process OR deferred chunks remain
+            $this->logger->info('Scheduling next incremental continue chunk', [
+                'backup_id' => $backup_id,
+                'processed_files' => $processedCount,
+                'total_files' => $totalFiles,
+                'has_deferred_chunks' => $hasDeferredChunks,
+                'deferred_count' => count($remainingDeferred)
+            ]);
+            // Schedule next chunk upload in 15 seconds (or sooner if we have deferred chunks)
+            $delay = $hasDeferredChunks ? 10 : 15;
+            $coordinator->scheduleNext($backup_id, $delay);
+            if ($processed150Files || $hasDeferredChunks) {
+                $this->logger->info('Scheduling next incremental continue chunk', [
+                    'backup_id' => $backup_id,
+                    'processed_files' => $processedCount,
+                    'total_files' => $totalFiles,
+                    'has_deferred_chunks' => $hasDeferredChunks,
+                    'deferred_count' => count($remainingDeferred),
+                    'files_processed_this_cycle' => $filesProcessedThisCycle,
+                    'processed_150_files' => $processed150Files
+                ]);
+                // Use external cron if enabled and we processed 150 files (or have deferred chunks)
+                if ($this->external_cron_manager && $this->external_cron_manager->is_enabled() && ($processed150Files || $hasDeferredChunks)) {
+                    // Check if job already exists to prevent duplicates
+                    $existing_job_id = $this->external_cron_manager->get_job_id_by_action('siteskite_incremental_continue', [$backup_id]);
+                    if (!$existing_job_id) {
+                        // Schedule recurring "every_minute" job that continues until all files are processed
+                        // Do NOT mark for auto-deletion - it will run every minute until completion
+                        $job_id = $this->external_cron_manager->create_recurring_job(
+                            'siteskite_incremental_continue',
+                            [$backup_id],
+                            'every_minute',
+                            [],
+                            "SiteSkite Incremental Continue"
+                        );
+                        if ($job_id) {
+                            $this->logger->info('Scheduled external cron for incremental continue (recurring every minute)', [
+                                'backup_id' => $backup_id,
+                                'job_id' => $job_id,
+                                'processed_150_files' => $processed150Files,
+                                'has_deferred_chunks' => $hasDeferredChunks,
+                                'processed_files' => $processedCount,
+                                'total_files' => $totalFiles
+                            ]);
+                        } else {
+                            // Fallback to coordinator scheduling if external cron fails
+                            $this->logger->warning('Failed to schedule external cron, falling back to coordinator', [
+                                'backup_id' => $backup_id
+                            ]);
+                            $delay = $hasDeferredChunks ? 10 : 15;
+                            $coordinator->scheduleNext($backup_id, $delay);
+                        }
+                    } else {
+                        $this->logger->debug('External cron job already exists for incremental continue, skipping creation', [
+                            'backup_id' => $backup_id,
+                            'existing_job_id' => $existing_job_id
+                        ]);
+                    }
+                } else {
+                    // Use coordinator scheduling if external cron is disabled or conditions not met
+                    $delay = $hasDeferredChunks ? 10 : 15;
+                    $coordinator->scheduleNext($backup_id, $delay);
+                }
+            } else {
+                // Not enough files processed and no deferred chunks - use normal scheduling
+                $delay = $hasDeferredChunks ? 10 : 15;
+                $coordinator->scheduleNext($backup_id, $delay);
+            }
         } else {
             $this->logger->info('Incremental upload completed, no further chunks needed', [
 …
                 'status' => $backup_status
             ]);
+            // Clean up any pending incremental continuation jobs for this backup
+            if ($this->external_cron_manager && $this->external_cron_manager->is_enabled()) {
+                $deleted_count = $this->external_cron_manager->delete_jobs_by_backup_id('siteskite_incremental_continue', $backup_id);
+                if ($deleted_count > 0) {
+                    $this->logger->info('Cleaned up pending incremental continuation jobs for completed backup', [
+                        'backup_id' => $backup_id,
+                        'deleted_count' => $deleted_count
+                    ]);
+                }
+            }
+            // Also clear WordPress cron events for this backup
+            wp_clear_scheduled_hook('siteskite_incremental_continue', [$backup_id]);
             // Ensure logs are cleared once more on any stray continue invocations post-completion
             try { $this->logger->delete_todays_log(); } catch (\Throwable $t) { /* ignore */ }
 …
                 ]);
                 // Schedule a short delayed retry
+                if (function_exists('wp_schedule_single_event')) {
+                    wp_schedule_single_event(time() + 15, 'siteskite_incremental_continue', [$backup_id]);
+                }
+                $this->schedule_cron_event('siteskite_incremental_continue', [$backup_id], 15, "SiteSkite Incremental Continue");
                 return;
+            }
 …
+            }
+            // Also check if credentials are stale (older than 1 hour)
+            $credentials_age = time() - ($status_data['initialized_at'] ?? 0);
+            if ($credentials_age > 3600) { // 1 hour
+            // Check if credentials are stale using expiration metadata (if available) or fallback to hardcoded threshold
+            $needs_refresh = $this->should_refresh_credentials($status_data, $provider, $backup_id);
+            if ($needs_refresh) {
+                $credentials_age = time() - ($status_data['initialized_at'] ?? 0);
                 $this->logger->info('Credentials are stale, refreshing for incremental backup', [
                     'backup_id' => $backup_id,
                     'provider' => $provider,
+                    'credentials_age' => $credentials_age
+                    'credentials_age' => $credentials_age,
+                    'has_expires' => isset($status_data['expires']),
+                    'expires_at' => $status_data['expires'] ?? null
                 ]);
 …
                         if (!empty($progress) && !empty($progress['completed'])) {
                             $this->complete_incremental_backup($backup_id, $status_data);
+                            // Clean up external cron recurring job after completion check
+                            if ($this->external_cron_manager && $this->external_cron_manager->is_enabled()) {
+                                $deleted_count = $this->external_cron_manager->delete_jobs_by_backup_id('siteskite_incremental_continue', $backup_id);
+                                if ($deleted_count > 0) {
+                                    $this->logger->info('Cleaned up external cron recurring job after incremental processing completion', [
+                                        'backup_id' => $backup_id,
+                                        'deleted_count' => $deleted_count
+                                    ]);
+                                }
+                            }
+                        }
                     } catch (\Throwable $t) { /* ignore finalize errors here */ }
 …
         // No presign endpoints present; fall back to generic requirement
         return $generic_has_all;
+    }
+    /**
+     * Check if credentials should be refreshed based on expiration metadata or fallback thresholds
+     *
+     * All providers now support expiration metadata from backend:
+     * - expires: Unix timestamp when credentials expire
+     * - recommended_refresh_before_expiry: Seconds before expiry to refresh proactively
+     * - recommended_refresh_after_files: Number of files after which to refresh
+     *
+     * @param array $status_data Status data containing credentials and metadata
+     * @param string $provider Provider name (e.g., 'pcloud', 'backblaze_b2', 'dropbox', 'google_drive')
+     * @param string|null $backup_id Optional backup ID for file count tracking
+     * @return bool True if credentials should be refreshed
+     */
+    private function should_refresh_credentials(array $status_data, string $provider, ?string $backup_id = null): bool
+    {
+        $currentTime = time();
+        // Provider-specific fallback thresholds (used if expires field is missing)
+        $provider_fallbacks = [
+            'backblaze_b2' => 82800,  // 23 hours (matches B2 token expiration)
+            'pcloud' => 86400,        // 24 hours
+            'dropbox' => 12600,       // 3.5 hours
+            'google_drive' => 3000,   // 50 minutes
+            'aws' => 3600,            // 1 hour (presigned URLs)
+            'aws_s3' => 3600,         // 1 hour (presigned URLs)
+        ];
+        $fallback_threshold = $provider_fallbacks[$provider] ?? 3600; // Default: 1 hour
+        // Check if expires field is present (backend provides expiration for all providers)
+        if (isset($status_data['expires']) && is_numeric($status_data['expires'])) {
+            $expiresAt = (int)$status_data['expires'];
+            // Check if credentials are actually expired
+            if ($currentTime >= $expiresAt) {
+                $this->logger->debug(ucfirst($provider) . ' credentials expired based on expires field', [
+                    'provider' => $provider,
+                    'expires_at' => $expiresAt,
+                    'current_time' => $currentTime,
+                    'expired_seconds_ago' => $currentTime - $expiresAt
+                ]);
+                return true;
+            }
+            // Check if we should refresh proactively (before expiry)
+            $recommended_refresh_before_expiry = isset($status_data['recommended_refresh_before_expiry'])
+                ? (int)$status_data['recommended_refresh_before_expiry']
+                : $this->get_default_refresh_before_expiry($provider);
+            $timeUntilExpiry = $expiresAt - $currentTime;
+            if ($timeUntilExpiry <= $recommended_refresh_before_expiry) {
+                $this->logger->debug(ucfirst($provider) . ' credentials should be refreshed proactively', [
+                    'provider' => $provider,
+                    'expires_at' => $expiresAt,
+                    'current_time' => $currentTime,
+                    'time_until_expiry' => $timeUntilExpiry,
+                    'recommended_refresh_before_expiry' => $recommended_refresh_before_expiry
+                ]);
+                return true;
+            }
+            // Check file count threshold if backup_id is provided
+            if ($backup_id !== null) {
+                $recommended_refresh_after_files = isset($status_data['recommended_refresh_after_files'])
+                    ? (int)$status_data['recommended_refresh_after_files']
+                    : 2000; // Default: 2000 files
+                // Get current upload count from incremental progress (count of processed files)
+                $progress = $this->get_incremental_progress($backup_id);
+                $uploaded_files = count($progress['processed_files'] ?? []);
+                if ($uploaded_files >= $recommended_refresh_after_files) {
+                    $this->logger->info(ucfirst($provider) . ' credentials should be refreshed based on file count threshold', [
+                        'provider' => $provider,
+                        'uploaded_files' => $uploaded_files,
+                        'recommended_refresh_after_files' => $recommended_refresh_after_files,
+                        'backup_id' => $backup_id
+                    ]);
+                    return true;
+                }
+            }
+            // Credentials are still valid (even if initialized_at is old)
+            return false;
+        }
+        // Fallback: use provider-specific hardcoded threshold if expires field is missing (backward compatibility)
+        $credentials_age = $currentTime - ($status_data['initialized_at'] ?? 0);
+        if ($credentials_age > $fallback_threshold) {
+            $this->logger->debug(ucfirst($provider) . ' credentials stale based on hardcoded threshold (expires field missing)', [
+                'provider' => $provider,
+                'credentials_age' => $credentials_age,
+                'fallback_threshold' => $fallback_threshold,
+                'initialized_at' => $status_data['initialized_at'] ?? null
+            ]);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get default refresh before expiry time for a provider (in seconds)
+     *
+     * @param string $provider Provider name
+     * @return int Seconds before expiry to refresh proactively
+     */
+    private function get_default_refresh_before_expiry(string $provider): int
+    {
+        $defaults = [
+            'backblaze_b2' => 3600,   // 1 hour before 23-hour expiration
+            'pcloud' => 3600,          // 1 hour before 24-hour expiration
+            'dropbox' => 1800,         // 30 minutes before 3.5-hour expiration
+            'google_drive' => 600,     // 10 minutes before 50-minute expiration
+            'aws' => 0,                // Presigned URLs don't need proactive refresh
+            'aws_s3' => 0,             // Presigned URLs don't need proactive refresh
+        ];
+        return $defaults[$provider] ?? 3600; // Default: 1 hour
+    }
 …
                 // Schedule immediate continuation instead of delayed retry since credentials are now available
+                if (function_exists('wp_schedule_single_event')) {
+                    \wp_schedule_single_event(time() + 2, 'siteskite_incremental_continue', [$backup_id]);
+                    $this->logger->info('Scheduled immediate incremental continue after credential refresh', [
+                        'backup_id' => $backup_id,
+                        'provider' => $provider
+                    ]);
+                }
+                $this->schedule_cron_event('siteskite_incremental_continue', [$backup_id], 2, "SiteSkite Incremental Continue");
+                $this->logger->info('Scheduled immediate incremental continue after credential refresh', [
+                    'backup_id' => $backup_id,
+                    'provider' => $provider
+                ]);
                 return;
+            }
 …
             // Cleanup leftover options/transients for this backup (WP-standard APIs)
             $this->cleanup_incremental_records($backup_id, $provider);
+            // Clean up external cron recurring job for incremental continue
+            if ($this->external_cron_manager && $this->external_cron_manager->is_enabled()) {
+                $deleted_count = $this->external_cron_manager->delete_jobs_by_backup_id('siteskite_incremental_continue', $backup_id);
+                if ($deleted_count > 0) {
+                    $this->logger->info('Cleaned up external cron recurring job after incremental backup completion', [
+                        'backup_id' => $backup_id,
+                        'deleted_count' => $deleted_count
+                    ]);
+                }
+            }
+            // Also clear WordPress cron events for this backup
+            wp_clear_scheduled_hook('siteskite_incremental_continue', [$backup_id]);
             $this->logger->delete_todays_log();

siteskite/trunk/includes/Backup/Incremental/Impl/BackblazeB2ObjectStore.php

-                      r3389896
+                      r3418578
     private ?string $uploadAuthToken = null;
     private ?int $tokenExpiresAt = null;
+    // File upload counter for credential refresh
+    private int $uploadCount = 0;
+    private const REFRESH_AFTER_FILES = 1500; // Refresh credentials after this many files
     public function __construct(Logger $logger, string $keyId, string $applicationKey, string $bucketName, string $algo = 'sha256', string $rootPath = '')
 …
     /**
      * Authenticate with Backblaze B2 and cache credentials
+     * Refreshes credentials if:
+     * - Token is expired or missing
+     * - Token expires within 1 hour (proactive refresh)
+     * - Upload count exceeds REFRESH_AFTER_FILES
      */
     private function ensureAuthenticated(): void
+    {
+        // Use cached token if still valid (tokens expire in ~1 hour)
+        if ($this->authToken && $this->tokenExpiresAt && time() < $this->tokenExpiresAt) {
+        $currentTime = time();
+        $needsRefresh = false;
+        // Check if token is expired or missing
+        if (!$this->authToken || !$this->tokenExpiresAt || $currentTime >= $this->tokenExpiresAt) {
+            $needsRefresh = true;
+            $this->logger->debug('Backblaze B2 token expired or missing, refreshing credentials');
+        }
+        // Check if token expires within 1 hour (proactive refresh)
+        elseif ($this->tokenExpiresAt && ($this->tokenExpiresAt - $currentTime) < 3600) {
+            $needsRefresh = true;
+            $this->logger->debug('Backblaze B2 token expires within 1 hour, proactively refreshing credentials', [
+                'expires_in' => $this->tokenExpiresAt - $currentTime
+            ]);
+        }
+        // Check if we've uploaded too many files (refresh after ~1500 files)
+        elseif ($this->uploadCount >= self::REFRESH_AFTER_FILES) {
+            $needsRefresh = true;
+            $this->logger->info('Backblaze B2 upload count reached threshold, refreshing credentials', [
+                'upload_count' => $this->uploadCount,
+                'threshold' => self::REFRESH_AFTER_FILES
+            ]);
+        }
+        if (!$needsRefresh) {
             return;
+        }
+        // Clear cached credentials and upload URL when refreshing
+        $this->clearCredentials();
         $this->logger->debug('Authenticating with Backblaze B2', [
 …
         $this->accountId = $auth['accountId'] ?? null;
         $this->tokenExpiresAt = time() + 3600; // Cache for 1 hour
+        // Reset upload counter when credentials are refreshed
+        $this->uploadCount = 0;
         if (!$this->authToken || !$this->apiUrl || !$this->accountId) {
 …
         $this->logger->debug('Backblaze B2 authentication successful', [
+            'api_url' => $this->apiUrl
+        ]);
+            'api_url' => $this->apiUrl,
+            'upload_count_reset' => true
+        ]);
+    }
+    /**
+     * Clear cached credentials and upload URL
+     * Used when refreshing credentials proactively or on errors
+     */
+    private function clearCredentials(): void
+    {
+        $this->authToken = null;
+        $this->apiUrl = null;
+        $this->accountId = null;
+        $this->tokenExpiresAt = null;
+        $this->bucketId = null;
+        $this->uploadUrl = null;
+        $this->uploadAuthToken = null;
+    }
 …
         if (\call_user_func('\\is_wp_error', $response)) {
+            // If upload URL expired, clear cache and retry once
+            if (stripos($response->get_error_message(), 'expired') !== false ||
+                stripos($response->get_error_message(), '401') !== false) {
+            $errorMessage = $response->get_error_message();
+            // If upload URL expired or 401/403 error, refresh credentials and retry
+            if (stripos($errorMessage, 'expired') !== false ||
+                stripos($errorMessage, '401') !== false ||
+                stripos($errorMessage, '403') !== false) {
+                $this->logger->warning('Backblaze B2 upload URL expired or unauthorized, refreshing credentials', [
+                    'error' => $errorMessage,
+                    'upload_count' => $this->uploadCount
+                ]);
+                // Clear upload URL cache and refresh credentials
                 $this->uploadUrl = null;
                 $this->uploadAuthToken = null;
+                // Refresh authentication if needed (handles token expiration)
+                $this->ensureAuthenticated();
+                // Get fresh upload URL
                 $uploadInfo = $this->getUploadUrl();
                 $uploadUrl = $uploadInfo['upload_url'];
                 $uploadAuthToken = $uploadInfo['auth_token'];
+                // Retry upload with fresh credentials
                 $response = \call_user_func('\\wp_remote_post', $uploadUrl, [
                     'headers' => [
 …
         $code = (int)\call_user_func('\\wp_remote_retrieve_response_code', $response);
         if ($code !== 200) {
+            // Handle 401/403 errors - immediately refresh credentials
+            if ($code === 401 || $code === 403) {
+                $this->logger->warning('Backblaze B2 upload failed with 401/403, immediately refreshing credentials', [
+                    'response_code' => $code,
+                    'upload_count' => $this->uploadCount
+                ]);
+                // Clear all cached credentials
+                $this->clearCredentials();
+                // Retry upload with fresh credentials
+                $this->ensureAuthenticated();
+                $uploadInfo = $this->getUploadUrl();
+                $uploadUrl = $uploadInfo['upload_url'];
+                $uploadAuthToken = $uploadInfo['auth_token'];
+                // Retry the upload
+                $retryResponse = \call_user_func('\\wp_remote_post', $uploadUrl, [
+                    'headers' => [
+                        'Authorization' => $uploadAuthToken,
+                        'X-Bz-File-Name' => $fileName,
+                        'X-Bz-Content-Type' => 'application/octet-stream',
+                        'X-Bz-Content-Sha1' => $sha1Hash,
+                        'Content-Length' => strlen($bytes)
+                    ],
+                    'body' => $bytes,
+                    'timeout' => 300
+                ]);
+                if (\call_user_func('\\is_wp_error', $retryResponse)) {
+                    throw new \RuntimeException('Backblaze B2 upload failed after credential refresh: ' . \call_user_func('\\esc_html', $retryResponse->get_error_message()));
+                }
+                $retryCode = (int)\call_user_func('\\wp_remote_retrieve_response_code', $retryResponse);
+                if ($retryCode !== 200) {
+                    $retryBody = \call_user_func('\\wp_remote_retrieve_body', $retryResponse);
+                    throw new \RuntimeException('Backblaze B2 upload failed after credential refresh with code ' . $retryCode . ': ' . \call_user_func('\\esc_html', $retryBody));
+                }
+                // Success after retry - increment counter
+                $this->uploadCount++;
+                return;
+            }
+            // For other errors, throw exception
             $body = \call_user_func('\\wp_remote_retrieve_body', $response);
             throw new \RuntimeException('Backblaze B2 upload failed with code ' . $code . ': ' . \call_user_func('\\esc_html', $body));
+        }
+        // Successful upload - increment counter
+        $this->uploadCount++;
+    }
+}

siteskite/trunk/includes/Backup/Incremental/Impl/PCloudObjectStore.php

-                      r3389896
+                      r3418578
+    {
         $path = $this->pathFor($hash);
+        $tmpPath = @tempnam(sys_get_temp_dir(), 'siteskite_-pc-');
+        if ($tmpPath === false) { throw new \RuntimeException('Failed to create temp file'); }
+        $bytes = stream_get_contents($stream);
+        if ($bytes === false) { wp_delete_file($tmpPath); throw new \RuntimeException('Failed to read stream'); }
+        file_put_contents($tmpPath, $bytes);
+        // For small files (< 5MB), use temp file approach (more reliable)
+        // For larger files, use streaming to avoid memory issues
+        $use_streaming = $size > 5 * 1024 * 1024; // 5MB threshold
+        if ($use_streaming) {
+            // Streaming upload for large files - avoids loading entire file into memory
+            // Ensure parent folders exist (minimal overhead - cached)
+            $this->manager->ensure_parent_folders_optimized($path, $this->accessToken, $this->folderCache);
+            // Use streaming upload directly from stream
+            $res = $this->manager->upload_file_from_stream($stream, $size, '', $this->accessToken, $path);
+            if (!($res['success'] ?? false)) {
+                throw new \RuntimeException('pCloud upload failed: ' . \esc_html($res['error'] ?? 'unknown'));
+            }
+        } else {
+            // Small files: use temp file (more reliable for pCloud API)
+            $tmpPath = @tempnam(sys_get_temp_dir(), 'siteskite_-pc-');
+            if ($tmpPath === false) { throw new \RuntimeException('Failed to create temp file'); }
+            try {
+                $bytes = stream_get_contents($stream);
+                if ($bytes === false) {
+                    \wp_delete_file($tmpPath);
+                    throw new \RuntimeException('Failed to read stream');
+                }
+                file_put_contents($tmpPath, $bytes);
+        // Ensure all parent directories exist before uploading (optimized - just tries creating)
+        $this->manager->ensure_parent_folders_optimized($path, $this->accessToken, $this->folderCache);
+        // Small delay to allow pCloud to propagate folder creation (especially for hash prefix folders)
+        // Hash prefix folders (2-character) are often created just before upload
+        usleep(100000); // 100ms
+        $res = $this->manager->upload_file($tmpPath, '', $this->accessToken, $path);
+        wp_delete_file($tmpPath);
+        if (!($res['success'] ?? false)) { throw new \RuntimeException('pCloud upload failed: ' . esc_html($res['error'] ?? 'unknown')); }
+                // Ensure all parent directories exist before uploading (optimized - cached)
+                $this->manager->ensure_parent_folders_optimized($path, $this->accessToken, $this->folderCache);
+                // Reduced delay - folder creation is cached and idempotent
+                // Only wait if this is a new hash prefix folder (2-character folder)
+                $pathSegments = array_filter(explode('/', dirname($path)));
+                if (count($pathSegments) >= 5) {
+                    // Hash prefix folder - minimal delay (folder creation is cached)
+                    usleep(50000); // 50ms (reduced from 100ms)
+                }
+                $res = $this->manager->upload_file($tmpPath, '', $this->accessToken, $path);
+                if (!($res['success'] ?? false)) {
+                    throw new \RuntimeException('pCloud upload failed: ' . \esc_html($res['error'] ?? 'unknown'));
+                }
+            } finally {
+                \wp_delete_file($tmpPath);
+            }
+        }
+    }
+}

siteskite/trunk/includes/Backup/Incremental/RetryPolicy.php

-                      r3389896
+                      r3418578
         if (preg_match('/http\s+5\d\d/', $m)) { return 'retry'; }
+        // Universal: 401/403 errors should trigger credentials refresh for all providers
+        // This handles expired/invalid tokens across all providers
+        if (strpos($m, 'http 401') !== false ||
+            strpos($m, 'http 403') !== false ||
+            strpos($m, '401') !== false ||
+            strpos($m, '403') !== false ||
+            strpos($m, 'unauthorized') !== false ||
+            strpos($m, 'forbidden') !== false ||
+            strpos($m, 'invalid_access_token') !== false ||
+            strpos($m, 'access token invalid or expired') !== false ||
+            strpos($m, 'token is invalid or missing') !== false ||
+            strpos($m, 'invalid token') !== false ||
+            strpos($m, 'expired token') !== false ||
+            strpos($m, 'authentication failed') !== false) {
+            return 'refresh';
+        }
         switch ($provider) {
             case 'dropbox':
-                // Invalid/expired token should trigger credentials refresh
-                if (strpos($m, 'http 401') !== false || strpos($m, 'invalid_access_token') !== false || strpos($m, 'access token invalid or expired') !== false || strpos($m, 'token is invalid or missing') !== false) {
-                    return 'refresh';
+                }
                 // Dropbox conflict on overwrite: treat as already uploaded
                 if (strpos($m, 'http 409') !== false) { return 'mark_present'; }

siteskite/trunk/includes/Cloud/AWSManager.php

-                      r3389896
+                      r3418578
 use SiteSkite\Logger\Logger;
+use SiteSkite\Core\Utils;
 class AWSManager
 …
                 // Call the API to get the actual S3 presigned URL
                 // For classic uploads, we need to construct the proper S3 key path
+                // The server expects the full path like: backups/{user_id}/{site_domain}/{backup_id}_{type}.zip
+                // Use user_id/site_host folder structure: {user_id}/{site_host}/{backup_id}_{type}.zip
+                $user_id = Utils::get_user_id();
                 $site_url = get_site_url();
                 $site_domain = wp_parse_url($site_url, PHP_URL_HOST);
+                $site_host = wp_parse_url($site_url, PHP_URL_HOST) ?: 'site';
                 $backup_id = $this->extract_backup_id_from_filename(basename($file_path));
                 $file_type = $this->extract_file_type_from_filename(basename($file_path));
                 // Construct the S3 key path that matches the server's expectation
                 $s3_key = "backups/{$this->get_user_id()}/{$site_domain}/{$backup_id}_{$file_type}.zip";
+                // Construct the S3 key path with user_id/site_host folder structure
+                $s3_key = "{$user_id}/{$site_host}/{$backup_id}_{$file_type}.zip";
                 $this->logger->info('Constructed S3 key for classic upload', [
 …
                     'backup_id' => $backup_id,
                     'file_type' => $file_type,
+                    'site_domain' => $site_domain
+                    'user_id' => $user_id,
+                    'site_host' => $site_host
                 ]);
 …
+    }
-    /**
-     * Get user ID for S3 key construction
-     */
-    private function get_user_id(): string
+    {
-        // Try to get user ID from various sources
-        $user_id = get_option('siteskite_user_id');
-        if ($user_id) {
-            return $user_id;
+        }
-        // Fallback to a default or extract from callback URL
-        $callback_url = get_option('siteskite_callback_url');
-        if ($callback_url && preg_match('/userID=(\d+)/', $callback_url, $matches)) {
-            return $matches[1];
+        }
-        return '227'; // Default fallback based on logs
+    }
     /**

siteskite/trunk/includes/Cloud/GoogleDriveManager.php

-                      r3397852
+                      r3418578
         return $parent_id;
+    }
+    /**
+     * Find or create a folder by path (creates folders if they don't exist)
+     * Similar to find_folder_by_path but creates missing folders
+     *
+     * @param string $access_token Google Drive access token
+     * @param string $folder_path Folder path like "user_id/site_host"
+     * @param string|null $base_folder_id Optional base folder ID to start from
+     * @return string|null Folder ID of the final folder in the path, or null on failure
+     */
+    public function find_or_create_folder_by_path(string $access_token, string $folder_path, ?string $base_folder_id = null): ?string
+    {
+        if (empty(trim($folder_path))) {
+            return $base_folder_id;
+        }
+        $segments = array_values(array_filter(explode('/', trim($folder_path, '/'))));
+        if (empty($segments)) {
+            return $base_folder_id;
+        }
+        $parent_id = $base_folder_id;
+        foreach ($segments as $segment) {
+            // Find existing folder under parent
+            $q = sprintf("name='%s' and mimeType='application/vnd.google-apps.folder' and trashed=false", addslashes($segment));
+            if ($parent_id) {
+                $q .= sprintf(" and '%s' in parents", addslashes($parent_id));
+            }
+            $url = 'https://www.googleapis.com/drive/v3/files?q=' . rawurlencode($q) . '&fields=files(id,name)';
+            $resp = wp_remote_get($url, [
+                'headers' => ['Authorization' => 'Bearer ' . $access_token],
+                'timeout' => 30
+            ]);
+            $found_id = null;
+            if (!is_wp_error($resp)) {
+                $body = json_decode(wp_remote_retrieve_body($resp), true);
+                $found_id = $body['files'][0]['id'] ?? null;
+            }
+            if (!$found_id) {
+                // Create folder under parent
+                $metadata = [
+                    'name' => $segment,
+                    'mimeType' => 'application/vnd.google-apps.folder'
+                ];
+                if ($parent_id) {
+                    $metadata['parents'] = [$parent_id];
+                }
+                $create_resp = wp_remote_post('https://www.googleapis.com/drive/v3/files', [
+                    'headers' => [
+                        'Authorization' => 'Bearer ' . $access_token,
+                        'Content-Type' => 'application/json'
+                    ],
+                    'body' => wp_json_encode($metadata),
+                    'timeout' => 30
+                ]);
+                if (!is_wp_error($create_resp)) {
+                    $create_body = json_decode(wp_remote_retrieve_body($create_resp), true);
+                    $found_id = $create_body['id'] ?? null;
+                    $code = (int) wp_remote_retrieve_response_code($create_resp);
+                    // 409 (conflict) means folder already exists, retry search
+                    if ($code === 409 && $found_id === null) {
+                        $retry_resp = wp_remote_get($url, [
+                            'headers' => ['Authorization' => 'Bearer ' . $access_token],
+                            'timeout' => 30
+                        ]);
+                        if (!is_wp_error($retry_resp)) {
+                            $retry_body = json_decode(wp_remote_retrieve_body($retry_resp), true);
+                            $found_id = $retry_body['files'][0]['id'] ?? null;
+                        }
+                    }
+                }
+            }
+            if (!$found_id) {
+                $this->logger->warning('Failed to create or find Google Drive folder segment', [
+                    'segment' => $segment,
+                    'parent_id' => $parent_id ? substr($parent_id, 0, 20) . '...' : 'root',
+                    'path' => $folder_path
+                ]);
+                return null;
+            }
+            $parent_id = $found_id;
+        }
+        return $parent_id;
+    }
+}

siteskite/trunk/includes/Cloud/PCloudManager.php

-                      r3389896
+                      r3418578
             // Step 3: Upload the file
             if ($custom_remote_path) {
+                // Use custom remote path for incremental uploads (manifests and objects)
+                // Ensure parent folders exist before uploading
+                $this->logger->debug('Ensuring parent folders for incremental upload', [
+                    'custom_remote_path' => $custom_remote_path
+                // Use custom remote path for incremental uploads (manifests and objects) or classic backups
+                // For classic backups, the path already includes folder_name: {folderName}/{user_id}/{site_host}/{filename}
+                // For incremental uploads, the path is absolute from root: siteskite/{site_host}/manifests/...
+                // Normalize the custom_remote_path to ensure it starts with / for proper path handling
+                $normalized_custom_path = '/' . trim($custom_remote_path, '/');
+                $this->logger->debug('Ensuring parent folders for upload', [
+                    'custom_remote_path' => $custom_remote_path,
+                    'normalized_custom_path' => $normalized_custom_path,
+                    'folder_name' => $folder_name
                 ]);
                 $empty_cache = [];
+                $this->ensure_parent_folders_optimized($custom_remote_path, $access_token, $empty_cache);
+                // Additional delay to allow pCloud to propagate folder creation (especially for manifests folder structure)
+                // Longer delay for manifest paths to ensure folders are fully available
+                $this->ensure_parent_folders_optimized($normalized_custom_path, $access_token, $empty_cache);
+                // Extract directory path for verification and folderid retrieval
+                $dir_path = dirname($normalized_custom_path);
+                $dir_path = '/' . trim($dir_path, '/');
+                // For classic backups (3+ level paths), get folderid for more reliable uploads
+                // Classic backup paths: {folderName}/{user_id}/{site_host}/{filename} = 3 levels
                 $is_manifest_path = strpos($custom_remote_path, '/manifests/') !== false;
+                usleep($is_manifest_path ? 500000 : 200000); // 500ms for manifests, 200ms for objects
+                $upload_result = $this->upload_file_to_pcloud($file_path, $custom_remote_path, $access_token);
+                $path_segments = array_filter(explode('/', trim($dir_path, '/')));
+                $path_depth = count($path_segments);
+                $is_classic_backup = !$is_manifest_path && $path_depth >= 3; // folderName/user_id/site_host = 3 segments
+                $this->logger->debug('Determining upload strategy', [
+                    'dir_path' => $dir_path,
+                    'path_depth' => $path_depth,
+                    'is_classic_backup' => $is_classic_backup
+                ]);
+                $target_folderid = null;
+                if ($is_classic_backup || $is_manifest_path) {
+                    // Get folderid from cache (stored during folder creation)
+                    $folderid_cache_key = $dir_path . '_folderid';
+                    if (isset($empty_cache[$folderid_cache_key])) {
+                        $cached_folderid = (int)$empty_cache[$folderid_cache_key];
+                        // Verify the cached folderid is correct by doing a stat
+                        // This ensures we're using the right folderid for the correct path
+                        usleep(100000); // 100ms (reduced from 200ms) - folder creation is cached
+                        $verify_stat = $this->stat_path($dir_path, $access_token);
+                        if ($verify_stat['success'] && ($verify_stat['exists'] ?? false) && isset($verify_stat['metadata']['folderid'])) {
+                            $verified_folderid = (int)$verify_stat['metadata']['folderid'];
+                            if ($verified_folderid === $cached_folderid) {
+                                $target_folderid = $verified_folderid;
+                                $this->logger->debug('Using verified folderid from folder creation', [
+                                    'dir_path' => $dir_path,
+                                    'folderid' => $target_folderid,
+                                    'cache_key' => $folderid_cache_key
+                                ]);
+                            } else {
+                                // Cached folderid doesn't match - use the verified one
+                                $target_folderid = $verified_folderid;
+                                $this->logger->warning('Cached folderid mismatch, using verified folderid', [
+                                    'dir_path' => $dir_path,
+                                    'cached_folderid' => $cached_folderid,
+                                    'verified_folderid' => $verified_folderid,
+                                    'cache_key' => $folderid_cache_key
+                                ]);
+                            }
+                        } else {
+                            // Stat failed, use cached folderid as fallback
+                            $target_folderid = $cached_folderid;
+                            $this->logger->warning('Could not verify cached folderid via stat, using cached value', [
+                                'dir_path' => $dir_path,
+                                'folderid' => $target_folderid,
+                                'stat_result' => $verify_stat
+                            ]);
+                        }
+                    } else {
+                        // Fallback: Try to get folderid via stat (for edge cases)
+                        $this->logger->debug('Folderid not in cache, trying stat', [
+                            'dir_path' => $dir_path,
+                            'cache_key' => $folderid_cache_key,
+                            'cache_keys_available' => array_keys($empty_cache)
+                        ]);
+                        usleep(150000); // 150ms (reduced from 300ms) - folder creation is cached
+                        $stat_result = $this->stat_path($dir_path, $access_token);
+                        if ($stat_result['success'] && ($stat_result['exists'] ?? false) && isset($stat_result['metadata']['folderid'])) {
+                            $target_folderid = (int)$stat_result['metadata']['folderid'];
+                            $this->logger->debug('Retrieved folderid via stat fallback', [
+                                'dir_path' => $dir_path,
+                                'folderid' => $target_folderid
+                            ]);
+                        } else {
+                            $this->logger->warning('Could not retrieve folderid via stat', [
+                                'dir_path' => $dir_path,
+                                'stat_result' => $stat_result
+                            ]);
+                        }
+                    }
+                    // Reduced delay for classic backups - folder creation is cached and idempotent
+                    if ($is_classic_backup && $target_folderid) {
+                        usleep(100000); // 100ms (reduced from 300ms) when we have folderid
+                    } elseif ($is_classic_backup) {
+                        usleep(200000); // 200ms (reduced from 500ms) if no folderid
+                    }
+                } else {
+                    // For shallow paths, minimal delay
+                    usleep(50000); // 50ms (reduced from 200ms) for objects
+                }
+                $upload_result = $this->upload_file_to_pcloud($file_path, $normalized_custom_path, $access_token, $target_folderid);
             } else {
                 // Use folder-based upload for regular uploads
 …
             // Don't check if exists first - just try creating (idempotent operation)
             $current_path = '';
+            $segment_index = 0;
             foreach ($segments as $segment) {
+                $segment_index++;
                 $current_path .= '/' . $segment;
 …
                 $is_manifest_final = (count($segments) === 4 && ($folder_name === 'files' || $folder_name === 'database'));
+                $this->logger->debug('Creating pCloud folder in optimized flow', [
+                    'current_path' => $current_path,
+                    'parent_path' => $parent_path,
+                    'folder_name' => $folder_name,
+                    'segment_index' => array_search($segment, $segments) + 1,
+                    'total_segments' => count($segments),
+                    'is_manifest_final' => $is_manifest_final
+                ]);
+                // For manifest final folders, ensure parent exists and get its folderid first
+                if ($is_manifest_final) {
+                    // Verify parent exists and get folderid for more reliable creation
+                    $parent_stat = $this->stat_path($parent_path, $access_token);
+                    if ($parent_stat['success'] && ($parent_stat['exists'] ?? false) && isset($parent_stat['metadata']['folderid'])) {
+                        $this->logger->debug('Using folderid for manifest final folder creation', [
+                // For classic backup: folderName/user_id/site_host (3 segments), the final folder is the 3rd segment
+                // segment_index is 1-based, so for 3 segments, final is when segment_index === 3
+                $is_classic_backup_final = (count($segments) === 3 && $segment_index === 3);
+                // $this->logger->debug('Creating pCloud folder in optimized flow', [
+                //     'current_path' => $current_path,
+                //     'parent_path' => $parent_path,
+                //     'folder_name' => $folder_name,
+                //     'segment_index' => $segment_index,
+                //     'total_segments' => count($segments),
+                //     'is_manifest_final' => $is_manifest_final,
+                //     'is_classic_backup_final' => $is_classic_backup_final
+                // ]);
+                // For final folders (manifest or classic backup), use parent folderid if available for better reliability
+                // Get parent folderid from cache first (faster), or via stat if not cached
+                $parent_folderid = null;
+                if ($is_manifest_final || $is_classic_backup_final) {
+                    $parent_folderid_cache_key = $parent_path . '_folderid';
+                    if (isset($folderCache[$parent_folderid_cache_key])) {
+                        $parent_folderid = (int)$folderCache[$parent_folderid_cache_key];
+                        $this->logger->debug('Using cached parent folderid for final folder creation', [
                             'parent_path' => $parent_path,
                             'parent_folderid' => $parent_stat['metadata']['folderid'],
+                            'parent_folderid' => $parent_folderid,
                             'folder_name' => $folder_name
                         ]);
+                        // Create using folderid directly for better reliability
+                        $folder_endpoint = $this->get_api_endpoint($access_token, 'createfolderifnotexists');
+                        $folder_url = $folder_endpoint . '?' . http_build_query([
+                            'access_token' => $access_token,
+                            'name' => $folder_name,
+                            'folderid' => (string)$parent_stat['metadata']['folderid']
+                    } else {
+                        // Fallback: get parent folderid via stat
+                        $parent_stat = $this->stat_path($parent_path, $access_token);
+                        if ($parent_stat['success'] && ($parent_stat['exists'] ?? false) && isset($parent_stat['metadata']['folderid'])) {
+                            $parent_folderid = (int)$parent_stat['metadata']['folderid'];
+                        }
+                    }
+                }
+                // Use create_folder_at_path for all folders - it handles verification and retries
+                $create_result = $this->create_folder_at_path($parent_path, $folder_name, $access_token, $parent_folderid);
+                // If successful, cache the folder and store folderid if available
+                if ($create_result['success']) {
+                    $created_folderid = $create_result['folderid'] ?? null;
+                    $folderCache[$current_path] = true;
+                    // $this->logger->debug('Successfully created pCloud folder (optimized)', [
+                    //     'current_path' => $current_path,
+                    //     'folder_name' => $folder_name,
+                    //     'folderid' => $created_folderid
+                    // ]);
+                    // Store folderid for classic backup final folder (needed for upload)
+                    if ($is_classic_backup_final && $created_folderid) {
+                        $folderCache[$current_path . '_folderid'] = $created_folderid;
+                        $this->logger->debug('Stored folderid for classic backup final folder', [
+                            'current_path' => $current_path,
+                            'folderid' => $created_folderid
                         ]);
+                        $response = wp_remote_get($folder_url, ['timeout' => 30]);
+                        if (!is_wp_error($response)) {
+                            $response_code = wp_remote_retrieve_response_code($response);
+                            $response_body = wp_remote_retrieve_body($response);
+                            $decoded = json_decode($response_body, true) ?: [];
+                            $result_code = isset($decoded['result']) ? (int)$decoded['result'] : -1;
+                            if ($response_code === 200 && ($result_code === 0 || $result_code === 2005)) {
+                                $create_result = ['success' => true];
+                    } elseif ($is_classic_backup_final && !$created_folderid) {
+                        // Log warning - create_folder_at_path already tried to verify, but couldn't get folderid
+                        $this->logger->warning('Final classic backup folder created but folderid unavailable', [
+                            'current_path' => $current_path,
+                            'folder_name' => $folder_name,
+                            'note' => 'Upload will use path instead of folderid'
+                        ]);
+                    }
+                    // Optimized: Reduce verification overhead - rely on folder creation being idempotent
+                    // Only verify for critical paths, and use minimal delays
+                    if (count($segments) >= 5) {
+                        // Hash prefix folders - minimal verification (folder creation is cached and idempotent)
+                        // Single quick check, then rely on upload retry if needed
+                        usleep(50000); // 50ms (reduced from 150ms * 3 attempts)
+                        $verify_stat = $this->stat_path($current_path, $access_token);
+                        if ($verify_stat['success'] && ($verify_stat['exists'] ?? false)) {
+                            $folderCache[$current_path] = true;
+                        } else {
+                            // Mark as created anyway - upload will retry if folder truly missing
+                            $folderCache[$current_path] = true;
+                        }
+                    } elseif (count($segments) >= 4) {
+                        // Manifest folders - reduced verification
+                        $is_final_folder = ($folder_name === 'files' || $folder_name === 'database');
+                        if ($is_final_folder) {
+                            // Final folder: single verification attempt with minimal delay
+                            usleep(100000); // 100ms (reduced from 300ms * 8 attempts)
+                            $verify_stat = $this->stat_path($current_path, $access_token);
+                            if ($verify_stat['success'] && ($verify_stat['exists'] ?? false)) {
+                                $folderCache[$current_path] = true;
                             } else {
                                 // Fallback to normal method
                                 $create_result = $this->create_folder_at_path($parent_path, $folder_name, $access_token);
+                                // Mark as created - upload will handle retry
+                                $folderCache[$current_path] = true;
+                            }
                         } else {
+                            // Fallback to normal method
+                            $create_result = $this->create_folder_at_path($parent_path, $folder_name, $access_token);
+                        }
+                    } else {
+                        // Parent doesn't exist or we can't get folderid, use normal method
+                        $create_result = $this->create_folder_at_path($parent_path, $folder_name, $access_token);
+                    }
+                } else {
+                    $create_result = $this->create_folder_at_path($parent_path, $folder_name, $access_token);
+                }
+                // If successful or folder already exists (result 2005), cache it
+                if ($create_result['success']) {
+                    $folderCache[$current_path] = true;
+                    $this->logger->debug('Successfully created pCloud folder (optimized)', [
+                        'current_path' => $current_path,
+                        'folder_name' => $folder_name
+                    ]);
+                    // Verify folder actually exists (especially important for deep folders)
+                    if (count($segments) >= 5) {
+                        // Hash prefix folders - verify they exist before continuing
+                        $verify_attempts = 0;
+                        $verified = false;
+                        while ($verify_attempts < 3 && !$verified) {
+                            usleep(150000); // 150ms per attempt
+                            $verify_stat = $this->stat_path($current_path, $access_token);
+                            if ($verify_stat['success'] && ($verify_stat['exists'] ?? false)) {
+                                $verified = true;
+                                $folderCache[$current_path] = true; // Cache verified folder
+                                $this->logger->debug('Hash prefix folder verified after creation', [
+                                    'path' => $current_path,
+                                    'attempts' => $verify_attempts + 1
+                                ]);
+                            }
+                            $verify_attempts++;
+                        }
+                        if (!$verified) {
+                            // Even if verification fails, mark as created in cache to avoid repeated attempts
+                            // This is expected with pCloud's eventual consistency - folders may take a moment to propagate
+                            // The upload itself will handle any real issues
+                            $folderCache[$current_path] = true;
+                            $this->logger->debug('Hash prefix folder not immediately verified (expected with pCloud eventual consistency)', [
+                                'path' => $current_path,
+                                'parent' => $parent_path,
+                                'name' => $folder_name,
+                                'note' => 'Folder created successfully; verification may lag due to eventual consistency. Upload will handle if folder truly missing'
+                            ]);
+                        }
+                    } elseif (count($segments) >= 4) {
+                        // Manifest folders (4 levels: siteskite/site/manifests/files) - verify they exist
+                        // The final folder (files/database) often needs more time and retries
+                        $is_final_folder = ($folder_name === 'files' || $folder_name === 'database');
+                        $max_attempts = $is_final_folder ? 8 : 5; // More attempts for final folders
+                        $verify_attempts = 0;
+                        $verified = false;
+                        // For final folders, try recreating if verification fails
+                        while ($verify_attempts < $max_attempts && !$verified) {
+                            usleep($is_final_folder ? 300000 : 150000); // 300ms for final, 150ms for others
+                            $verify_stat = $this->stat_path($current_path, $access_token);
+                            if ($verify_stat['success'] && ($verify_stat['exists'] ?? false)) {
+                                $verified = true;
+                                $folderCache[$current_path] = true; // Cache verified folder
+                                $this->logger->debug('Manifest folder verified after creation', [
+                                    'path' => $current_path,
+                                    'attempts' => $verify_attempts + 1,
+                                    'is_final_folder' => $is_final_folder
+                                ]);
+                            } else {
+                                // If verification fails and it's a final folder, try recreating it
+                                if ($is_final_folder && $verify_attempts > 1 && $verify_attempts % 2 === 0) {
+                                    $this->logger->debug('Retrying creation of final manifest folder', [
+                                        'path' => $current_path,
+                                        'parent' => $parent_path,
+                                        'name' => $folder_name,
+                                        'attempt' => $verify_attempts
+                                    ]);
+                                    $this->create_folder_at_path($parent_path, $folder_name, $access_token);
+                                    usleep(200000); // Wait after recreation
+                                }
+                            }
+                            $verify_attempts++;
+                        }
+                        if (!$verified) {
+                            // Even if verification fails, mark as created in cache to avoid repeated attempts
+                            // The upload itself will handle any real issues
+                            $folderCache[$current_path] = true;
+                            $this->logger->warning('Manifest folder not verified after creation', [
+                                'path' => $current_path,
+                                'parent' => $parent_path,
+                                'name' => $folder_name,
+                                'attempts' => $verify_attempts,
+                                'is_final_folder' => $is_final_folder,
+                                'note' => 'Marking as created in cache; upload will handle if folder truly missing'
+                            ]);
+                        } elseif ($is_final_folder) {
+                            // Additional wait for final folder after verification
+                            usleep(400000); // 400ms extra wait for final folder
+                            $this->logger->debug('Final manifest folder verified and ready', [
+                                'path' => $current_path
+                            ]);
+                            // Non-final manifest folder: no verification needed
+                            usleep(30000); // 30ms minimal delay
+                        }
                     } elseif (count($segments) > 3) {
                         usleep(50000); // 50ms for other deep folders
+                        usleep(20000); // 20ms for other deep folders (reduced from 50ms)
+                    }
                 } else {
 …
      * @param string $folder_name Folder name to create
      * @param string $access_token Access token
+     * @param int|null $parent_folderid Optional parent folderid (more reliable than path for nested folders)
      * @return array Result with success status
      */
     private function create_folder_at_path(string $parent_path, string $folder_name, string $access_token): array
+    private function create_folder_at_path(string $parent_path, string $folder_name, string $access_token, ?int $parent_folderid = null): array
+    {
         try {
 …
                 // Root folder - use folderid=0
                 $query_params['folderid'] = '0';
+            } elseif ($parent_folderid !== null) {
+                // Use provided parent folderid (most reliable for nested folders)
+                $query_params['folderid'] = (string)$parent_folderid;
+                $this->logger->debug('Using provided parent folderid for folder creation', [
+                    'parent_path' => $parent_path,
+                    'folder_name' => $folder_name,
+                    'parent_folderid' => $parent_folderid
+                ]);
             } else {
                 // For deep nested folders (especially hash prefix folders), use folderid for better reliability
                 // Count segments: /siteskite/inc.site/objects/sha256 = 4 segments
                 $depth = substr_count(trim($parent_path, '/'), '/') + 1;
                 if ($depth >= 4) {
                     // Deep nested (4+ segments) - get folderid for reliability
                     // This is critical for hash prefix folders like /.../sha256/af
+                if ($depth >= 3) {
+                    // Nested (3+ segments) - get folderid for reliability
+                    // This is critical for classic backup paths: folderName/user_id/site_host
                     $parent_stat = $this->stat_path($parent_path, $access_token);
                     if ($parent_stat['success'] && isset($parent_stat['metadata']['folderid'])) {
                         $query_params['folderid'] = (string)$parent_stat['metadata']['folderid'];
+                        $this->logger->debug('Using folderid for deep nested folder creation', [
+                        // $this->logger->debug('Using folderid for nested folder creation (from stat)', [
+                        //     'parent_path' => $parent_path,
+                        //     'folder_name' => $folder_name,
+                        //     'folderid' => $query_params['folderid'],
+                        //     'depth' => $depth
+                        // ]);
+                    } else {
+                        // Fallback to path if stat fails, but log it
+                        $this->logger->warning('Failed to get folderid for nested folder, falling back to path', [
                             'parent_path' => $parent_path,
                             'folder_name' => $folder_name,
+                            'folderid' => $query_params['folderid']
+                        ]);
+                    } else {
+                        // Fallback to path if stat fails, but log it
+                        $this->logger->warning('Failed to get folderid for deep nested folder, falling back to path', [
+                            'parent_path' => $parent_path,
+                            'folder_name' => $folder_name,
+                            'stat_result' => $parent_stat
+                            'stat_result' => $parent_stat,
+                            'depth' => $depth
                         ]);
                         $query_params['path'] = $parent_path;
 …
             $result_code = isset($decoded['result']) ? (int)$decoded['result'] : -1;
+            // Extract folderid from response if available
+            $folderid = null;
+            if (isset($decoded['metadata']['folderid'])) {
+                $folderid = (int)$decoded['metadata']['folderid'];
+            } elseif (isset($decoded['folderid'])) {
+                $folderid = (int)$decoded['folderid'];
+            }
             // pCloud API: result 0 = success, result 2005 = folder already exists (also success)
             if ($response_code === 200 && ($result_code === 0 || $result_code === 2005)) {
+                // $this->logger->debug('pCloud folder created or already exists', [
+                //     'parent_path' => $parent_path,
+                //     'folder_name' => $folder_name,
+                //     'result_code' => $result_code
+                // ]);
+                return ['success' => true];
+                // Always verify folderid by doing a stat on the full path to ensure we have the correct folderid
+                // This is critical for classic backup paths where we need the correct folderid for uploads
+                $full_path = ($parent_path === '/') ? '/' . $folder_name : $parent_path . '/' . $folder_name;
+                // For newly created folders, wait longer and retry stat multiple times
+                // pCloud has eventual consistency issues, especially for nested folders
+                $max_retries = ($result_code === 0) ? 5 : 2; // More retries for newly created folders
+                $retry_delay = ($result_code === 0) ? 300000 : 200000; // 300ms for new, 200ms for existing
+                $verified_folderid = null;
+                $stat_check = null;
+                for ($retry = 0; $retry < $max_retries; $retry++) {
+                    if ($retry > 0) {
+                        usleep($retry_delay);
+                    }
+                    $stat_check = $this->stat_path($full_path, $access_token);
+                    if ($stat_check['success'] && ($stat_check['exists'] ?? false) && isset($stat_check['metadata']['folderid'])) {
+                        $verified_folderid = (int)$stat_check['metadata']['folderid'];
+                        // $this->logger->debug('pCloud folder created or already exists (verified via stat)', [
+                        //     'parent_path' => $parent_path,
+                        //     'folder_name' => $folder_name,
+                        //     'full_path' => $full_path,
+                        //     'result_code' => $result_code,
+                        //     'folderid_from_response' => $folderid,
+                        //     'folderid_from_stat' => $verified_folderid,
+                        //     'retry_attempt' => $retry + 1,
+                        //     'using_verified_folderid' => true
+                        // ]);
+                        break;
+                    }
+                }
+                if ($verified_folderid) {
+                    return [
+                        'success' => true,
+                        'folderid' => $verified_folderid
+                    ];
+                } else {
+                    // Folder doesn't exist according to stat - this is a problem
+                    // Don't use the response folderid as it might be wrong (parent folderid)
+                    $this->logger->warning('pCloud folder creation reported success but folder does not exist via stat', [
+                        'parent_path' => $parent_path,
+                        'folder_name' => $folder_name,
+                        'full_path' => $full_path,
+                        'result_code' => $result_code,
+                        'folderid_from_response' => $folderid,
+                        'stat_result' => $stat_check,
+                        'retries' => $max_retries
+                    ]);
+                    // Return success but with null folderid - the caller should handle this
+                    // The folder might exist but stat is failing, or the folder wasn't actually created
+                    return [
+                        'success' => true,
+                        'folderid' => null,
+                        'warning' => 'Folder creation reported success but could not verify via stat'
+                    ];
+                }
+            }
 …
             // 2005 means folder already exists, which is fine
             if ($result_code === 2005) {
+                return ['success' => true];
+                // Try to get folderid via stat if not in response
+                if (!$folderid) {
+                    $full_path = ($parent_path === '/') ? '/' . $folder_name : $parent_path . '/' . $folder_name;
+                    $stat_check = $this->stat_path($full_path, $access_token);
+                    if ($stat_check['success'] && ($stat_check['exists'] ?? false) && isset($stat_check['metadata']['folderid'])) {
+                        $folderid = (int)$stat_check['metadata']['folderid'];
+                    }
+                }
+                return [
+                    'success' => true,
+                    'folderid' => $folderid
+                ];
+            }
 …
                 $stat_check = $this->stat_path($full_path, $access_token);
                 if ($stat_check['success'] && ($stat_check['exists'] ?? false)) {
+                    $folderid_from_stat = isset($stat_check['metadata']['folderid']) ? (int)$stat_check['metadata']['folderid'] : null;
                     // $this->logger->debug('pCloud folder exists despite API error 1001', [
                     //     'parent_path' => $parent_path,
                     //     'folder_name' => $folder_name,
+                    //     'full_path' => $full_path
+                    //     'full_path' => $full_path,
+                    //     'folderid' => $folderid_from_stat
                     // ]);
+                    return ['success' => true];
+                    return [
+                        'success' => true,
+                        'folderid' => $folderid_from_stat
+                    ];
+                }
+            }
 …
                 'nopartial' => '1',
             ];
+            // Use the directory path (not including filename)
+            $query['path'] = $upload_path;
+            // For nested paths (3+ levels), use folderid if available for better reliability
+            // This is especially important for classic backups: {folderName}/{user_id}/{site_host}
+            $path_segments = array_filter(explode('/', trim($upload_path, '/')));
+            $path_depth = count($path_segments);
+            if ($folderid !== null && $path_depth >= 2) {
+                // Verify folderid matches the expected path before using it
+                // This is critical to ensure files go to the correct location
+                $verify_stat = $this->stat_path($upload_path, $access_token);
+                $verified_folderid = null;
+                if ($verify_stat['success'] && ($verify_stat['exists'] ?? false) && isset($verify_stat['metadata']['folderid'])) {
+                    $verified_folderid = (int)$verify_stat['metadata']['folderid'];
+                }
+                if ($verified_folderid && $verified_folderid === $folderid) {
+                    // Folderid matches - safe to use
+                    $query['folderid'] = (string)$folderid;
+                    $this->logger->debug('Using verified folderid for nested path upload', [
+                        'folderid' => $folderid,
+                        'upload_path' => $upload_path,
+                        'path_depth' => $path_depth,
+                        'verified' => true
+                    ]);
+                } elseif ($verified_folderid) {
+                    // Folderid mismatch - use the verified one
+                    $query['folderid'] = (string)$verified_folderid;
+                    $this->logger->warning('Folderid mismatch detected, using verified folderid', [
+                        'original_folderid' => $folderid,
+                        'verified_folderid' => $verified_folderid,
+                        'upload_path' => $upload_path,
+                        'path_depth' => $path_depth
+                    ]);
+                } else {
+                    // Could not verify folderid - fall back to path for safety
+                    $query['path'] = $upload_path;
+                    $this->logger->warning('Could not verify folderid, falling back to path', [
+                        'folderid' => $folderid,
+                        'upload_path' => $upload_path,
+                        'path_depth' => $path_depth,
+                        'stat_result' => $verify_stat
+                    ]);
+                }
+            } else {
+                // Use path for shallow paths or when folderid not available
+                $query['path'] = $upload_path;
+                $this->logger->debug('Using path for upload', [
+                    'upload_path' => $upload_path,
+                    'path_depth' => $path_depth,
+                    'folderid_available' => $folderid !== null
+                ]);
+            }
             $upload_url = $upload_endpoint . '?' . http_build_query($query);
 …
             $this->logger->debug('Starting pCloud upload request');
+            // For large files (>10MB), use streaming to avoid memory issues
+            // For smaller files, use in-memory approach (more reliable with pCloud API)
+            $use_streaming = $file_size > 10 * 1024 * 1024; // 10MB threshold
+            if ($use_streaming) {
+                // Streaming upload for large files - avoids loading entire file into memory
+                return $this->upload_file_streaming($file_path, $remote_filename, $upload_url, $mime_type, $file_size, $upload_path, $access_token, $folderid);
+            }
+            // Small files: use in-memory approach (more reliable)
             // Read file contents for WordPress HTTP API
-            // Note: For very large files, this might consume memory, but it's the WordPress-standard way
             $file_contents = file_get_contents($file_path);
             if ($file_contents === false) {
 …
             if (!$file_id && $has_directory_error) {
                 $this->logger->info('pCloud upload failed with "Directory does not exist", ensuring full directory path and retrying', [
+                $this->logger->info('pCloud upload failed with "Directory does not exist", retrying with folder recreation', [
                     'upload_path' => $upload_path,
                     'error' => $upload_data['error'] ?? 'Directory does not exist'
                 ]);
                 // Ensure the entire parent path exists (not just the final segment)
                 // This handles cases where intermediate folders might be missing
+                    'error' => $upload_data['error'] ?? 'Directory does not exist',
+                    'has_folderid' => $folderid !== null
+                ]);
+                // Recreate folders and get folderid if we don't have it
                 $full_file_path = $upload_path . '/' . $remote_filename;
+                $empty_cache = []; // Use empty cache to force recreation check
+                $this->ensure_parent_folders_optimized($full_file_path, $access_token, $empty_cache);
+                // Verify the directory actually exists before retrying (with retries)
+                $verify_retries = 0;
+                $max_verify_retries = 5;
+                $dir_exists = false;
+                while ($verify_retries < $max_verify_retries) {
+                    usleep(200000 * ($verify_retries + 1)); // 200ms, 400ms, 600ms, 800ms, 1000ms
+                $retry_cache = [];
+                $this->ensure_parent_folders_optimized($full_file_path, $access_token, $retry_cache);
+                // Get folderid from retry cache or use existing
+                $retry_folderid = $folderid;
+                $folderid_cache_key = $upload_path . '_folderid';
+                if (isset($retry_cache[$folderid_cache_key])) {
+                    $retry_folderid = (int)$retry_cache[$folderid_cache_key];
+                } elseif (!$retry_folderid) {
+                    // Fallback: try stat to get folderid
+                    usleep(500000); // Wait for folder propagation
                     $stat_result = $this->stat_path($upload_path, $access_token);
+                    if ($stat_result['success'] && ($stat_result['exists'] ?? false)) {
+                        $dir_exists = true;
+                        $this->logger->debug('Upload directory verified after retry folder creation', [
+                            'upload_path' => $upload_path,
+                            'retries' => $verify_retries + 1
+                        ]);
+                        break;
+                    }
+                    $verify_retries++;
+                    // If still doesn't exist, try creating the final directory again
+                    if ($verify_retries < $max_verify_retries) {
+                        $final_segment = basename($upload_path);
+                        $final_parent = dirname($upload_path);
+                        if ($final_parent && $final_parent !== '/' && $final_parent !== '.') {
+                            $this->create_folder_at_path($final_parent, $final_segment, $access_token);
+                        }
+                    if ($stat_result['success'] && ($stat_result['exists'] ?? false) && isset($stat_result['metadata']['folderid'])) {
+                        $retry_folderid = (int)$stat_result['metadata']['folderid'];
+                    }
+                }
+                if (!$dir_exists) {
+                    $this->logger->warning('Upload directory still does not exist after retries, attempting upload anyway', [
+                        'upload_path' => $upload_path,
+                        'max_retries' => $max_verify_retries
+                    ]);
+                // Wait before retry
+                $path_depth_retry = count(array_filter(explode('/', trim($upload_path, '/'))));
+                usleep($path_depth_retry >= 2 ? 500000 : 300000);
+                // Rebuild upload URL - prefer folderid if available
+                $retry_query = [
+                    'access_token' => $access_token,
+                    'filename' => $remote_filename,
+                    'renameifexists' => '1',
+                    'nopartial' => '1',
+                ];
+                if ($retry_folderid !== null && $path_depth_retry >= 2) {
+                    $retry_query['folderid'] = (string)$retry_folderid;
+                } else {
+                    $retry_query['path'] = $upload_path;
+                }
+                // Additional wait before upload attempt
+                usleep(300000); // 300ms
+                // Retry upload once
+                $retry_response = wp_safe_remote_post($upload_url, [
+                $retry_upload_url = $upload_endpoint . '?' . http_build_query($retry_query);
+                // Retry upload
+                $retry_response = wp_safe_remote_post($retry_upload_url, [
                     'timeout' => max(300, (int) ceil($file_size / (1024 * 1024)) * 10),
                     'headers' => [
 …
                     $retry_code = wp_remote_retrieve_response_code($retry_response);
                     $retry_body = wp_remote_retrieve_body($retry_response);
-                    $this->logger->debug('pCloud retry upload response', [
-                        'response_code' => $retry_code,
-                        'response_body' => $retry_body
-                    ]);
                     if ($retry_code === 200) {
 …
                             ]);
                         } else {
-                            // Update for error handling below
                             $response_code = $retry_code;
                             $response_body = $retry_body;
 …
+                        }
                     } else {
-                        // Update response for error handling below
                         $response_code = $retry_code;
                         $response_body = $retry_body;
 …
+            }
+        }
+    }
+    /**
+     * Upload file using streaming for large files (avoids loading entire file into memory)
+     *
+     * @param string $file_path Local file path
+     * @param string $remote_filename Remote filename
+     * @param string $upload_url Upload URL with query parameters
+     * @param string $mime_type MIME type
+     * @param int $file_size File size in bytes
+     * @param string $upload_path Upload path (for retry logic)
+     * @param string $access_token Access token
+     * @param int|null $folderid Folder ID (for retry logic)
+     * @return array Upload result
+     */
+    private function upload_file_streaming(string $file_path, string $remote_filename, string $upload_url, string $mime_type, int $file_size, string $upload_path, string $access_token, ?int $folderid): array
+    {
+        $file_handle = fopen($file_path, 'rb');
+        if ($file_handle === false) {
+            return [
+                'success' => false,
+                'error' => 'Failed to open file for streaming upload'
+            ];
+        }
+        try {
+            // Create multipart boundary
+            $boundary = wp_generate_password(24, false);
+            // Build multipart body header
+            $multipart_header = '--' . $boundary . "\r\n";
+            $multipart_header .= 'Content-Disposition: form-data; name="file"; filename="' . $remote_filename . '"' . "\r\n";
+            $multipart_header .= 'Content-Type: ' . $mime_type . "\r\n\r\n";
+            $multipart_footer = "\r\n--" . $boundary . "--";
+            // Calculate total size for Content-Length
+            $header_size = strlen($multipart_header);
+            $footer_size = strlen($multipart_footer);
+            $total_size = $header_size + $file_size + $footer_size;
+            // Use cURL directly for streaming upload
+            $ch = curl_init($upload_url);
+            if ($ch === false) {
+                return [
+                    'success' => false,
+                    'error' => 'Failed to initialize cURL for streaming upload'
+                ];
+            }
+            // Build multipart body using streams
+            $body_stream = fopen('php://temp', 'r+');
+            if ($body_stream === false) {
+                curl_close($ch);
+                return [
+                    'success' => false,
+                    'error' => 'Failed to create temp stream for multipart body'
+                ];
+            }
+            // Write header
+            fwrite($body_stream, $multipart_header);
+            // Stream file contents in chunks
+            $chunk_size = 8192; // 8KB chunks
+            while (!feof($file_handle)) {
+                $chunk = fread($file_handle, $chunk_size);
+                if ($chunk !== false) {
+                    fwrite($body_stream, $chunk);
+                }
+            }
+            // Write footer
+            fwrite($body_stream, $multipart_footer);
+            // Rewind stream
+            rewind($body_stream);
+            // Get stream contents (WordPress HTTP API will handle this efficiently)
+            $body_contents = stream_get_contents($body_stream);
+            fclose($body_stream);
+            // Configure cURL for upload
+            curl_setopt_array($ch, [
+                CURLOPT_POST => true,
+                CURLOPT_POSTFIELDS => $body_contents,
+                CURLOPT_RETURNTRANSFER => true,
+                CURLOPT_TIMEOUT => max(300, (int) ceil($file_size / (1024 * 1024)) * 10),
+                CURLOPT_SSL_VERIFYPEER => true,
+                CURLOPT_SSL_VERIFYHOST => 2,
+                CURLOPT_HTTPHEADER => [
+                    'Content-Type: multipart/form-data; boundary=' . $boundary,
+                    'Expect:',
+                    'User-Agent: SiteSkite-Link/1.0; WordPress/' . get_bloginfo('version'),
+                    'Content-Length: ' . $total_size
+                ]
+            ]);
+            $response_body = curl_exec($ch);
+            $response_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
+            $curl_error = curl_error($ch);
+            curl_close($ch);
+            if ($response_body === false || !empty($curl_error)) {
+                return [
+                    'success' => false,
+                    'error' => 'cURL error during streaming upload: ' . $curl_error
+                ];
+            }
+            if ($response_code !== 200) {
+                return [
+                    'success' => false,
+                    'error' => 'Upload failed with status ' . $response_code . ': ' . $response_body
+                ];
+            }
+            $upload_data = json_decode($response_body, true);
+            $file_id = $upload_data['fileids'][0] ?? ($upload_data['metadata'][0]['fileid'] ?? null);
+            // Handle directory errors (same as non-streaming)
+            $error_result = isset($upload_data['result']) ? (int)$upload_data['result'] : 0;
+            $error_message = isset($upload_data['error']) ? (string)$upload_data['error'] : '';
+            $has_directory_error = ($error_result === 2005) ||
+                                   (stripos($error_message, 'Directory does not exist') !== false);
+            if (!$file_id && $has_directory_error) {
+                // Retry with folder recreation (same logic as non-streaming)
+                $full_file_path = $upload_path . '/' . $remote_filename;
+                $retry_cache = [];
+                $this->ensure_parent_folders_optimized($full_file_path, $access_token, $retry_cache);
+                // Retry upload (use non-streaming for retry to be more reliable)
+                usleep(300000); // 300ms wait
+                return $this->upload_file_to_pcloud($file_path, $upload_path . '/' . $remote_filename, $access_token, $folderid);
+            }
+            if (!$file_id) {
+                return [
+                    'success' => false,
+                    'error' => 'No file ID returned from pCloud upload. Response: ' . $response_body
+                ];
+            }
+            return [
+                'success' => true,
+                'file_id' => $file_id,
+                'file_size' => $file_size
+            ];
+        } finally {
+            fclose($file_handle);
+        }
+    }
+    /**
+     * Upload file from stream (for incremental backups)
+     *
+     * @param resource $stream Stream resource
+     * @param int $size Stream size in bytes
+     * @param string $folder_name Folder name (not used for incremental)
+     * @param string $access_token Access token
+     * @param string $custom_remote_path Full remote path
+     * @return array Upload result
+     */
+    public function upload_file_from_stream($stream, int $size, string $folder_name, string $access_token, string $custom_remote_path): array
+    {
+        // Extract directory and filename from custom_remote_path
+        $upload_path = dirname($custom_remote_path);
+        $upload_path = '/' . trim($upload_path, '/');
+        $remote_filename = basename($custom_remote_path);
+        // Get upload endpoint
+        $upload_endpoint = $this->get_api_endpoint($access_token, 'uploadfile');
+        // Build query
+        $query = [
+            'access_token' => $access_token,
+            'filename' => $remote_filename,
+            'renameifexists' => '1',
+            'nopartial' => '1',
+            'path' => $upload_path
+        ];
+        $upload_url = $upload_endpoint . '?' . http_build_query($query);
+        // Detect MIME type
+        $detected = wp_check_filetype($remote_filename);
+        $mime_type = !empty($detected['type']) ? $detected['type'] : 'application/octet-stream';
+        // Create multipart boundary
+        $boundary = wp_generate_password(24, false);
+        // Build multipart body using streams
+        $body_stream = fopen('php://temp', 'r+');
+        if ($body_stream === false) {
+            return [
+                'success' => false,
+                'error' => 'Failed to create temp stream for multipart body'
+            ];
+        }
+        // Write header
+        $header = '--' . $boundary . "\r\n";
+        $header .= 'Content-Disposition: form-data; name="file"; filename="' . $remote_filename . '"' . "\r\n";
+        $header .= 'Content-Type: ' . $mime_type . "\r\n\r\n";
+        fwrite($body_stream, $header);
+        // Stream file contents in chunks
+        $chunk_size = 8192; // 8KB chunks
+        while (!feof($stream)) {
+            $chunk = fread($stream, $chunk_size);
+            if ($chunk !== false) {
+                fwrite($body_stream, $chunk);
+            }
+        }
+        // Write footer
+        $footer = "\r\n--" . $boundary . "--";
+        fwrite($body_stream, $footer);
+        // Rewind stream
+        rewind($body_stream);
+        $body_contents = stream_get_contents($body_stream);
+        fclose($body_stream);
+        // Upload using WordPress HTTP API
+        $response = wp_safe_remote_post($upload_url, [
+            'timeout' => max(300, (int) ceil($size / (1024 * 1024)) * 10),
+            'headers' => [
+                'Content-Type' => 'multipart/form-data; boundary=' . $boundary,
+                'Expect' => '',
+                'User-Agent' => 'SiteSkite-Link/1.0; WordPress/' . get_bloginfo('version')
+            ],
+            'body' => $body_contents,
+        ]);
+        if (is_wp_error($response)) {
+            return [
+                'success' => false,
+                'error' => 'Upload failed: ' . $response->get_error_message()
+            ];
+        }
+        $response_code = wp_remote_retrieve_response_code($response);
+        $response_body = wp_remote_retrieve_body($response);
+        if ($response_code !== 200) {
+            return [
+                'success' => false,
+                'error' => 'Upload failed with status ' . $response_code . ': ' . $response_body
+            ];
+        }
+        $upload_data = json_decode($response_body, true);
+        $file_id = $upload_data['fileids'][0] ?? ($upload_data['metadata'][0]['fileid'] ?? null);
+        if (!$file_id) {
+            return [
+                'success' => false,
+                'error' => 'No file ID returned from pCloud upload. Response: ' . $response_body
+            ];
+        }
+        return [
+            'success' => true,
+            'file_id' => $file_id,
+            'file_size' => $size
+        ];
+    }

siteskite/trunk/includes/Core/Plugin.php

-                      r3416301
+                      r3418578
 use SiteSkite\Cloud\PCloudManager;
 use SiteSkite\Backup\Incremental\IncrementalStatus;
+use SiteSkite\Cron\ExternalCronManager;
+use SiteSkite\Cron\CronTriggerHandler;
 use function add_action;
 …
     /**
+     * @var ExternalCronManager External cron manager instance
+     */
+    private ExternalCronManager $external_cron_manager;
+    /**
+     * @var CronTriggerHandler Cron trigger handler instance
+     */
+    private CronTriggerHandler $cron_trigger_handler;
+    /**
      * Get plugin instance - Singleton pattern
      */
 …
             $this->cleanup_manager = new CleanupManager($this->logger);
+            // Initialize external cron manager
+            $this->external_cron_manager = new ExternalCronManager($this->logger);
             // Initialize cloud storage managers
 …
                 $this->backblaze_b2_manager,
                 $this->pcloud_manager,
+                $this->notification_manager
+                $this->notification_manager,
+                $this->external_cron_manager
             );
 …
                 $this->pcloud_manager,
                 $this->aws_manager,
+                $incremental_status
+                $incremental_status,
+                $this->external_cron_manager
             );
 …
                 $this->backup_manager,
                 $this->cleanup_manager,
+                $this->progress_tracker
+                $this->progress_tracker,
+                $this->external_cron_manager
+            );
+            // Initialize cron trigger handler
+            $this->cron_trigger_handler = new CronTriggerHandler(
+                $this->logger,
+                $this->external_cron_manager,
+                $this->backup_manager,
+                $this->schedule_manager,
+                $this->restore_manager
             );
 …
                 $this->restore_manager,
                 $this->schedule_manager,
                 $this->cleanup_manager
+                $this->cron_trigger_handler
             );
 …
         ]);
+        // Register external cron settings save handler
+        // Add filter to log REST API requests for debugging cron triggers
+        add_filter('rest_pre_dispatch', [$this, 'log_rest_api_requests'], 10, 3);
         // Background cron for continuing incremental uploads until complete
         add_action('siteskite_incremental_continue', [
 …
             'default' => ''
         ]);
+    }
 …
+        }
         require_once SITESKITE_PATH . 'templates/admin-page.php';
+    }
+    /**
+     * Log REST API requests for debugging cron triggers
+     */
+    public function log_rest_api_requests($result, $server, $request)
+    {
+        $route = $request->get_route();
+        // Log cron trigger requests for debugging
+        if (strpos($route, '/cron/trigger') !== false) {
+            $this->logger->debug('REST API request received', [
+                'route' => $route,
+                'method' => $request->get_method(),
+                'headers' => $request->get_headers(),
+                'body' => substr($request->get_body(), 0, 500) // First 500 chars
+            ]);
+        }
+        return $result;
+    }

siteskite/trunk/includes/Restore/RestoreManager.php

-                      r3400025
+                      r3418578
 use SiteSkite\Restore\RestorePlanner;
 use SiteSkite\Notification\NotificationManager;
+use SiteSkite\Cron\ExternalCronManager;
+use SiteSkite\Core\Utils;
 use function get_option;
 …
     private NotificationManager $notification_manager;
     /**
+     * @var ExternalCronManager|null External cron manager instance
+     */
+    private ?ExternalCronManager $external_cron_manager = null;
+    /**
      * Cache provider credentials pulled from stored status/runtime fetches to avoid repeated lookups.
      * @var array<string, array<string, mixed>>
 …
         BackblazeB2Manager $backblaze_b2_manager,
         PCloudManager $pcloud_manager,
+        NotificationManager $notification_manager
+        NotificationManager $notification_manager,
+        ?ExternalCronManager $external_cron_manager = null
     ) {
         $this->logger = $logger;
 …
         $this->pcloud_manager = $pcloud_manager;
         $this->notification_manager = $notification_manager;
+        $this->external_cron_manager = $external_cron_manager;
         $this->init_restore_directory();
 …
         update_option($old_key, $value);
+    }
+    /**
+     * Schedule cron event (uses external cron if enabled, otherwise WordPress cron)
+     */
+    private function schedule_cron_event(string $hook, array $args, int $delay_seconds = 0, string $title = ''): void
+    {
+        // Try external cron first if enabled
+        if ($this->external_cron_manager && $this->external_cron_manager->is_enabled()) {
+            $job_id = $this->external_cron_manager->schedule_single_event($hook, $args, $delay_seconds, $title);
+            if ($job_id) {
+                $this->logger->debug('Scheduled external cron event', [
+                    'hook' => $hook,
+                    'delay' => $delay_seconds,
+                    'job_id' => $job_id
+                ]);
+                return;
+            } else {
+                $this->logger->warning('Failed to schedule external cron, falling back to WordPress cron', [
+                    'hook' => $hook
+                ]);
+            }
+        }
+        // Fallback to WordPress cron
+        wp_schedule_single_event(time() + $delay_seconds, $hook, $args);
+    }
     private function init_restore_directory(): void
 …
             // Start background restore process
+            wp_schedule_single_event(time(), 'siteskite_process_restore', [
+                'backup_id' => $backup_id,
+                'type' => $type,
+                'download_url' => $download_url
+            ]);
+            $this->schedule_cron_event(
+                'siteskite_process_restore',
+                [
+                    'backup_id' => $backup_id,
+                    'type' => $type,
+                    'download_url' => $download_url
+                ],
+, // Immediate execution
+                "SiteSkite Process Restore"
+            );
             return new \WP_REST_Response($restore_info);
 …
             // Schedule restore to run via cron (asynchronous)
+            if (function_exists('wp_schedule_single_event')) {
+                wp_schedule_single_event(time(), 'siteskite_process_incremental_restore', [$manifestId]);
+                $this->logger->info('Incremental restore scheduled via cron', [
+                    'manifest_id' => $manifestId,
+                    'scope' => $scope
+                ]);
+            }
+            $this->schedule_cron_event(
+                'siteskite_process_incremental_restore',
+                [$manifestId],
+, // Immediate execution
+                "SiteSkite Process Incremental Restore"
+            );
+            $this->logger->info('Incremental restore scheduled via cron', [
+                'manifest_id' => $manifestId,
+                'scope' => $scope
+            ]);
             return new \WP_REST_Response([
 …
+                    }
                     // For PCloud, use the full object path
+                    // For PCloud, use the full object path to get file_id, then download
                     // The objectPath is: siteskite/{host}/objects/sha256/{hash_prefix}/{hash}.blob
+                    $res = $this->pcloud_manager->download_file($objectPath, $pcloud_access_token, $temp_file);
+                    $normalized_path = '/' . trim($objectPath, '/');
+                    // Get file_id from path using stat
+                    $stat_result = $this->pcloud_manager->stat_path($normalized_path, $pcloud_access_token);
+                    if (!$stat_result['success'] || !($stat_result['exists'] ?? false) || !isset($stat_result['metadata']['fileid'])) {
+                        $this->logger->error('Failed to get file_id from pCloud path', [
+                            'object_path' => $objectPath,
+                            'stat_result' => $stat_result
+                        ]);
+                        return null;
+                    }
+                    $file_id = (string)$stat_result['metadata']['fileid'];
+                    // Download file by ID
+                    $res = $this->pcloud_manager->download_file_by_id($file_id, $pcloud_access_token, $temp_file);
                     if (!($res['success'] ?? false)) {
                         $this->logger->error('Failed to download object from PCloud', [
                             'object_path' => $objectPath,
+                            'file_id' => $file_id,
                             'error' => $res['error'] ?? 'Unknown error'
                         ]);
 …
+                    }
+                    // Get user_id and site_host folder for classic backups (same pattern as upload)
+                    $user_id = Utils::get_user_id();
+                    $site_host = wp_parse_url(get_option('siteurl'), PHP_URL_HOST) ?: 'site';
+                    $base_folder = sanitize_text_field($request->get_param('dropbox_folder') ?? $request->get_param('target_directory') ?? '');
+                    // Construct Dropbox path with user_id/site_host folder structure
+                    $dropbox_base_path = !empty($base_folder)
+                        ? '/' . trim($base_folder, '/') . '/' . $user_id . '/' . $site_host
+                        : '/' . $user_id . '/' . $site_host;
+                    $dropbox_path = $dropbox_base_path . '/' . $file_name;
                     // Try to download the specific file first
-                    $dropbox_path = '/' . $file_name;
                     $download_result = $this->dropbox_manager->download_file($dropbox_path, $access_token, $destination);
 …
                             $file_name,
                             $destination,
                             function($full_zip_name, $full_zip_path) use ($access_token) {
                                 $full_dropbox_path = '/' . $full_zip_name;
+                            function($full_zip_name, $full_zip_path) use ($access_token, $dropbox_base_path) {
+                                $full_dropbox_path = $dropbox_base_path . '/' . $full_zip_name;
                                 return $this->dropbox_manager->download_file($full_dropbox_path, $access_token, $full_zip_path);
+                            }
 …
                     $final_destination = $this->restore_dir . '/' . $file_name;
+                    // Get user_id and site_host folder for classic backups (same pattern as upload)
+                    $user_id = Utils::get_user_id();
+                    $site_host = wp_parse_url(get_option('siteurl'), PHP_URL_HOST) ?: 'site';
+                    $folder_path = $user_id . '/' . $site_host;
+                    $target_folder_id = $this->google_drive_manager->find_folder_by_path($access_token, $folder_path, $google_drive_folder_id);
+                    // Search for file in the user_id/site_host folder
                     $file_search_result = $this->google_drive_manager->get_file_id_by_name(
                         $file_name,
                         $access_token,
                         $google_drive_folder_id
+                        $target_folder_id
                     );
 …
                             $file_name,
                             $final_destination,
+                            function($full_zip_name, $full_zip_path) use ($access_token, $google_drive_folder_id) {
+                            function($full_zip_name, $full_zip_path) use ($access_token, $google_drive_folder_id, $user_id, $site_host) {
+                                // Find user_id/site_host folder for full.zip search
+                                $folder_path = $user_id . '/' . $site_host;
+                                $target_folder_id = $this->google_drive_manager->find_folder_by_path($access_token, $folder_path, $google_drive_folder_id);
                                 $full_file_search = $this->google_drive_manager->get_file_id_by_name(
                                     $full_zip_name,
                                     $access_token,
                                     $google_drive_folder_id
+                                    $target_folder_id
                                 );
 …
                     $file_name = $url_path ? wp_basename($url_path) : wp_basename($download_url);
+                    // Get user_id and site_host folder for classic backups (same pattern as upload)
+                    $user_id = Utils::get_user_id();
+                    $site_host = wp_parse_url(get_option('siteurl'), PHP_URL_HOST) ?: 'site';
+                    $file_path_with_folders = $user_id . '/' . $site_host . '/' . $file_name;
                     $this->logger->info('Extracting filename for Backblaze B2 restore', [
                         'download_url' => $download_url,
                         'url_path' => $url_path,
                         'extracted_file_name' => $file_name,
+                        'file_path_with_folders' => $file_path_with_folders,
                         'bucket_name' => $bucket_name
                     ]);
                     // Try to find the specific file first
+                    // Try to find the specific file first in user_id/site_host folder
                     $file_search_result = $this->backblaze_b2_manager->get_file_by_name(
                         $file_name,
+                        $file_path_with_folders,
                         $key_id,
                         $application_key,
 …
                             $file_name,
                             $destination,
+                            function($full_zip_name, $full_zip_path) use ($key_id, $application_key, $bucket_name) {
+                                // Search for full.zip
+                            function($full_zip_name, $full_zip_path) use ($key_id, $application_key, $bucket_name, $user_id, $site_host) {
+                                // Search for full.zip in user_id/site_host folder
+                                $full_zip_path_with_folders = $user_id . '/' . $site_host . '/' . $full_zip_name;
                                 $full_zip_search = $this->backblaze_b2_manager->get_file_by_name(
                                     $full_zip_name,
+                                    $full_zip_path_with_folders,
                                     $key_id,
                                     $application_key,
 …
+                                }
                                 // Download the full.zip
+                                // Download the full.zip (use the path with user_id/site_host for download)
                                 $download_result = $this->backblaze_b2_manager->download_file(
                                     $full_zip_search['file_id'],
                                     $full_zip_name,
+                                    $full_zip_path_with_folders,
                                     $key_id,
                                     $application_key,
 …
                                 return $download_result;
                             },
+                            function($full_zip_name) use ($key_id, $application_key, $bucket_name) {
+                            function($full_zip_name) use ($key_id, $application_key, $bucket_name, $user_id, $site_host) {
+                                // Search for full.zip in user_id/site_host folder
+                                $full_zip_path_with_folders = $user_id . '/' . $site_host . '/' . $full_zip_name;
                                 return $this->backblaze_b2_manager->get_file_by_name(
                                     $full_zip_name,
+                                    $full_zip_path_with_folders,
                                     $key_id,
                                     $application_key,
 …
+                        }
                     } else {
                         // Specific file found, download it normally
+                        // Specific file found, download it normally (use path with user_id/site_host)
                         $download_result = $this->backblaze_b2_manager->download_file(
                             $file_search_result['file_id'],
                             $file_name,
+                            $file_path_with_folders,
                             $key_id,
                             $application_key,
 …
+                    }
+                    // Extract filename from download_url (handle both URL and path formats)
                     $file_name = basename($download_url);
+                    // Remove any URL scheme if present (e.g., http://Linked_Sites/file.zip -> file.zip)
+                    if (preg_match('/^https?:\/\//', $file_name)) {
+                        $file_name = basename(parse_url($download_url, PHP_URL_PATH));
+                    }
+                    // Get user_id and site_host for classic backups (same pattern as upload)
+                    // Path structure: {folderName}/{user_id}/{site_host}
+                    $user_id = Utils::get_user_id();
+                    $site_host = wp_parse_url(get_option('siteurl'), PHP_URL_HOST) ?: 'site';
+                    $pcloud_target_path = '/' . trim($pcloud_folder_name, '/') . '/' . $user_id . '/' . $site_host;
+                    $this->logger->debug('pCloud restore path construction', [
+                        'download_url' => $download_url,
+                        'file_name' => $file_name,
+                        'pcloud_folder_name' => $pcloud_folder_name,
+                        'user_id' => $user_id,
+                        'site_host' => $site_host,
+                        'pcloud_target_path' => $pcloud_target_path
+                    ]);
                     // Validate token and get endpoint
 …
+                    }
+                    // Helper function to get folderid from a path (simplified)
+                    $pcloud_manager = $this->pcloud_manager;
+                    $logger = $this->logger;
+                    $get_folderid_from_path = function($path) use ($pcloud_manager, $provided_token, $token_validation, $logger) {
+                        // Try stat first (fastest)
+                        $stat_result = $pcloud_manager->stat_path($path, $provided_token);
+                        if ($stat_result['success'] && ($stat_result['exists'] ?? false) && isset($stat_result['metadata']['folderid'])) {
+                            return (int)$stat_result['metadata']['folderid'];
+                        }
+                        // Fallback: get folderid by listing parent folder
+                        $parent_path = dirname($path);
+                        $folder_name = basename($path);
+                        if ($parent_path && $parent_path !== '/' && $parent_path !== '.') {
+                            // Get parent folderid
+                            $parent_folderid = null;
+                            $parent_stat = $pcloud_manager->stat_path($parent_path, $provided_token);
+                            if ($parent_stat['success'] && ($parent_stat['exists'] ?? false) && isset($parent_stat['metadata']['folderid'])) {
+                                $parent_folderid = (int)$parent_stat['metadata']['folderid'];
+                            }
+                            // List parent folder to find target folder
+                            $parent_list_params = array('access_token' => $provided_token);
+                            if ($parent_folderid !== null) {
+                                $parent_list_params['folderid'] = (string)$parent_folderid;
+                            } else {
+                                $parent_list_params['path'] = $parent_path;
+                            }
+                            $parent_list_url = $token_validation['endpoint'] . '/listfolder?' . http_build_query($parent_list_params);
+                            $parent_list_response = wp_remote_get($parent_list_url, array('timeout' => 30));
+                            if (!is_wp_error($parent_list_response) && wp_remote_retrieve_response_code($parent_list_response) === 200) {
+                                $parent_list_data = json_decode(wp_remote_retrieve_body($parent_list_response), true);
+                                $parent_contents = $parent_list_data['metadata']['contents'] ?? $parent_list_data['contents'] ?? [];
+                                foreach ($parent_contents as $item) {
+                                    if (isset($item['isfolder']) && $item['isfolder'] &&
+                                        isset($item['name']) && $item['name'] === $folder_name &&
+                                        isset($item['folderid'])) {
+                                        return (int)$item['folderid'];
+                                    }
+                                }
+                            }
+                        }
+                        return null;
+                    };
                     // Helper function to list folder and find file
+                    $find_file_in_pcloud = function($search_file_name) use ($token_validation, $provided_token, $pcloud_folder_name) {
+                        $list_url = $token_validation['endpoint'] . '/listfolder?' . http_build_query(array(
+                            'access_token' => $provided_token,
+                            'path' => '/' . trim($pcloud_folder_name, '/')
+                        ));
+                    $find_file_in_pcloud = function($search_file_name) use ($token_validation, $provided_token, $pcloud_target_path, $get_folderid_from_path, $logger) {
+                        $path_segments = array_filter(explode('/', trim($pcloud_target_path, '/')));
+                        $path_depth = count($path_segments);
+                        // Try to get folderid for nested paths (more reliable)
+                        $target_folderid = null;
+                        if ($path_depth >= 3) {
+                            $target_folderid = $get_folderid_from_path($pcloud_target_path);
+                            if ($target_folderid) {
+                                $logger->debug('Using folderid for pCloud restore listfolder', [
+                                    'path' => $pcloud_target_path,
+                                    'folderid' => $target_folderid
+                                ]);
+                            }
+                        }
+                        // Build listfolder query - prefer folderid for nested paths
+                        $list_params = array(
+                            'access_token' => $provided_token
+                        );
+                        if ($target_folderid !== null && $path_depth >= 3) {
+                            $list_params['folderid'] = (string)$target_folderid;
+                        } else {
+                            $list_params['path'] = $pcloud_target_path;
+                        }
+                        $list_url = $token_validation['endpoint'] . '/listfolder?' . http_build_query($list_params);
                         $response = wp_remote_get($list_url, array('timeout' => 30));
+                        if (is_wp_error($response) || wp_remote_retrieve_response_code($response) !== 200) {
+                            return ['success' => false, 'error' => 'Failed to list pCloud folder'];
+                        if (is_wp_error($response)) {
+                            return ['success' => false, 'error' => 'Failed to list pCloud folder: ' . $response->get_error_message()];
+                        }
+                        $response_code = wp_remote_retrieve_response_code($response);
+                        if ($response_code !== 200) {
+                            $error_body = wp_remote_retrieve_body($response);
+                            // If folderid approach failed, try with path as fallback
+                            if ($target_folderid !== null && $path_depth >= 3) {
+                                $logger->debug('listfolder with folderid failed, trying with path', [
+                                    'path' => $pcloud_target_path,
+                                    'response_code' => $response_code
+                                ]);
+                                $fallback_url = $token_validation['endpoint'] . '/listfolder?' . http_build_query(array(
+                                    'access_token' => $provided_token,
+                                    'path' => $pcloud_target_path
+                                ));
+                                $fallback_response = wp_remote_get($fallback_url, array('timeout' => 30));
+                                if (!is_wp_error($fallback_response) && wp_remote_retrieve_response_code($fallback_response) === 200) {
+                                    $response = $fallback_response;
+                                } else {
+                                    return ['success' => false, 'error' => 'Failed to list pCloud folder. Status: ' . $response_code . ', Response: ' . $error_body];
+                                }
+                            } else {
+                                return ['success' => false, 'error' => 'Failed to list pCloud folder. Status: ' . $response_code . ', Response: ' . $error_body];
+                            }
+                        }
                         $response_data = json_decode(wp_remote_retrieve_body($response), true);
                         $files = array();
+                        // Handle different response structures
                         if (isset($response_data['metadata']['contents'])) {
                             $files = $response_data['metadata']['contents'];
+                        } elseif (isset($response_data['contents'])) {
+                            $files = $response_data['contents'];
+                        }
+                        $logger->debug('pCloud listfolder response', [
+                            'path' => $pcloud_target_path,
+                            'folderid' => $target_folderid,
+                            'files_count' => count($files),
+                            'file_names' => array_map(function($f) { return $f['name'] ?? 'unknown'; }, $files),
+                            'search_file_name' => $search_file_name
+                        ]);
+                        // If no files found and we used path (not folderid), try to get folderid and retry
+                        if (empty($files) && $target_folderid === null && $path_depth >= 3) {
+                            $logger->debug('No files found with path, trying to get folderid and retry', [
+                                'path' => $pcloud_target_path
+                            ]);
+                            // Try to get folderid using helper function
+                            $target_folderid = $get_folderid_from_path($pcloud_target_path);
+                            if ($target_folderid) {
+                                // Retry listfolder with folderid
+                                $retry_list_url = $token_validation['endpoint'] . '/listfolder?' . http_build_query(array(
+                                    'access_token' => $provided_token,
+                                    'folderid' => (string)$target_folderid
+                                ));
+                                $retry_response = wp_remote_get($retry_list_url, array('timeout' => 30));
+                                if (!is_wp_error($retry_response) && wp_remote_retrieve_response_code($retry_response) === 200) {
+                                    $response = $retry_response;
+                                    $response_data = json_decode(wp_remote_retrieve_body($response), true);
+                                    $files = array();
+                                    if (isset($response_data['metadata']['contents'])) {
+                                        $files = $response_data['metadata']['contents'];
+                                    } elseif (isset($response_data['contents'])) {
+                                        $files = $response_data['contents'];
+                                    }
+                                    $logger->debug('pCloud listfolder retry response (with folderid)', [
+                                        'path' => $pcloud_target_path,
+                                        'folderid' => $target_folderid,
+                                        'files_count' => count($files)
+                                    ]);
+                                }
+                            }
+                        }
 …
                             if (isset($file['name']) && $file['name'] === $search_file_name) {
                                 $file_id = $file['fileid'];
+                                $logger->debug('Found file in pCloud', [
+                                    'file_name' => $search_file_name,
+                                    'file_id' => $file_id
+                                ]);
                                 break;
+                            }
 …
                         if (empty($file_id)) {
+                            return ['success' => false, 'error' => 'File not found: ' . $search_file_name];
+                            $available_files = array_map(function($f) {
+                                return $f['name'] ?? 'unknown';
+                            }, $files);
+                            $logger->error('File not found in pCloud folder', [
+                                'search_file_name' => $search_file_name,
+                                'pcloud_target_path' => $pcloud_target_path,
+                                'folderid' => $target_folderid,
+                                'available_files' => $available_files,
+                                'files_count' => count($files)
+                            ]);
+                            return ['success' => false, 'error' => 'File not found: ' . $search_file_name . ' in path: ' . $pcloud_target_path . '. Available files: ' . implode(', ', $available_files)];
+                        }
 …
              // Schedule the restore process
+             wp_schedule_single_event(time(), 'siteskite_process_restore', [
+                'backup_id' => $backup_id,
+                'type' => $type,
+                'download_url' => $download_result['file_path']
+            ]);
+             $this->schedule_cron_event(
+                'siteskite_process_restore',
+                [
+                    'backup_id' => $backup_id,
+                    'type' => $type,
+                    'download_url' => $download_result['file_path']
+                ],
+, // Immediate execution
+                "SiteSkite Process Restore"
+            );
             return new \WP_REST_Response([
 …
             // Schedule cleanup of restore status after 5 minutes
+            if (function_exists('wp_schedule_single_event')) {
+                wp_schedule_single_event(
+                    time() + 300,
+                    'siteskite_cleanup_restore_status',
+                    [$restore_id]
+                );
+            }
+            $this->schedule_cron_event(
+                'siteskite_cleanup_restore_status',
+                [$restore_id],
+, // 5 minutes delay
+                "SiteSkite Cleanup Restore Status"
+            );
         } catch (\Exception $e) {
             $this->logger->error('Failed to handle restore completion', [

siteskite/trunk/includes/Schedule/ScheduleManager.php

-                      r3389896
+                      r3418578
 use SiteSkite\Cleanup\CleanupManager;
 use SiteSkite\Progress\ProgressTracker;
+use SiteSkite\Cron\ExternalCronManager;
 use function get_option;
 use function update_option;
 …
     private ProgressTracker $progress_tracker;
+    /**
+     * @var ExternalCronManager|null External cron manager instance
+     */
+    private ?ExternalCronManager $external_cron_manager = null;
     private const SECONDS_IN_MONTH = 2592000; // 30 days
     private const OPTION_KEY_OLD = 'siteskite_backup_schedules';
 …
         BackupManager $backup_manager,
         CleanupManager $cleanup_manager,
+        ProgressTracker $progress_tracker
+        ProgressTracker $progress_tracker,
+        ?ExternalCronManager $external_cron_manager = null
     ) {
         $this->logger = $logger;
 …
         $this->cleanup_manager = $cleanup_manager;
         $this->progress_tracker = $progress_tracker;
+        $this->external_cron_manager = $external_cron_manager;
         $this->register_hooks();
+    }
 …
+    {
         try {
+            // Clear external cron jobs
+            if ($this->external_cron_manager && $this->external_cron_manager->is_enabled()) {
+                $schedule = $this->get_option_bc(self::SINGLE_SCHEDULE_NEW, self::SINGLE_SCHEDULE_OLD);
+                if (isset($schedule['external_job_id'])) {
+                    $this->external_cron_manager->delete_job($schedule['external_job_id']);
+                    $this->logger->info('Deleted external cron job', [
+                        'job_id' => $schedule['external_job_id']
+                    ]);
+                }
+            }
             $this->clear_all_schedules();
             $this->clear_all_cron_events();
 …
             wp_clear_scheduled_hook('siteskite_scheduled_backup');
+            // Create the new schedule - don't pass backup_id, generate it fresh each run
+            wp_schedule_event(
+                $schedule['next_run'],
+                $schedule['frequency'],
+                'siteskite_scheduled_backup',
+                [$schedule_data['type'], 'automatic']
+            );
+            // Try external cron first if enabled
+            if ($this->external_cron_manager && $this->external_cron_manager->is_enabled()) {
+                $job_id = $this->external_cron_manager->create_recurring_job(
+                    'siteskite_scheduled_backup',
+                    [$schedule_data['type'], 'automatic'],
+                    $schedule_data['frequency'],
+                    [
+                        'time' => $schedule_data['time'] ?? '00:00',
+                        'day' => $schedule_data['day'] ?? '',
+                        'date' => $schedule_data['date'] ?? 1
+                    ],
+                    "SiteSkite: Scheduled Backup ({$schedule_data['type']})"
+                );
+                if ($job_id) {
+                    // Store job ID in schedule
+                    $schedule['external_job_id'] = $job_id;
+                    $this->update_option_bc(self::OPTION_KEY_NEW, self::OPTION_KEY_OLD, [$schedule['id'] => $schedule]);
+                    $this->update_option_bc(self::SINGLE_SCHEDULE_NEW, self::SINGLE_SCHEDULE_OLD, $schedule);
+                    $this->logger->info('Created external cron job for scheduled backup', [
+                        'job_id' => $job_id,
+                        'type' => $schedule_data['type'],
+                        'frequency' => $schedule_data['frequency']
+                    ]);
+                } else {
+                    $this->logger->warning('Failed to create external cron job, falling back to WordPress cron');
+                    // Fall through to WordPress cron
+                }
+            }
+            // Fallback to WordPress cron if external cron is disabled or failed
+            if (!$this->external_cron_manager || !$this->external_cron_manager->is_enabled() || !isset($schedule['external_job_id'])) {
+                wp_schedule_event(
+                    $schedule['next_run'],
+                    $schedule['frequency'],
+                    'siteskite_scheduled_backup',
+                    [$schedule_data['type'], 'automatic']
+                );
+            }
             $this->logger->info('Created new backup schedule', $schedule);
 …
     private function cleanup_existing_crons(): void {
         try {
+            // Clear external cron jobs if enabled
+            if ($this->external_cron_manager && $this->external_cron_manager->is_enabled()) {
+                $schedule = $this->get_option_bc(self::SINGLE_SCHEDULE_NEW, self::SINGLE_SCHEDULE_OLD);
+                if (isset($schedule['external_job_id'])) {
+                    $this->external_cron_manager->delete_job($schedule['external_job_id']);
+                    $this->logger->debug('Deleted external cron job during cleanup', [
+                        'job_id' => $schedule['external_job_id']
+                    ]);
+                }
+            }
             // Clear any recurring schedules using public API
             wp_clear_scheduled_hook('siteskite_scheduled_backup');

siteskite/trunk/readme.txt

-                      r3416301
+                      r3418578
 Tested up to: 6.9
 Requires PHP: 7.4
 Stable tag: 1.0.6
+Stable tag: 1.0.7
 License: GPLv2 or later
 License URI: https://www.gnu.org/licenses/gpl-2.0.html
 …
 == Changelog ==
+= 1.0.7 (13 December 2025) =
+* Added: Better Backup management
+* Improved: Backup performance
 = 1.0.6 (10 December 2025) =
 * Added: pCloud Auth based Authentication
 …
 == Upgrade Notice ==
+= 1.0.7 (13 December 2025) =
+* Added: Better Backup management
+* Improved: Backup performance
 = 1.0.6 (10 December 2025) =
 * Added: pCloud Auth based Authentication

siteskite/trunk/siteskite-link.php

-                      r3416301
+                      r3418578
  * 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.0.6
+ * Version: 1.0.7
  * Requires at least: 5.3
  * Requires PHP: 7.4
 …
 // Plugin version
 define('SITESKITE_VERSION', '1.0.6');
+define('SITESKITE_VERSION', '1.0.7');
 // Plugin file, path, and URL

siteskite/trunk/templates/admin-page.php

-                      r3389896
+                      r3418578
     </div>
     <?php endif; ?>
+    <!-- External Cron Settings Section -->
 </div>

Plugin Directory

Context Navigation

Legend:

siteskite/trunk/assets/css/admin.css

siteskite/trunk/includes/API/RestAPI.php

siteskite/trunk/includes/Backup/BackupManager.php

siteskite/trunk/includes/Backup/Incremental/Impl/BackblazeB2ObjectStore.php

siteskite/trunk/includes/Backup/Incremental/Impl/PCloudObjectStore.php

siteskite/trunk/includes/Backup/Incremental/RetryPolicy.php

siteskite/trunk/includes/Cloud/AWSManager.php

siteskite/trunk/includes/Cloud/GoogleDriveManager.php

siteskite/trunk/includes/Cloud/PCloudManager.php

siteskite/trunk/includes/Core/Plugin.php

siteskite/trunk/includes/Restore/RestoreManager.php

siteskite/trunk/includes/Schedule/ScheduleManager.php

siteskite/trunk/readme.txt

siteskite/trunk/siteskite-link.php

siteskite/trunk/templates/admin-page.php

Download in other formats: