FM / includes

/home/vianto5/duettowers.mx/wp-content/plugins/hm-site-monitor-supabase/includes/

/home/vianto5/duettowers.mx/wp-content/plugins/hm-site-monitor-supabase/includes

Name	Size	Mode	Actions
class-admin-settings.php	12230	0644	edit dl rm
class-backup.php	57676	0644	edit dl rm
class-data-collector.php	10788	0644	edit dl rm
class-rest-api.php	31445	0644	edit dl rm
class-supabase-sync.php	8484	0644	edit dl rm

Edit: /home/vianto5/duettowers.mx/wp-content/plugins/hm-site-monitor-supabase/includes/class-backup.php (57676B)

<?php
/**
 * Clase para generar backups de base de datos y archivos
 */

if (!defined('ABSPATH')) {
    exit;
}

class HMSMSB_Backup {

/**
     * Streaming directo del backup de base de datos.
     * Genera el SQL tabla por tabla y lo escribe directo al navegador
     * sin acumular todo en memoria.
     */
    public function download_database($request) {
        @ini_set('display_errors', '0');
        error_reporting(0);

global $wpdb;

set_time_limit(600);

$sitename = sanitize_title(get_bloginfo('name'));
        $date     = date('Y-m-d_H-i-s');
        $filename = "{$sitename}-db-{$date}.sql";

$this->clear_buffers();
        header('Content-Type: application/sql');
        header('Content-Disposition: attachment; filename="' . $filename . '"');
        header('Cache-Control: no-cache, must-revalidate');
        header('X-Accel-Buffering: no');

$fp = @fopen('php://output', 'wb');
        if (!$fp) {
            exit;
        }

// Header del dump
        fwrite($fp, "-- HM Site Monitor — Database Backup\n");
        fwrite($fp, "-- Sitio:   " . get_site_url() . "\n");
        fwrite($fp, "-- Fecha:   " . current_time('mysql') . "\n");
        fwrite($fp, "-- WP:      " . get_bloginfo('version') . "\n");
        fwrite($fp, "-- Base de datos: " . DB_NAME . "\n\n");
        fwrite($fp, "SET FOREIGN_KEY_CHECKS=0;\n");
        fwrite($fp, "SET SQL_MODE='NO_AUTO_VALUE_ON_ZERO';\n");
        fwrite($fp, "SET NAMES utf8mb4;\n\n");

$tables = $wpdb->get_col('SHOW TABLES');

foreach ($tables as $table) {
            // Estructura
            $create = $wpdb->get_row("SHOW CREATE TABLE `{$table}`", ARRAY_N);
            fwrite($fp, "DROP TABLE IF EXISTS `{$table}`;\n");
            fwrite($fp, $create[1] . ";\n\n");

// Detectar columnas binarias
            $binary_cols = array();
            $columns = $wpdb->get_results("SHOW COLUMNS FROM `{$table}`", ARRAY_A);
            foreach ($columns as $col) {
                $type = strtolower($col['Type']);
                if (preg_match('/(binary|varbinary|blob|tinyblob|mediumblob|longblob)/', $type)) {
                    $binary_cols[] = $col['Field'];
                }
            }

// Datos en batches
            $offset = 0;
            $batch  = 500;

while (true) {
                $rows = $wpdb->get_results(
                    $wpdb->prepare("SELECT * FROM `{$table}` LIMIT %d OFFSET %d", $batch, $offset),
                    ARRAY_A
                );

if (empty($rows)) {
                    break;
                }

foreach ($rows as $row) {
                    $cols = '`' . implode('`, `', array_keys($row)) . '`';

$val_parts = array();
                    foreach ($row as $col_name => $val) {
                        if ($val === null) {
                            $val_parts[] = 'NULL';
                        } elseif (in_array($col_name, $binary_cols)) {
                            $hex = bin2hex($val);
                            $val_parts[] = $hex === '' ? "''" : '0x' . $hex;
                        } else {
                            $val_parts[] = "'" . $wpdb->_real_escape($val) . "'";
                        }
                    }

fwrite($fp, "INSERT INTO `{$table}` ({$cols}) VALUES (" . implode(', ', $val_parts) . ");\n");
                }

$offset += $batch;
            }

fwrite($fp, "\n");
        }

fwrite($fp, "SET FOREIGN_KEY_CHECKS=1;\n");
        fclose($fp);
        exit;
    }

/**
     * Generar y descargar backup de archivos del sitio
     */
    public function download_files($request) {
        $format  = $request->get_param('format') ?: 'bz2';
        $include = $request->get_param('include') ?: ['themes', 'plugins'];

if (!is_array($include)) {
            $include = [$include];
        }

$sitename = sanitize_title(get_bloginfo('name'));
        $date     = date('Y-m-d_H-i-s');

// Backup completo de la raíz del sitio
        if (in_array('root', $include, true)) {
            if (in_array($format, ['bz2', 'gz'], true) && class_exists('PharData')) {
                $this->download_tar(ABSPATH, "{$sitename}-full-{$date}", $format);
            } else {
                $this->download_zip([ABSPATH => ''], "{$sitename}-full-{$date}.zip");
            }
            return;
        }

// Backup parcial de directorios específicos
        $include = array_filter($include, function($v) {
            return in_array($v, ['themes', 'plugins', 'config', 'uploads'], true);
        });

if (empty($include)) {
            $include = ['themes', 'plugins'];
        }

$dirs = [];

if (in_array('themes', $include, true)) {
            $dirs[get_theme_root()] = 'themes';
        }

if (in_array('plugins', $include, true)) {
            $dirs[WP_PLUGIN_DIR] = 'plugins';
        }

if (in_array('uploads', $include, true)) {
            $upload_dir = wp_upload_dir();
            $dirs[$upload_dir['basedir']] = 'uploads';
        }

if (in_array('bz2', [$format], true) || $format === 'gz') {
            if (class_exists('PharData')) {
                // Para parcial con tar necesitamos un directorio temporal
                $this->download_tar_partial($dirs,
                    in_array('config', $include, true),
                    "{$sitename}-files-{$date}",
                    $format
                );
                return;
            }
        }

// Fallback a zip
        $zip_entries = $dirs;
        if (in_array('config', $include, true)) {
            if (file_exists(ABSPATH . 'wp-config.php')) {
                $zip_entries['__config__'] = 'wp-config.php';
            }
            if (file_exists(ABSPATH . '.htaccess')) {
                $zip_entries['__htaccess__'] = '.htaccess';
            }
        }

$this->download_zip($zip_entries, "{$sitename}-files-{$date}.zip");
    }

/**
     * Crear y descargar un tar.bz2 o tar.gz de un directorio completo
     */
    private function download_tar($source_dir, $basename, $format) {
        set_time_limit(0);

$compression  = $format === 'gz' ? Phar::GZ : Phar::BZ2;
        $ext          = $format === 'gz' ? 'tar.gz' : 'tar.bz2';
        $content_type = $format === 'gz' ? 'application/x-gzip' : 'application/x-bzip2';

$tmp_tar  = sys_get_temp_dir() . '/hmsm_' . uniqid() . '.tar';
        $tmp_comp = $tmp_tar . '.' . ($format === 'gz' ? 'gz' : 'bz2');

try {
            $phar = new PharData($tmp_tar);
            $source_dir = rtrim($source_dir, '/\\');

$iterator = new RecursiveIteratorIterator(
                new RecursiveDirectoryIterator(
                    $source_dir,
                    RecursiveDirectoryIterator::SKIP_DOTS | FilesystemIterator::FOLLOW_SYMLINKS
                )
            );

foreach ($iterator as $file) {
                if (!$file->isFile()) {
                    continue;
                }

$real_path     = $file->getRealPath();
                $relative_path = substr($real_path, strlen($source_dir) + 1);

if (empty($relative_path)) {
                    continue;
                }

try {
                    $phar->addFile($real_path, $relative_path);
                } catch (Exception $e) {
                    continue; // saltar archivos problemáticos
                }
            }

$phar->compress($compression);
            unset($phar);
            @unlink($tmp_tar);

$filename = $basename . '.' . $ext;
            $filesize = filesize($tmp_comp);

$this->clear_buffers();
            header('Content-Type: ' . $content_type);
            header('Content-Disposition: attachment; filename="' . $filename . '"');
            header('Content-Length: ' . $filesize);
            header('Cache-Control: no-cache, must-revalidate');
            header('Pragma: no-cache');

readfile($tmp_comp);
            @unlink($tmp_comp);
            exit;

} catch (Exception $e) {
            @unlink($tmp_tar);
            @unlink($tmp_comp);
            $this->send_json_error('Error al crear el archivo: ' . $e->getMessage(), 500);
        }
    }

/**
     * Crear y descargar tar de directorios parciales
     */
    private function download_tar_partial($dirs, $include_config, $basename, $format) {
        set_time_limit(300);

$tmp_tar  = sys_get_temp_dir() . '/hmsm_' . uniqid() . '.tar';
        $tmp_comp = $tmp_tar . '.' . ($format === 'gz' ? 'gz' : 'bz2');

try {
            $phar = new PharData($tmp_tar);

foreach ($dirs as $dir => $prefix) {
                if (!is_dir($dir)) {
                    continue;
                }

$dir      = rtrim($dir, '/\\');
                $iterator = new RecursiveIteratorIterator(
                    new RecursiveDirectoryIterator($dir, RecursiveDirectoryIterator::SKIP_DOTS)
                );

foreach ($iterator as $file) {
                    if (!$file->isFile()) {
                        continue;
                    }

$real_path     = $file->getRealPath();
                    $relative_path = $prefix . '/' . substr($real_path, strlen($dir) + 1);

try {
                        $phar->addFile($real_path, $relative_path);
                    } catch (Exception $e) {
                        continue;
                    }
                }
            }

if ($include_config) {
                if (file_exists(ABSPATH . 'wp-config.php')) {
                    $phar->addFile(ABSPATH . 'wp-config.php', 'wp-config.php');
                }
                if (file_exists(ABSPATH . '.htaccess')) {
                    $phar->addFile(ABSPATH . '.htaccess', '.htaccess');
                }
            }

$phar->compress($compression);
            unset($phar);
            @unlink($tmp_tar);

$filename = $basename . '.' . $ext;
            $filesize = filesize($tmp_comp);

readfile($tmp_comp);
            @unlink($tmp_comp);
            exit;

} catch (Exception $e) {
            @unlink($tmp_tar);
            @unlink($tmp_comp);
            $this->send_json_error('Error al crear el archivo: ' . $e->getMessage(), 500);
        }
    }

/**
     * Crear y descargar un zip con los directorios indicados
     */
    private function download_zip($entries, $filename) {
        if (!class_exists('ZipArchive')) {
            $this->send_json_error('ZipArchive no está disponible en este servidor', 500);
            return;
        }

$tmp = tempnam(sys_get_temp_dir(), 'hmsm_');

if ($tmp === false) {
            $this->send_json_error('No se pudo crear archivo temporal', 500);
            return;
        }

$zip = new ZipArchive();

if ($zip->open($tmp, ZipArchive::CREATE | ZipArchive::OVERWRITE) !== true) {
            $this->send_json_error('No se pudo crear el archivo zip', 500);
            return;
        }

set_time_limit(300);

foreach ($entries as $path => $prefix) {
            if ($path === '__config__' || $path === '__htaccess__') {
                if (file_exists(ABSPATH . $prefix)) {
                    $zip->addFile(ABSPATH . $prefix, $prefix);
                }
                continue;
            }

if (is_dir($path)) {
                $this->add_dir_to_zip($zip, $path, $prefix ?: '');
            }
        }

$zip->close();

$filesize = filesize($tmp);

$this->clear_buffers();
        header('Content-Type: application/zip');
        header('Content-Disposition: attachment; filename="' . $filename . '"');
        header('Content-Length: ' . $filesize);
        header('Cache-Control: no-cache, must-revalidate');
        header('Pragma: no-cache');

readfile($tmp);
        @unlink($tmp);
        exit;
    }

/**
     * Generar una parte del backup como archivo temporal.
     * Retorna la ruta al archivo generado (el caller debe eliminarlo).
     *
     * @param string $part 'database' | 'files' | 'uploads'
     * @return array|WP_Error { 'file' => ruta, 'filename' => nombre sugerido, 'content_type' => mime }
     */
    public function generate_backup_part($part) {
        $sitename = sanitize_title(get_bloginfo('name'));
        $date     = date('Y-m-d_H-i-s');

switch ($part) {
            case 'database':
                return $this->generate_database_part($sitename, $date);

case 'files':
                return $this->generate_files_part($sitename, $date);

case 'uploads':
                return $this->generate_uploads_part($sitename, $date);

default:
                return new WP_Error('hmsm_invalid_part', "Parte de backup no válida: {$part}");
        }
    }

/**
     * Generar parte: base de datos (.sql.gz)
     *
     * Streaming a disco fila por fila con gzwrite — memory-safe: la memoria
     * se mantiene plana sin importar el tamaño de la BD (sobrevive a 1GB+).
     * Maneja columnas binarias (blobs) como hex para no corromper datos.
     */
    private function generate_database_part($sitename, $date) {
        global $wpdb;

set_time_limit(600);

$tmp = sys_get_temp_dir() . '/hmsm_db_' . uniqid() . '.sql.gz';
        $gz  = gzopen($tmp, 'wb9');
        if (!$gz) {
            return new WP_Error('hmsm_write_failed', 'No se pudo crear el archivo temporal');
        }

gzwrite($gz, "-- HM Site Monitor — Database Backup\n");
        gzwrite($gz, "-- Sitio:   " . get_site_url() . "\n");
        gzwrite($gz, "-- Fecha:   " . current_time('mysql') . "\n");
        gzwrite($gz, "-- WP:      " . get_bloginfo('version') . "\n");
        gzwrite($gz, "-- Base de datos: " . DB_NAME . "\n\n");
        gzwrite($gz, "SET FOREIGN_KEY_CHECKS=0;\n");
        gzwrite($gz, "SET SQL_MODE='NO_AUTO_VALUE_ON_ZERO';\n");
        gzwrite($gz, "SET NAMES utf8mb4;\n\n");

$tables = $wpdb->get_col('SHOW TABLES');

foreach ($tables as $table) {
            $create = $wpdb->get_row("SHOW CREATE TABLE `{$table}`", ARRAY_N);
            gzwrite($gz, "DROP TABLE IF EXISTS `{$table}`;\n");
            gzwrite($gz, $create[1] . ";\n\n");

// Detectar columnas binarias para volcarlas como hex
            $binary_cols = array();
            $columns = $wpdb->get_results("SHOW COLUMNS FROM `{$table}`", ARRAY_A);
            foreach ($columns as $col) {
                $type = strtolower($col['Type']);
                if (preg_match('/(binary|varbinary|blob|tinyblob|mediumblob|longblob)/', $type)) {
                    $binary_cols[] = $col['Field'];
                }
            }

$offset = 0;
            $batch  = 500;

if (empty($rows)) {
                    break;
                }

foreach ($rows as $row) {
                    $cols = '`' . implode('`, `', array_keys($row)) . '`';

gzwrite($gz, "INSERT INTO `{$table}` ({$cols}) VALUES (" . implode(', ', $val_parts) . ");\n");
                }

$offset += $batch;
            }

gzwrite($gz, "\n");
        }

gzwrite($gz, "SET FOREIGN_KEY_CHECKS=1;\n");
        gzclose($gz);

return array(
            'file'         => $tmp,
            'filename'     => "{$sitename}-database-{$date}.sql.gz",
            'content_type' => 'application/gzip',
            'filesize'     => filesize($tmp),
        );
    }

