@deinossrl/dgp-agent 1.4.52 → 1.4.54

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog - DGP Agent
 
+## [1.4.54] - 2026-01-12
+
+### Added
+- Implementado comando `pg_restore` para restaurar bases de datos desde backups
+- Descarga automática de backups desde Supabase Storage
+- Soporte para restauración completa, solo esquema, o solo datos
+- Actualización automática de estado en tabla `db_restores`
+
+### Changed
+- `pg_restore` viene incluido con pg_dump (mismo binario de PostgreSQL)
+- Limpieza automática de archivos temporales después de restore
+
+## [1.4.53] - 2026-01-12
+
+### Fixed
+- Actualizado service_role key con el correcto desde Supabase Dashboard
+- Resuelve error 401 "Invalid API key" al hacer polling de comandos
+- Ahora puede subir backups a Storage sin errores de RLS
+
 ## [1.4.52] - 2026-01-12
 
 ### Fixed

package/index.mjs

@@ -366,7 +366,7 @@ let AGENT_MODE = 'smart'; // Siempre inteligente
 const CONFIG = {
   apiUrl: process.env.DGP_API_URL || fileConfig.apiUrl || 'https://asivayhbrqennwiwttds.supabase.co/functions/v1/dgp-agent-status',
   commandsUrl: process.env.DGP_COMMANDS_URL || fileConfig.commandsUrl || 'https://asivayhbrqennwiwttds.supabase.co/rest/v1/agent_commands',
-  supabaseKey: process.env.DGP_SUPABASE_KEY || fileConfig.supabaseKey || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImFzaXZheWhicnFlbm53aXd0dGRzIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTcyMjU1Mzc3MCwiZXhwIjoyMDM4MTI5NzcwfQ.r7RM4wXOQN4b7QMeHEw5U0y_l3dPZc8b0a7vp7_PBpQ',
+  supabaseKey: process.env.DGP_SUPABASE_KEY || fileConfig.supabaseKey || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImFzaXZheWhicnFlbm53aXd0dGRzIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTc2NzMwMDA5NywiZXhwIjoyMDgyODc2MDk3fQ.53h-WsRtVxJ5ZkquHNAYbWJ-keQotmTJwKsYjcZhmIE',
   interval: parseInt(process.env.DGP_INTERVAL || fileConfig.interval || '30', 10),
   commandPollInterval: parseInt(process.env.DGP_COMMAND_POLL_INTERVAL || fileConfig.commandPollInterval || '10', 10),
   machineId: process.env.DGP_MACHINE_ID || fileConfig.machineId || `${hostname()}-${process.env.USERNAME || process.env.USER || 'dev'}`,
@@ -1872,6 +1872,207 @@ async function executePgDump(command) {
   }
 }
 
