@deinossrl/dgp-agent 1.4.59 → 1.5.1

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog - DGP Agent
 
+## [1.5.1] - 2026-01-12
+
+### Changed
+- Actualizada ayuda (`dgp-agent help`) con documentación completa de backup/restore
+- Agregada sección detallada explicando auto-creación de schemas
+- Mejor descripción de capacidades del agente
+
+## [1.5.0] - 2026-01-12
+
+### Added
+- **Auto-creación de schemas en restore**: Detecta automáticamente qué schemas necesita el backup y los crea antes de restaurar
+- Agregado `psql.exe` a los binarios instalados (pg_dump, pg_restore, psql)
+- Detección robusta de schemas con 3 métodos:
+  1. `pg_restore --list` con múltiples patrones de búsqueda
+  2. Análisis directo del contenido del backup si --list falla
+  3. Fallback a parsing manual del archivo
+- Manejo inteligente de errores al crear schemas (ya existe, sin permisos, etc.)
+
+### Changed
+- Logs más detallados durante detección y creación de schemas
+- Mejor manejo de errores críticos vs warnings
+
+### Fixed
+- Restauraciones personalizadas ahora funcionan correctamente sin necesidad de crear schemas manualmente
+- Resuelve el problema de "schema does not exist" en backups selectivos
+
 ## [1.4.59] - 2026-01-12
 
 ### Added

package/index.mjs

@@ -1532,16 +1532,21 @@ async function findOrInstallPgDump() {
                     // 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
+                    // Copiar pg_dump.exe, pg_restore.exe y psql.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' });
                     }
 
+                    const extractedPsql = join(BIN_DIR, 'pgsql', 'bin', 'psql.exe');
+                    const localPsql = join(BIN_DIR, 'psql.exe');
+                    if (existsSync(extractedPsql)) {
+                      execSync(`copy "${extractedPsql}" "${localPsql}"`, { shell: 'cmd.exe' });
+                    }
+
                     // Copiar TODAS las DLLs (no solo algunas específicas)
                     execSync(`copy "${binSrcDir}\\*.dll" "${BIN_DIR}\\"`, { shell: 'cmd.exe' });
 