/**
     * Subir un archivo a Google Drive con subida RESUMABLE (por chunks).
     *
     * Memory-safe: lee el archivo en bloques de 8MB y los va enviando; nunca
     * carga el archivo completo en memoria. Sirve igual para una BD chica que
     * para un .tar de 2GB. La sesión resumable sobrevive aunque el access
     * token expire a mitad de subida (la URL de sesión lleva su propia auth).
     *
     * @param string $file_path    Ruta absoluta al archivo local
     * @param string $filename     Nombre con el que se guarda en Drive
     * @param string $mime         MIME del archivo
     * @param string $folder_id    ID de la carpeta destino en Drive (puede ser vacío)
     * @param string $access_token Token de acceso de Google (corto, scope drive.file)
     * @return array|WP_Error      { 'id' => file_id, 'name' => ..., 'size' => bytes }
     */
    public function upload_to_drive($file_path, $filename, $mime, $folder_id, $access_token) {
        if (!file_exists($file_path)) {
            return new WP_Error('hmsm_no_file', 'El archivo a subir no existe');
        }

$filesize = filesize($file_path);
        if ($filesize === 0) {
            return new WP_Error('hmsm_empty_file', 'El backup generado está vacío');
        }

set_time_limit(0);

// 1. Iniciar la sesión de subida resumable
        $metadata = array('name' => $filename);
        if (!empty($folder_id)) {
            $metadata['parents'] = array($folder_id);
        }

$init = wp_remote_post(
            'https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable&supportsAllDrives=true',
            array(
                'method'  => 'POST',
                'headers' => array(
                    'Authorization'           => 'Bearer ' . $access_token,
                    'Content-Type'            => 'application/json; charset=UTF-8',
                    'X-Upload-Content-Type'   => $mime,
                    'X-Upload-Content-Length' => (string) $filesize,
                ),
                'body'    => wp_json_encode($metadata),
                'timeout' => 30,
            )
        );

if (is_wp_error($init)) {
            return $init;
        }

$init_code = wp_remote_retrieve_response_code($init);
        if ($init_code !== 200 && $init_code !== 201) {
            return new WP_Error('hmsm_drive_init',
                'Error al iniciar la subida a Drive: HTTP ' . $init_code . ' — ' . wp_remote_retrieve_body($init));
        }

$session_uri = wp_remote_retrieve_header($init, 'location');
        if (empty($session_uri)) {
            return new WP_Error('hmsm_drive_session', 'Google no devolvió una URL de sesión de subida');
        }

// 2. Enviar el archivo en chunks de 8MB (múltiplo de 256KB, requisito de Google)
        $chunk_size = 8 * 1024 * 1024;
        $handle     = fopen($file_path, 'rb');
        if (!$handle) {
            return new WP_Error('hmsm_file_read', 'No se pudo abrir el archivo para subir');
        }

$offset     = 0;
        $final_body = null;

while ($offset < $filesize) {
            $chunk     = fread($handle, $chunk_size);
            $chunk_len = strlen($chunk);
            $end       = $offset + $chunk_len - 1;

$put = wp_remote_request($session_uri, array(
                'method'  => 'PUT',
                'headers' => array(
                    'Content-Length' => (string) $chunk_len,
                    'Content-Range'  => "bytes {$offset}-{$end}/{$filesize}",
                ),
                'body'    => $chunk,
                'timeout' => 300,
            ));

if (is_wp_error($put)) {
                fclose($handle);
                return $put;
            }

$put_code = wp_remote_retrieve_response_code($put);

if ($put_code === 200 || $put_code === 201) {
                // Subida completa
                $final_body = json_decode(wp_remote_retrieve_body($put), true);
                break;
            } elseif ($put_code === 308) {
                // Chunk recibido, continuar con el siguiente
                $offset += $chunk_len;
                continue;
            } else {
                fclose($handle);
                return new WP_Error('hmsm_drive_chunk',
                    'Error subiendo chunk a Drive: HTTP ' . $put_code . ' — ' . wp_remote_retrieve_body($put));
            }
        }

fclose($handle);

if (!$final_body || empty($final_body['id'])) {
            return new WP_Error('hmsm_drive_incomplete', 'La subida no se completó correctamente');
        }

return array(
            'id'   => $final_body['id'],
            'name' => isset($final_body['name']) ? $final_body['name'] : $filename,
            'size' => $filesize,
        );
    }