+/**
+ * Ejecuta pg_restore para restaurar una base de datos desde un backup
+ * @param {Object} command - El comando con params de restore
+ */
+async function executePgRestore(command) {
+  const { id, params } = command;
+  const { restore_id, backup_storage_path, target_environment, restore_type, clean_before_restore } = params;
+
+  let localFilePath = null;
+
+  try {
+    console.log('');
+    logInfo(`=== Ejecutando pg_restore (Restauración) ===`);
+    await addCommandLog('info', 'Iniciando restore...');
+
+    // Verificar que pg_restore esté disponible
+    const pgRestoreCmd = await findOrInstallPgDump(); // Usa la misma función, pg_restore viene con pg_dump
+    if (!pgRestoreCmd) {
+      throw new Error('pg_restore no está disponible');
+    }
+
+    const pgRestorePath = pgRestoreCmd.replace('pg_dump', 'pg_restore');
+    logInfo(`Usando pg_restore: ${pgRestorePath}`);
+
+    // Descargar backup desde Storage
+    logInfo(`Descargando backup desde Storage: ${backup_storage_path}`);
+    await addCommandLog('info', `Descargando backup: ${backup_storage_path}`);
+
+    const supabase = createClient(
+      CONFIG.apiUrl.replace('/functions/v1/dgp-agent-status', ''),
+      CONFIG.supabaseKey
+    );
+
+    const { data: fileData, error: downloadError } = await supabase.storage
+      .from('database-backups')
+      .download(backup_storage_path);
+
+    if (downloadError) {
+      throw new Error(`Error descargando backup: ${downloadError.message}`);
+    }
+
+    // Guardar temporalmente
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+    const tempFileName = `restore_${timestamp}.dump`;
+    localFilePath = join(BIN_DIR, tempFileName);
+
+    // Convertir Blob a Buffer y guardar
+    const arrayBuffer = await fileData.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    writeFileSync(localFilePath, buffer);
+
+    const fileSize = statSync(localFilePath).size;
+    logSuccess(`Backup descargado (${(fileSize / 1024 / 1024).toFixed(2)} MB)`);
+    await addCommandLog('success', `Backup descargado: ${(fileSize / 1024 / 1024).toFixed(2)} MB`);
+
+    // Marcar restore como running
+    await supabase
+      .schema('dgp')
+      .from('db_restores')
+      .update({ status: 'running', started_at: new Date().toISOString() })
+      .eq('id', restore_id);
+
+    // Construir argumentos de pg_restore
+    const pgRestoreArgs = [];
+
+    // Conexión
+    if (target_environment.connection_type === 'supabase') {
+      const projectRef = target_environment.supabase_project_ref;
+      pgRestoreArgs.push(`--host=db.${projectRef}.supabase.co`);
+      pgRestoreArgs.push(`--port=5432`);
+      pgRestoreArgs.push(`--username=postgres`);
+      pgRestoreArgs.push(`--dbname=postgres`);
+
+      // Service role key como password
+      if (target_environment.metadata?.service_role_key) {
+        process.env.PGPASSWORD = target_environment.metadata.service_role_key;
+      }
+    } else if (target_environment.connection_type === 'postgresql') {
+      pgRestoreArgs.push(`--host=${target_environment.db_host}`);
+      pgRestoreArgs.push(`--port=${target_environment.db_port || 5432}`);
+      pgRestoreArgs.push(`--username=${target_environment.db_user}`);
+      pgRestoreArgs.push(`--dbname=${target_environment.db_name}`);
+
+      if (target_environment.db_password_encrypted || target_environment.metadata?.password) {
+        process.env.PGPASSWORD = target_environment.db_password_encrypted || target_environment.metadata.password;
+      }
+    }
+
+    // Opciones de restore
+    if (clean_before_restore) {
+      pgRestoreArgs.push('--clean');
+    }
+
+    if (restore_type === 'schema_only') {
+      pgRestoreArgs.push('--schema-only');
+    } else if (restore_type === 'data_only') {
+      pgRestoreArgs.push('--data-only');
+    }
+
+    // No detener en errores (útil para restauraciones parciales)
+    pgRestoreArgs.push('--exit-on-error');
+    pgRestoreArgs.push('--no-owner');
+    pgRestoreArgs.push('--no-privileges');
+
+    // Archivo de entrada
+    pgRestoreArgs.push(localFilePath);
+
+    // Ejecutar pg_restore
+    logCommand(`Ejecutando: pg_restore [conexión oculta]`);
+    await addCommandLog('command', 'Ejecutando pg_restore...');
+
+    const result = spawnSync(pgRestorePath, pgRestoreArgs, {
+      env: process.env,
+      encoding: 'utf-8',
+      stdio: 'pipe',
+    });
+
+    if (result.error) {
+      throw new Error(`Error ejecutando pg_restore: ${result.error.message}`);
+    }
+
+    if (result.status !== 0) {
+      const errorMsg = result.stderr || result.stdout || 'Unknown error';
+      throw new Error(`pg_restore failed with code ${result.status}: ${errorMsg}`);
+    }
+
+    logSuccess('Restauración completada');
+    await addCommandLog('success', 'Base de datos restaurada');
+
+    // Actualizar estado en DB
+    await supabase
+      .schema('dgp')
+      .from('db_restores')
+      .update({
+        status: 'completed',
+        completed_at: new Date().toISOString()
+      })
+      .eq('id', restore_id);
+
+    logSuccess('Registro de restore actualizado');
+
+    // Limpiar archivo local
+    try {
+      unlinkSync(localFilePath);
+      logInfo('Archivo temporal eliminado');
+    } catch (e) {
+      // Ignorar
+    }
+
+    // Marcar comando como completado
+    await updateCommandStatus(id, 'completed', {
+      restore_id: restore_id,
+      restored_from: backup_storage_path
+    });
+
+    console.log('');
+    logSuccess(`=== Restauración completada exitosamente ===`);
+    console.log('');
+
+    return { success: true };
+
+  } catch (error) {
+    logError(`Restore failed: ${error.message}`);
+    await addCommandLog('error', error.message);
+
+    // Limpiar archivo local si existe
+    if (localFilePath && existsSync(localFilePath)) {
+      try {
+        unlinkSync(localFilePath);
+      } catch (e) {
+        // Ignorar
+      }
+    }
+
+    // Actualizar estado del restore en DB
+    try {
+      const supabase = createClient(
+        CONFIG.apiUrl.replace('/functions/v1/dgp-agent-status', ''),
+        CONFIG.supabaseKey
+      );
+
+      await supabase
+        .schema('dgp')
+        .from('db_restores')
+        .update({
+          status: 'failed',
+          error_message: error.message
+        })
+        .eq('id', restore_id);
+    } catch (e) {
+      // Ignorar errores al actualizar
+    }
+
+    await updateCommandStatus(id, 'failed', {}, error.message);
+    return { success: false, error: error.message };
+  } finally {
+    // Limpiar variables de entorno
+    delete process.env.PGPASSWORD;
+  }
+}
+
 /**
  * Ejecuta un comando recibido
  * @param {Object} command - El comando a ejecutar
@@ -1898,6 +2099,9 @@ async function executeCommand(command, useAI = false) {
     case 'pg_dump':
       return await executePgDump(command);
 
+    case 'pg_restore':
+      return await executePgRestore(command);
+
     case 'rollback':
       logError('Rollback not implemented yet');
       await updateCommandStatus(command.id, 'failed', {}, 'Rollback not implemented');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deinossrl/dgp-agent",
-  "version": "1.4.52",
+  "version": "1.4.54",
   "description": "Agente local para Despliegue-GPT - Reporta el estado del repositorio Git a la plataforma TenMinute IA",
   "main": "index.mjs",
   "bin": {