@@ -1582,16 +1587,21 @@ async function findOrInstallPgDump() {
                 if (existsSync(extractedPgDump)) {
                   const binSrcDir = join(BIN_DIR, 'pgsql', 'bin');
 
-                  // Copiar pg_dump.exe
+                  // Copiar pg_dump.exe, pg_restore.exe y psql.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' });
                   }
 
+                  const extractedPsql = join(BIN_DIR, 'pgsql', 'bin', 'psql.exe');
+                  const localPsql = join(BIN_DIR, 'psql.exe');
+                  if (existsSync(extractedPsql)) {
+                    execSync(`copy "${extractedPsql}" "${localPsql}"`, { shell: 'cmd.exe' });
+                  }
+
                   // Copiar TODAS las DLLs
                   execSync(`copy "${binSrcDir}\\*.dll" "${BIN_DIR}\\"`, { shell: 'cmd.exe' });
 
@@ -1958,7 +1968,155 @@ async function executePgRestore(command) {
       .update({ status: 'running', started_at: new Date().toISOString() })
       .eq('id', restore_id);
 
-    // Construir argumentos de pg_restore
+    // PASO 1: Detectar y crear schemas necesarios antes de restaurar
+    logInfo('Analizando backup para detectar schemas...');
+    await addCommandLog('info', 'Detectando schemas del backup...');
+
+    const schemas = new Set();
+
+    try {
+      // Usar pg_restore --list para ver el contenido del backup
+      const listResult = spawnSync(pgRestorePath, ['--list', localFilePath], {
+        env: process.env,
+        encoding: 'utf-8',
+        stdio: 'pipe',
+      });
+
+      if (listResult.status === 0 && listResult.stdout) {
+        const listOutput = listResult.stdout;
+
+        // Método 1: Buscar líneas con "SCHEMA - nombre"
+        const schemaLines = listOutput.match(/^\s*\d+;\s*\d+\s+\d+\s+SCHEMA\s+-\s+(\w+)/gm) || [];
+        schemaLines.forEach(line => {
+          const match = line.match(/SCHEMA\s+-\s+(\w+)/);
+          if (match && match[1] && match[1] !== 'public' && match[1] !== '-') {
+            schemas.add(match[1]);
+          }
+        });
+
+        // Método 2: Buscar referencias a schemas en tablas (ej: "TABLE - crm.quotes")
+        const tableLines = listOutput.match(/TABLE\s+-\s+(\w+)\./g) || [];
+        tableLines.forEach(line => {
+          const match = line.match(/TABLE\s+-\s+(\w+)\./);
+          if (match && match[1] && match[1] !== 'public') {
+            schemas.add(match[1]);
+          }
+        });
+
+        // Método 3: Buscar "SCHEMA COMMENT" o "ACL - SCHEMA"
+        const schemaRefs = listOutput.match(/(?:SCHEMA COMMENT|ACL - SCHEMA)\s+-\s+(\w+)/g) || [];
+        schemaRefs.forEach(line => {
+          const match = line.match(/(?:SCHEMA COMMENT|ACL - SCHEMA)\s+-\s+(\w+)/);
+          if (match && match[1] && match[1] !== 'public') {
+            schemas.add(match[1]);
+          }
+        });
+
+        logInfo(`pg_restore --list ejecutado correctamente`);
+      } else {
+        logInfo(`pg_restore --list no devolvió output, buscando en contenido del backup...`);
+      }
+
+      // Si no encontramos schemas con --list, parsear el archivo directamente
+      if (schemas.size === 0) {
+        try {
+          const backupContent = readFileSync(localFilePath, 'utf-8').substring(0, 500000); // Primeros 500KB
+
+          // Buscar patrones "schema.table" o "CREATE TABLE schema."
+          const schemaPatterns = [
+            /CREATE TABLE\s+(\w+)\./gi,
+            /INSERT INTO\s+(\w+)\./gi,
+            /ALTER TABLE\s+(\w+)\./gi,
+            /DROP.*ON\s+(\w+)\./gi,
+          ];
+
+          schemaPatterns.forEach(pattern => {
+            const matches = backupContent.matchAll(pattern);
+            for (const match of matches) {
+              if (match[1] && match[1] !== 'public' && match[1] !== 'pg_catalog') {
+                schemas.add(match[1]);
+              }
+            }
+          });
+
+          logInfo('Schemas detectados por análisis directo del backup');
+        } catch (parseError) {
+          logInfo(`No se pudo parsear directamente: ${parseError.message}`);
+        }
+      }
+
+    } catch (listError) {
+      logInfo(`Error en detección de schemas: ${listError.message}`);
+    }
+
+    // Crear los schemas detectados
+    if (schemas.size > 0) {
+      logInfo(`Schemas detectados: ${Array.from(schemas).join(', ')}`);
+      await addCommandLog('info', `Creando schemas: ${Array.from(schemas).join(', ')}`);
+
+      const psqlPath = pgRestorePath.replace('pg_restore', 'psql');
+      const psqlExe = psqlPath.replace('.exe', '') + '.exe';
+
+      // Verificar que psql existe
+      if (!existsSync(psqlExe)) {
+        logInfo('psql no disponible, schemas deben existir previamente');
+      } else {
+        // Crear cada schema
+        for (const schemaName of schemas) {
+          try {
+            const createSchemaSQL = `CREATE SCHEMA IF NOT EXISTS "${schemaName}";`;
+            const psqlArgs = [];
+
+            // Conexión (misma que pg_restore)
+            if (target_environment.connection_type === 'supabase') {
+              const projectRef = target_environment.supabase_project_ref;
+              psqlArgs.push(`--host=db.${projectRef}.supabase.co`);
+              psqlArgs.push(`--port=5432`);
+              psqlArgs.push(`--username=postgres`);
+              psqlArgs.push(`--dbname=postgres`);
+            } else if (target_environment.connection_type === 'postgresql') {
+              psqlArgs.push(`--host=${target_environment.db_host}`);
+              psqlArgs.push(`--port=${target_environment.db_port || 5432}`);
+              psqlArgs.push(`--username=${target_environment.db_user}`);
+              psqlArgs.push(`--dbname=${target_environment.db_name}`);
+            }
+
+            psqlArgs.push('--command', createSchemaSQL);
+            psqlArgs.push('--no-psqlrc'); // No cargar archivos de configuración
+            psqlArgs.push('--quiet'); // Silencioso
+
+            logInfo(`Creando schema: ${schemaName}`);
+
+            const createResult = spawnSync(psqlExe, psqlArgs, {
+              env: process.env,
+              encoding: 'utf-8',
+              stdio: 'pipe',
+            });
+
+            if (createResult.status === 0) {
+              logSuccess(`✓ Schema "${schemaName}" creado`);
+            } else {
+              const stderr = createResult.stderr || '';
+              if (stderr.includes('already exists')) {
+                logInfo(`✓ Schema "${schemaName}" ya existe`);
+              } else if (stderr.includes('permission denied')) {
+                logError(`✗ Sin permisos para crear schema "${schemaName}"`);
+                throw new Error(`No hay permisos para crear el schema "${schemaName}"`);
+              } else {
+                logInfo(`⚠ Schema "${schemaName}": ${stderr.substring(0, 200)}`);
+              }
+            }
+          } catch (schemaError) {
+            logError(`Error creando schema "${schemaName}": ${schemaError.message}`);
+            throw schemaError;
+          }
+        }
+      }
+    } else {
+      logInfo('No se detectaron schemas personalizados (solo public)');
+    }
+
+    // PASO 2: Construir argumentos de pg_restore
     const pgRestoreArgs = [];
 
     // Conexión
@@ -2906,6 +3064,24 @@ ${colors.bold}¿QUÉ HACE EL AGENTE?${colors.reset}
   ${colors.green}✓${colors.reset} Ejecuta comandos git (commit, push, pull, etc)
   ${colors.green}✓${colors.reset} Usa IA para interpretar tareas en lenguaje natural
   ${colors.green}✓${colors.reset} Mejora mensajes de commit automáticamente
+  ${colors.green}✓${colors.reset} ${colors.bold}Backup y restore de bases de datos PostgreSQL${colors.reset}
+  ${colors.green}✓${colors.reset} Auto-creación de schemas en restauraciones
+
+${colors.bold}BACKUP Y RESTORE DE BASES DE DATOS${colors.reset}
+  El agente puede crear backups y restaurar bases de datos PostgreSQL/Supabase:
+
+  ${colors.yellow}Backup:${colors.reset}
+    • Descarga PostgreSQL 17.2 automáticamente (primera vez)
+    • Crea backups con pg_dump (formato custom, tar o SQL)
+    • Sube a Supabase Storage automáticamente
+    • Soporta backups completos, por schema o por tabla
+
+  ${colors.yellow}Restore:${colors.reset}
+    • Descarga backup desde Storage
+    • ${colors.bold}Detecta y crea schemas automáticamente${colors.reset} (v1.5.0+)
+    • Ejecuta pg_restore con progreso en tiempo real
+    • Maneja warnings de DROP gracefully
+    • Continúa aunque objetos no existan previamente
 
 ${colors.bold}CONFIGURACIÓN${colors.reset}
   La API key de Claude se configura desde:

package/package.json

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