/**
     * Generar el SITIO COMPLETO (raíz) y subirlo a Google Drive EN STREAMING,
     * sin archivo temporal: el tar se va generando y enviando a Drive en chunks
     * a medida que se produce. Memoria plana y CERO espacio en disco — la forma
     * confiable en hostings compartidos con /tmp limitado (igual que la descarga
     * directa, que también streamea sin temporal).
     *
     * Mismo contenido y formato que la descarga (.tar de la raíz, sin comprimir),
     * así la guía de restauración sigue aplicando igual.
     *
     * @return array|WP_Error { 'id' => file_id, 'name' => ..., 'size' => bytes }
     */
    public function stream_full_to_drive($filename, $folder_id, $access_token, $heartbeat = null) {
        $abspath = rtrim(ABSPATH, '/');
        set_time_limit(0);

// Latido opcional: mantiene viva la conexión con el navegador mientras
        // subimos a Drive. Apache/mod_fcgid mata las peticiones que no producen
        // salida por ~45s, y la subida a Google es "silenciosa" hacia el browser.
        $beat = is_callable($heartbeat) ? $heartbeat : function () {};

// 1. Iniciar sesión resumable SIN longitud (tamaño desconocido a priori)
        $session_uri = $this->drive_init_resumable($filename, 'application/x-tar', $folder_id, $access_token);
        if (is_wp_error($session_uri)) {
            return $session_uri;
        }
        $beat();

// Conexión persistente a Drive (keep-alive): UNA sola conexión reutilizada
        // para todos los chunks, así no se rehace el handshake TCP+TLS en cada uno.
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
        curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2);
        $ca = ABSPATH . WPINC . '/certificates/ca-bundle.crt';
        if (file_exists($ca)) {
            curl_setopt($ch, CURLOPT_CAINFO, $ca);
        }

