@deinossrl/dgp-agent 1.4.53 → 1.4.55

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog - DGP Agent
 
+## [1.4.55] - 2026-01-12
+
+### Fixed
+- Ahora se copia `pg_restore.exe` junto con `pg_dump.exe` al instalar PostgreSQL
+- Resuelve error ENOENT al ejecutar comando de restore
+
+## [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

package/index.mjs

@@ -1519,12 +1519,19 @@ async function findOrInstallPgDump() {
                   const extractedPgDump = join(BIN_DIR, 'pgsql', 'bin', 'pg_dump.exe');
 
                   if (existsSync(extractedPgDump)) {
-                    // Copiar pg_dump.exe y TODAS las DLLs al BIN_DIR raíz
+                    // Copiar pg_dump.exe, pg_restore.exe y TODAS las DLLs al BIN_DIR raíz
                     const binSrcDir = join(BIN_DIR, 'pgsql', 'bin');
 
                     // Copiar pg_dump.exe
                     execSync(`copy "${extractedPgDump}" "${localPgDump}"`, { shell: 'cmd.exe' });
 
+                    // Copiar pg_restore.exe
+                    const extractedPgRestore = join(BIN_DIR, 'pgsql', 'bin', 'pg_restore.exe');
+                    const localPgRestore = join(BIN_DIR, 'pg_restore.exe');
+                    if (existsSync(extractedPgRestore)) {
+                      execSync(`copy "${extractedPgRestore}" "${localPgRestore}"`, { shell: 'cmd.exe' });
+                    }
+
                     // Copiar TODAS las DLLs (no solo algunas específicas)
                     execSync(`copy "${binSrcDir}\\*.dll" "${BIN_DIR}\\"`, { shell: 'cmd.exe' });
 
@@ -1568,6 +1575,13 @@ async function findOrInstallPgDump() {
                   // Copiar pg_dump.exe
                   execSync(`copy "${extractedPgDump}" "${localPgDump}"`, { shell: 'cmd.exe' });
 
+                  // Copiar pg_restore.exe
+                  const extractedPgRestore = join(BIN_DIR, 'pgsql', 'bin', 'pg_restore.exe');
+                  const localPgRestore = join(BIN_DIR, 'pg_restore.exe');
+                  if (existsSync(extractedPgRestore)) {
+                    execSync(`copy "${extractedPgRestore}" "${localPgRestore}"`, { shell: 'cmd.exe' });
+                  }
+
                   // Copiar TODAS las DLLs
                   execSync(`copy "${binSrcDir}\\*.dll" "${BIN_DIR}\\"`, { shell: 'cmd.exe' });
 
@@ -1872,6 +1886,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 +2113,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.53",
+  "version": "1.4.55",
   "description": "Agente local para Despliegue-GPT - Reporta el estado del repositorio Git a la plataforma TenMinute IA",
   "main": "index.mjs",
   "bin": {