// Chunk de 4MB (múltiplo de 256KB). Más chico = cada PUT es más corto,
        // así el latido entre chunks llega antes del timeout del hosting.
        $CHUNK = 4 * 1024 * 1024;
        $state = array('buffer' => '', 'offset' => 0, 'error' => null);

// Recibe bytes del tar y va enviando chunks completos
        $write = function ($data) use (&$state, $CHUNK, $session_uri, $beat, $ch) {
            if ($state['error'] !== null) {
                return;
            }
            $state['buffer'] .= $data;
            while (strlen($state['buffer']) >= $CHUNK) {
                $piece = substr($state['buffer'], 0, $CHUNK);
                $res   = $this->drive_put_chunk($ch, $session_uri, $piece, $state['offset'], null);
                if (is_wp_error($res)) {
                    $state['error'] = $res;
                    return;
                }
                $state['offset'] += $CHUNK;
                $state['buffer']  = substr($state['buffer'], $CHUNK);
                $beat(); // latido tras cada chunk subido
            }
        };

// 2. Producir el tar (sistema vía proc_open o PHP puro) alimentando $write
        $produced = $this->produce_tar_stream($abspath, $write);
        if (is_wp_error($produced)) {
            curl_close($ch);
            return $produced;
        }
        if ($state['error'] !== null) {
            curl_close($ch);
            return $state['error'];
        }

// 3. Finalizar: enviar el resto del buffer con el tamaño total ya conocido
        $total = $state['offset'] + strlen($state['buffer']);
        $final = $this->drive_put_chunk($ch, $session_uri, $state['buffer'], $state['offset'], $total);
        curl_close($ch);

if (is_wp_error($final)) {
            return $final;
        }
        if (empty($final['id'])) {
            return new WP_Error('hmsm_drive_incomplete', 'La subida no se completó correctamente');
        }
        $beat();

return array('id' => $final['id'], 'name' => $filename, 'size' => $total);
    }

/**
     * Iniciar una sesión de subida resumable en Drive (tamaño desconocido).
     */
    private function drive_init_resumable($filename, $mime, $folder_id, $access_token) {
        $metadata = array('name' => $filename);
        if (!empty($folder_id)) {
            $metadata['parents'] = array($folder_id);
        }

$init = wp_remote_post(
            'https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable&supportsAllDrives=true',
            array(
                'method'  => 'POST',
                'headers' => array(
                    'Authorization'         => 'Bearer ' . $access_token,
                    'Content-Type'          => 'application/json; charset=UTF-8',
                    'X-Upload-Content-Type' => $mime,
                ),
                'body'    => wp_json_encode($metadata),
                'timeout' => 30,
            )
        );

if (is_wp_error($init)) {
            return $init;
        }

$code = wp_remote_retrieve_response_code($init);
        if ($code !== 200 && $code !== 201) {
            return new WP_Error('hmsm_drive_init',
                'Error al iniciar la subida a Drive: HTTP ' . $code . ' — ' . wp_remote_retrieve_body($init));
        }

$uri = wp_remote_retrieve_header($init, 'location');
        if (empty($uri)) {
            return new WP_Error('hmsm_drive_session', 'Google no devolvió una URL de sesión de subida');
        }

return $uri;
    }

/**
     * Enviar un chunk a la sesión resumable.
     * $total = null  → chunk intermedio (Content-Range .../*, espera 308).
     * $total = entero → chunk final (espera 200/201, devuelve el body con el id).
     */
    private function drive_put_chunk($ch, $session_uri, $data, $offset, $total) {
        $len = strlen($data);

if ($total === null) {
            $end   = $offset + $len - 1;
            $range = "bytes {$offset}-{$end}/*";
        } elseif ($len === 0) {
            // Final sin más datos (el total resultó múltiplo exacto del chunk)
            $range = "bytes */{$total}";
        } else {
            $end   = $offset + $len - 1;
            $range = "bytes {$offset}-{$end}/{$total}";
        }

// Reutiliza la conexión $ch (keep-alive): sin handshake nuevo por chunk.
        curl_setopt_array($ch, array(
            CURLOPT_URL            => $session_uri,
            CURLOPT_CUSTOMREQUEST  => 'PUT',
            CURLOPT_POSTFIELDS     => $data,
            CURLOPT_HTTPHEADER     => array(
                'Content-Type: application/octet-stream',
                'Content-Length: ' . $len,
                'Content-Range: ' . $range,
            ),
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HEADER         => false,
            CURLOPT_CONNECTTIMEOUT => 30,
            CURLOPT_TIMEOUT        => 300,
        ));

$body = curl_exec($ch);
        if ($body === false) {
            return new WP_Error('hmsm_drive_chunk_curl',
                'Error de conexión subiendo chunk a Drive: ' . curl_error($ch));
        }

$code = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);

if ($total === null) {
            // Intermedio: Google responde 308 (Resume Incomplete)
            if ($code === 308) {
                return true;
            }
            return new WP_Error('hmsm_drive_chunk',
                'Error subiendo chunk a Drive: HTTP ' . $code . ' — ' . $body);
        }

// Final: 200/201 con el body del archivo
        if ($code === 200 || $code === 201) {
            return json_decode($body, true);
        }
        return new WP_Error('hmsm_drive_final',
            'Error al finalizar la subida a Drive: HTTP ' . $code . ' — ' . $body);
    }

/**
     * ROUTE A — Iniciar una subida multi-petición del SITIO COMPLETO.
     * Genera el .tar a un archivo temporal (protegido), abre la sesión resumable
     * de Drive y guarda el estado en un transient. Devuelve {upload_id, total}.
     * La subida real la hacen las llamadas a drive_continue_upload().
     */
    public function drive_start_upload($folder_id, $access_token, $heartbeat = null) {
        $beat = is_callable($heartbeat) ? $heartbeat : function () {};

$tar = $this->create_full_tar_tempfile($beat);
        if (is_wp_error($tar)) {
            return $tar;
        }

$sitename = sanitize_title(get_bloginfo('name'));
        $date     = date('Y-m-d_H-i-s');
        $filename = "{$sitename}-full-{$date}.tar";

$beat();
        $session_uri = $this->drive_init_resumable($filename, 'application/x-tar', $folder_id, $access_token);
        if (is_wp_error($session_uri)) {
            @unlink($tar['path']);
            return $session_uri;
        }

$upload_id = wp_generate_password(24, false);
        set_transient('hmsm_drive_up_' . $upload_id, array(
            'session_uri' => $session_uri,
            'temp_path'   => $tar['path'],
            'total'       => $tar['size'],
            'offset'      => 0,
            'filename'    => $filename,
        ), 6 * HOUR_IN_SECONDS);

return array('upload_id' => $upload_id, 'total' => $tar['size'], 'filename' => $filename);
    }

/**
     * ROUTE A — Continuar una subida: envía tramos del temporal a Drive hasta
     * agotar un presupuesto de tiempo (~240s), luego devuelve para que el
     * navegador vuelva a llamar. Al terminar borra el temporal.
     * Devuelve {done, offset, total, file_id?}.
     */
    public function drive_continue_upload($upload_id, $heartbeat = null) {
        $beat = is_callable($heartbeat) ? $heartbeat : function () {};
        $key  = 'hmsm_drive_up_' . $upload_id;
        $st   = get_transient($key);

if (!$st || empty($st['temp_path'])) {
            return new WP_Error('hmsm_upload_notfound', 'Sesión de subida no encontrada o expirada');
        }
        if (!file_exists($st['temp_path'])) {
            delete_transient($key);
            return new WP_Error('hmsm_temp_gone', 'El archivo temporal ya no existe');
        }

set_time_limit(0);
        $CHUNK  = 4 * 1024 * 1024;
        $BUDGET = 20; // seg por ronda: corto para que el front actualice la barra seguido
        $t0     = time();

$ch = curl_init();
        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
        curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2);
        $ca = ABSPATH . WPINC . '/certificates/ca-bundle.crt';
        if (file_exists($ca)) {
            curl_setopt($ch, CURLOPT_CAINFO, $ca);
        }

$fp = @fopen($st['temp_path'], 'rb');
        if (!$fp) {
            curl_close($ch);
            return new WP_Error('hmsm_temp_read', 'No se pudo leer el archivo temporal');
        }
        fseek($fp, (int) $st['offset']);

$offset  = (int) $st['offset'];
        $total   = (int) $st['total'];
        $file_id = null;

while ($offset < $total) {
            $piece = fread($fp, $CHUNK);
            $len   = strlen($piece);
            if ($len === 0) {
                break;
            }
            $is_last = ($offset + $len >= $total);
            $res = $this->drive_put_chunk($ch, $st['session_uri'], $piece, $offset, $is_last ? $total : null);
            if (is_wp_error($res)) {
                fclose($fp);
                curl_close($ch);
                // Fallo: borrar el temporal y el estado para no dejar GB colgados en disco
                @unlink($st['temp_path']);
                delete_transient($key);
                return $res;
            }
            $offset += $len;
            if ($is_last && is_array($res)) {
                $file_id = isset($res['id']) ? $res['id'] : null;
            }
            $beat();

if (!$is_last && (time() - $t0) >= $BUDGET) {
                break; // se acabó el presupuesto de esta ronda
            }
        }
        fclose($fp);
        curl_close($ch);

if ($offset >= $total) {
            @unlink($st['temp_path']);
            delete_transient($key);
            return array('done' => true, 'offset' => $total, 'total' => $total, 'file_id' => $file_id);
        }

// Guardar progreso para la próxima ronda
        $st['offset'] = $offset;
        set_transient($key, $st, 6 * HOUR_IN_SECONDS);
        return array('done' => false, 'offset' => $offset, 'total' => $total);
    }

/**
     * Generar el sitio completo (raíz) como .tar en un temporal protegido de la
     * cuenta (wp-content/uploads/hmsm-tmp, con .htaccess Deny porque el tar
     * incluye wp-config). Late durante la generación para no morir por timeout.
     * Devuelve array(path, size) o WP_Error.
     */
    private function create_full_tar_tempfile($beat) {
        $abspath = rtrim(ABSPATH, '/');
        $upload  = wp_upload_dir();
        $dir     = trailingslashit($upload['basedir']) . 'hmsm-tmp';

if (!is_dir($dir)) {
            wp_mkdir_p($dir);
        }
        if (!file_exists($dir . '/.htaccess')) {
            @file_put_contents($dir . '/.htaccess', "Deny from all\n");
        }
        if (!file_exists($dir . '/index.php')) {
            @file_put_contents($dir . '/index.php', "<?php // Silence is golden\n");
        }

// Limpiar temporales huérfanos de subidas abandonadas (> 6h). No usamos
        // disk_free_space porque en shared/CloudLinux es poco confiable (reporta
        // mal aunque haya espacio); si el disco se llena, la escritura falla sola.
        foreach ((glob($dir . '/backup-*.tar') ?: array()) as $old) {
            if (@filemtime($old) < time() - 6 * HOUR_IN_SECONDS) {
                @unlink($old);
            }
        }

$tmp = $dir . '/backup-' . wp_generate_password(20, false) . '.tar';
        set_time_limit(0);

// 1. tar del sistema vía proc_open (rápido), latiendo mientras trabaja
        if ($this->can_use_system_tar() && function_exists('proc_open')) {
            // --exclude evita que el tar se incluya a sí mismo: hmsm-tmp está DENTRO
            // de la raíz, y sin esto tar puede abortar (tar parcial) o entrar en bucle.
            $cmd = sprintf('tar -cf %s --exclude=%s --exclude=%s -C %s .',
                escapeshellarg($tmp),
                escapeshellarg('*/hmsm-tmp'),
                escapeshellarg('*/hmsm-tmp/*'),
                escapeshellarg($abspath));
            $descriptors = array(1 => array('pipe', 'w'), 2 => array('pipe', 'w'));
            $pipes = array();
            $proc  = @proc_open($cmd, $descriptors, $pipes);

if (is_resource($proc)) {
                if (isset($pipes[1])) { stream_set_blocking($pipes[1], false); }
                if (isset($pipes[2])) { stream_set_blocking($pipes[2], false); }
                $exitcode = 0;
                do {
                    $status = proc_get_status($proc);
                    if (isset($pipes[2])) { fread($pipes[2], 8192); } // drenar stderr
                    $beat();
                    if ($status['running']) {
                        usleep(500000);
                    } else {
                        $exitcode = $status['exitcode'];
                    }
                } while ($status['running']);

if (isset($pipes[1])) { fclose($pipes[1]); }
                if (isset($pipes[2])) { fclose($pipes[2]); }
                proc_close($proc);

clearstatcache(true, $tmp);
                // Aceptar SOLO si tar terminó OK (0) o con warnings benignos (1).
                // Exit >= 2 es error fatal → NO aceptar el tar parcial (evita
                // respaldos incompletos como el de 3MB).
                if ($exitcode <= 1 && file_exists($tmp) && filesize($tmp) > 0) {
                    return array('path' => $tmp, 'size' => filesize($tmp));
                }
                @unlink($tmp);
            }
        }

// 2. Fallback: tar en PHP puro al archivo, latiendo por archivo
        $fp = @fopen($tmp, 'wb');
        if (!$fp) {
            return new WP_Error('hmsm_write_failed', 'No se pudo crear el archivo temporal');
        }

$iterator = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator($abspath, RecursiveDirectoryIterator::SKIP_DOTS),
            RecursiveIteratorIterator::SELF_FIRST
        );

foreach ($iterator as $file) {
            if (!$file->isFile()) {
                continue;
            }
            $realpath = @$file->getRealPath();
            if ($realpath === false || !@is_readable($realpath)) {
                continue;
            }
            if (strpos($realpath, '/hmsm-tmp/') !== false) {
                continue; // no incluir temporales de respaldo (hmsm-tmp)
            }
            $relative = substr($realpath, strlen($abspath) + 1);
            if (empty($relative) || strlen($relative) > 255) {
                continue;
            }
            $size = @filesize($realpath);
            if ($size === false) {
                continue;
            }
            $header = $this->build_tar_header($relative, $size, @filemtime($realpath));
            if ($header === false) {
                continue;
            }

fwrite($fp, $header);
            $fh = @fopen($realpath, 'rb');
            if ($fh) {
                while (!feof($fh)) {
                    $chunk = fread($fh, 65536);
                    if ($chunk !== false && $chunk !== '') {
                        fwrite($fp, $chunk);
                    }
                }
                fclose($fh);
                $rem = $size % 512;
                if ($rem > 0) {
                    fwrite($fp, str_repeat("\0", 512 - $rem));
                }
            }
            $beat(); // latido por archivo
        }

fwrite($fp, str_repeat("\0", 1024));
        fclose($fp);

if (!file_exists($tmp) || filesize($tmp) === 0) {
            return new WP_Error('hmsm_backup_failed', 'No se generó el archivo de respaldo');
        }
        return array('path' => $tmp, 'size' => filesize($tmp));
    }

/**
     * Producir el tar de la raíz completa alimentando un callback $write($bytes).
     * Usa el tar del sistema vía proc_open (rápido) si está disponible; si no,
     * arma el tar en PHP puro. No usa archivos temporales ni acumula en memoria
     * (la lectura del pipe se autorregula con la velocidad de subida).
     */
    private function produce_tar_stream($abspath, $write) {
        // 1. tar del sistema vía proc_open (stdout en streaming)
        if ($this->can_use_system_tar() && function_exists('proc_open')) {
            $cmd         = sprintf('tar -cf - -C %s .', escapeshellarg($abspath));
            $descriptors = array(1 => array('pipe', 'w'), 2 => array('pipe', 'w'));
            $pipes       = array();
            $proc        = @proc_open($cmd, $descriptors, $pipes);

if (is_resource($proc)) {
                if (isset($pipes[1])) {
                    while (!feof($pipes[1])) {
                        $data = fread($pipes[1], 65536);
                        if ($data === false) {
                            break;
                        }
                        if ($data !== '') {
                            $write($data);
                        }
                    }
                    fclose($pipes[1]);
                }
                if (isset($pipes[2])) {
                    fclose($pipes[2]);
                }
                proc_close($proc);
                return true;
            }
        }

// 2. Fallback: tar en PHP puro
        $iterator = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator($abspath, RecursiveDirectoryIterator::SKIP_DOTS),
            RecursiveIteratorIterator::SELF_FIRST
        );

$write($header);

$fh = @fopen($realpath, 'rb');
            if ($fh) {
                while (!feof($fh)) {
                    $chunk = fread($fh, 65536);
                    if ($chunk !== false && $chunk !== '') {
                        $write($chunk);
                    }
                }
                fclose($fh);

$remainder = $size % 512;
                if ($remainder > 0) {
                    $write(str_repeat("\0", 512 - $remainder));
                }
            }
        }

// Fin del tar (dos bloques de 512 bytes en cero)
        $write(str_repeat("\0", 1024));
        return true;
    }

/**
     * Generar parte: archivos del sitio (themes + plugins + config) como .zip
     */
    private function generate_files_part($sitename, $date) {
        if (!class_exists('ZipArchive')) {
            return new WP_Error('hmsm_no_zip', 'ZipArchive no está disponible en este servidor');
        }

set_time_limit(600);

$tmp = sys_get_temp_dir() . '/hmsm_files_' . uniqid() . '.zip';
        $zip = new ZipArchive();

if ($zip->open($tmp, ZipArchive::CREATE | ZipArchive::OVERWRITE) !== true) {
            return new WP_Error('hmsm_zip_failed', 'No se pudo crear el archivo zip');
        }

// Themes
        $theme_root = get_theme_root();
        if (is_dir($theme_root)) {
            $this->add_dir_to_zip($zip, $theme_root, 'themes');
        }

// Plugins
        if (is_dir(WP_PLUGIN_DIR)) {
            $this->add_dir_to_zip($zip, WP_PLUGIN_DIR, 'plugins');
        }

// Config
        if (file_exists(ABSPATH . 'wp-config.php')) {
            $zip->addFile(ABSPATH . 'wp-config.php', 'wp-config.php');
        }
        if (file_exists(ABSPATH . '.htaccess')) {
            $zip->addFile(ABSPATH . '.htaccess', '.htaccess');
        }

$zip->close();

if (!file_exists($tmp)) {
            return new WP_Error('hmsm_backup_failed', 'No se generó el archivo zip');
        }

return array(
            'file'         => $tmp,
            'filename'     => "{$sitename}-files-{$date}.zip",
            'content_type' => 'application/zip',
            'filesize'     => filesize($tmp),
        );
    }

/**
     * Generar parte: uploads/media como .zip
     */
    private function generate_uploads_part($sitename, $date) {
        if (!class_exists('ZipArchive')) {
            return new WP_Error('hmsm_no_zip', 'ZipArchive no está disponible en este servidor');
        }

set_time_limit(600);

$upload_dir = wp_upload_dir();
        $basedir    = $upload_dir['basedir'];

if (!is_dir($basedir)) {
            return new WP_Error('hmsm_no_uploads', 'No se encontró el directorio de uploads');
        }

$tmp = sys_get_temp_dir() . '/hmsm_uploads_' . uniqid() . '.zip';
        $zip = new ZipArchive();

if ($zip->open($tmp, ZipArchive::CREATE | ZipArchive::OVERWRITE) !== true) {
            return new WP_Error('hmsm_zip_failed', 'No se pudo crear el archivo zip');
        }

$this->add_dir_to_zip($zip, $basedir, 'uploads');
        $zip->close();

if (!file_exists($tmp)) {
            return new WP_Error('hmsm_backup_failed', 'No se generó el archivo zip');
        }

return array(
            'file'         => $tmp,
            'filename'     => "{$sitename}-uploads-{$date}.zip",
            'content_type' => 'application/zip',
            'filesize'     => filesize($tmp),
        );
    }

/**
     * Streaming directo de archivos del sitio como tar.gz.
     * Intenta usar el comando tar del sistema; si no está disponible,
     * genera el tar.gz en PHP puro escribiendo directo a php://output.
     * No usa archivos temporales ni carga archivos completos en memoria.
     */
    public function stream_files_download() {
        $sitename = sanitize_title(get_bloginfo('name'));
        $date     = date('Y-m-d_H-i-s');
        $filename = "{$sitename}-files-{$date}.tar";
        $abspath  = rtrim(ABSPATH, '/');

set_time_limit(0);

// Intentar con comando tar del sistema (más rápido y confiable)
        if ($this->can_use_system_tar()) {
            $this->stream_with_system_tar($abspath, $filename);
            return;
        }

// Fallback: PHP puro streaming tar.gz
        $this->stream_with_php_tar($abspath, $filename);
    }

/**
     * Verificar si podemos usar tar del sistema
     */
    private function can_use_system_tar() {
        if (!function_exists('passthru') && !function_exists('proc_open')) {
            return false;
        }

if (function_exists('shell_exec')) {
            $tar_path = trim(shell_exec('which tar 2>/dev/null') ?: '');
            return !empty($tar_path);
        }

return false;
    }

/**
     * Streaming con tar del sistema
     */
    private function stream_with_system_tar($abspath, $filename) {
        @ini_set('display_errors', '0');
        error_reporting(0);

$this->clear_buffers();
        header('Content-Type: application/x-tar');
        header('Content-Disposition: attachment; filename="' . $filename . '"');
        header('Cache-Control: no-cache, must-revalidate');
        header('X-Accel-Buffering: no');

// Excluir nuestra carpeta de temporales (hmsm-tmp): no es data del sitio
        $cmd = sprintf('tar cf - --exclude=%s --exclude=%s -C %s .',
            escapeshellarg('*/hmsm-tmp'),
            escapeshellarg('*/hmsm-tmp/*'),
            escapeshellarg($abspath));
        passthru($cmd);
        exit;
    }

/**
     * Streaming tar en PHP puro — sin archivos temporales ni memoria.
     * Escribe formato tar directamente a php://output.
     * Sin compresión para máxima compatibilidad con cualquier hosting.
     */
    private function stream_with_php_tar($abspath, $filename) {
        @ini_set('display_errors', '0');
        error_reporting(0);

// Cambiar extensión a .tar (sin compresión)
        $filename = str_replace('.tar.gz', '.tar', $filename);

$fp = @fopen('php://output', 'wb');
        if (!$fp) {
            exit;
        }

$iterator = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator($abspath, RecursiveDirectoryIterator::SKIP_DOTS),
            RecursiveIteratorIterator::SELF_FIRST
        );

foreach ($iterator as $file) {
            if (!$file->isFile()) {
                continue;
            }

$realpath = @$file->getRealPath();
            if ($realpath === false || !@is_readable($realpath)) {
                continue;
            }
            if (strpos($realpath, '/hmsm-tmp/') !== false) {
                continue; // no incluir nuestros temporales
            }

$relative = substr($realpath, strlen($abspath) + 1);
            if (empty($relative) || strlen($relative) > 255) {
                continue;
            }

$size = @filesize($realpath);
            if ($size === false || $size === 0) {
                continue;
            }

$header = $this->build_tar_header($relative, $size, @filemtime($realpath));
            if ($header === false) {
                continue;
            }

// Escribir header
            fwrite($fp, $header);

// Escribir contenido en chunks de 64KB
            $fh = @fopen($realpath, 'rb');
            if ($fh) {
                while (!feof($fh)) {
                    $chunk = fread($fh, 65536);
                    if ($chunk !== false && $chunk !== '') {
                        fwrite($fp, $chunk);
                    }
                }
                fclose($fh);

// Padding a bloques de 512 bytes
                $remainder = $size % 512;
                if ($remainder > 0) {
                    fwrite($fp, str_repeat("\0", 512 - $remainder));
                }
            }
        }

// Fin del archivo tar
        fwrite($fp, str_repeat("\0", 1024));
        fclose($fp);
        exit;
    }

/**
     * Construir header de 512 bytes en formato tar POSIX (ustar).
     */
    private function build_tar_header($filename, $size, $mtime) {
        $prefix = '';
        $name   = $filename;

// Si el nombre > 100, dividir en prefix + name
        if (strlen($name) > 100) {
            $split = strrpos(substr($filename, 0, 155), '/');
            if ($split === false || strlen($filename) - $split - 1 > 100) {
                return false;
            }
            $prefix = substr($filename, 0, $split);
            $name   = substr($filename, $split + 1);
        }

// Header de 512 bytes — formato octal correcto para tar
        $header  = str_pad($name, 100, "\0");               // name (100)
        $header .= sprintf('%07o', 0100644) . "\0";          // mode (8)
        $header .= sprintf('%07o', 0) . "\0";                // uid (8)
        $header .= sprintf('%07o', 0) . "\0";                // gid (8)
        $header .= sprintf('%011o', $size) . "\0";            // size (12)
        $header .= sprintf('%011o', $mtime) . "\0";           // mtime (12)
        $header .= '        ';                                 // checksum placeholder (8)
        $header .= '0';                                        // typeflag (1)
        $header .= str_pad('', 100, "\0");                    // linkname (100)
        $header .= "ustar\0";                                 // magic (6)
        $header .= '00';                                       // version (2)
        $header .= str_pad('', 32, "\0");                     // uname (32)
        $header .= str_pad('', 32, "\0");                     // gname (32)
        $header .= str_pad('', 8, "\0");                      // devmajor (8)
        $header .= str_pad('', 8, "\0");                      // devminor (8)
        $header .= str_pad($prefix, 155, "\0");               // prefix (155)
        $header .= str_pad('', 12, "\0");                     // padding (12)

// Calcular checksum (suma de todos los bytes del header)
        $checksum = 0;
        for ($i = 0; $i < 512; $i++) {
            $checksum += ord($header[$i]);
        }
        $checksum_str = sprintf('%06o', $checksum) . "\0 ";
        $header = substr_replace($header, $checksum_str, 148, 8);

return $header;
    }

/**
     * Helper: agregar directorio recursivamente a PharData
     */
    private function add_directory_to_phar($phar, $dir, $prefix) {
        $dir = rtrim($dir, '/\\');
        $iterator = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator($dir, RecursiveDirectoryIterator::SKIP_DOTS)
        );

foreach ($iterator as $file) {
            if (!$file->isFile()) {
                continue;
            }
            $relative = $prefix . '/' . substr($file->getRealPath(), strlen($dir) + 1);
            try {
                $phar->addFile($file->getRealPath(), $relative);
            } catch (Exception $e) {
                continue;
            }
        }
    }

/**
     * Generar volcado SQL de todas las tablas de WordPress
     */
    private function generate_sql_dump() {
        global $wpdb;

set_time_limit(300);

$output  = "-- HM Site Monitor — Database Backup\n";
        $output .= "-- Sitio:   " . get_site_url() . "\n";
        $output .= "-- Fecha:   " . current_time('mysql') . "\n";
        $output .= "-- WP:      " . get_bloginfo('version') . "\n";
        $output .= "-- Base de datos: " . DB_NAME . "\n\n";
        $output .= "SET FOREIGN_KEY_CHECKS=0;\n";
        $output .= "SET SQL_MODE='NO_AUTO_VALUE_ON_ZERO';\n";
        $output .= "SET NAMES utf8mb4;\n\n";

$tables = $wpdb->get_col('SHOW TABLES');

foreach ($tables as $table) {
            $create  = $wpdb->get_row("SHOW CREATE TABLE `{$table}`", ARRAY_N);
            $output .= "DROP TABLE IF EXISTS `{$table}`;\n";
            $output .= $create[1] . ";\n\n";

$offset = 0;
            $batch  = 500;

if (empty($rows)) {
                    break;
                }

foreach ($rows as $row) {
                    $cols   = '`' . implode('`, `', array_keys($row)) . '`';
                    $values = implode(', ', array_map(function($val) use ($wpdb) {
                        if ($val === null) {
                            return 'NULL';
                        }
                        return "'" . $wpdb->_real_escape($val) . "'";
                    }, array_values($row)));

$output .= "INSERT INTO `{$table}` ({$cols}) VALUES ({$values});\n";
                }

$output .= "\n";
                $offset += $batch;
            }
        }

$output .= "SET FOREIGN_KEY_CHECKS=1;\n";

return $output;
    }

/**
     * Agregar directorio completo al zip de forma recursiva
     */
    private function add_dir_to_zip($zip, $dir, $zip_prefix) {
        if (!is_dir($dir)) {
            return;
        }

$dir      = rtrim($dir, '/\\');
        $iterator = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator($dir, RecursiveDirectoryIterator::SKIP_DOTS),
            RecursiveIteratorIterator::SELF_FIRST
        );

foreach ($iterator as $file) {
            $real_path     = $file->getRealPath();
            $relative_path = ($zip_prefix ? $zip_prefix . '/' : '') . substr($real_path, strlen($dir) + 1);

if ($file->isDir()) {
                $zip->addEmptyDir($relative_path);
            } else {
                $zip->addFile($real_path, $relative_path);
            }
        }
    }

/**
     * Enviar datos en memoria como descarga
     */
    private function send_data($data, $filename, $content_type) {
        $this->clear_buffers();

header('Content-Type: ' . $content_type);
        header('Content-Disposition: attachment; filename="' . $filename . '"');
        header('Content-Length: ' . strlen($data));
        header('Cache-Control: no-cache, must-revalidate');
        header('Pragma: no-cache');

echo $data;
        exit;
    }

/**
     * Devolver error en JSON antes de salir
     */
    private function send_json_error($message, $status = 500) {
        $this->clear_buffers();
        http_response_code($status);
        header('Content-Type: application/json');
        echo wp_json_encode(['success' => false, 'message' => $message]);
        exit;
    }

/**
     * Limpiar todos los buffers de salida activos
     */
    private function clear_buffers() {
        while (ob_get_level()) {
            ob_end_clean();
        }
    }
}

cmd: