@deinossrl/dgp-agent 1.5.6 → 1.5.8

package/index.mjs

@@ -1770,24 +1770,93 @@ async function executePgDump(command) {
     // Archivo de salida
     pgDumpArgs.push(`--file=${localFilePath}`);
 
-    // Ejecutar pg_dump usando spawnSync directamente (evita problemas con espacios en rutas)
+    // Agregar --verbose para obtener información de progreso
+    pgDumpArgs.push('--verbose');
+
+    // Ejecutar pg_dump usando spawn para capturar progreso en tiempo real
     logCommand(`Ejecutando: pg_dump [conexión oculta]`);
     await addCommandLog('command', 'Ejecutando pg_dump...');
 
-    const result = spawnSync(pgDumpCmd, pgDumpArgs, {
-      env: process.env,
-      encoding: 'utf-8',
-      stdio: 'pipe',
-    });
+    // Usar spawn asíncrono para capturar progreso
+    await new Promise((resolve, reject) => {
+      const pgDumpProcess = spawn(pgDumpCmd, pgDumpArgs, {
+        env: process.env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
 
-    if (result.error) {
-      throw new Error(`Error ejecutando pg_dump: ${result.error.message}`);
-    }
+      let stderrBuffer = '';
+      let stdoutBuffer = '';
+      let lastLogTime = Date.now();
+      let objectCount = 0;
+      let totalEstimated = 0;
+
+      // Estimar total de objetos si se especificaron schemas/tables
+      if (params.tables && params.tables.length > 0) {
+        totalEstimated = params.tables.length;
+      } else if (params.schemas && params.schemas.length > 0) {
+        // Aproximado: ~20 objetos por schema (tablas, índices, secuencias, etc.)
+        totalEstimated = params.schemas.length * 20;
+      }
 
-    if (result.status !== 0) {
-      const errorMsg = result.stderr || result.stdout || 'Unknown error';
-      throw new Error(`pg_dump failed with code ${result.status}: ${errorMsg}`);
-    }
+      // Capturar stderr (pg_dump envía progreso aquí con --verbose)
+      pgDumpProcess.stderr.on('data', (data) => {
+        const message = data.toString();
+        stderrBuffer += message;
+
+        // Contar objetos procesados
+        const lines = message.split('\n');
+        for (const line of lines) {
+          if (line.includes('processing') || line.includes('dumping data for table') || line.includes('creating') || line.includes('setting owner')) {
+            objectCount++;
+          }
+        }
+
+        // Enviar log cada 2 segundos para no saturar
+        const now = Date.now();
+        if (now - lastLogTime > 2000) {
+          const relevantLine = lines[lines.length - 1].trim();
+          if (relevantLine && (relevantLine.includes('processing') || relevantLine.includes('dumping') || relevantLine.includes('table') || relevantLine.includes('creating'))) {
+            let progressMsg = '';
+
+            // Si tenemos estimación, mostrar porcentaje
+            if (totalEstimated > 0 && objectCount > 0) {
+              const percentage = Math.min(Math.round((objectCount / totalEstimated) * 100), 100);
+              progressMsg = `Progreso: ${percentage}% (${objectCount}/${totalEstimated}) - `;
+            } else if (objectCount > 0) {
+              progressMsg = `Objetos procesados: ${objectCount} - `;
+            }
+
+            progressMsg += relevantLine.substring(0, 80);
+            addCommandLog('info', progressMsg).catch(() => {});
+            lastLogTime = now;
+          }
+        }
+      });
+
+      // Capturar stdout (por si acaso)
+      pgDumpProcess.stdout.on('data', (data) => {
+        stdoutBuffer += data.toString();
+      });
+
+      // Manejar errores del proceso
+      pgDumpProcess.on('error', (error) => {
+        reject(new Error(`Error ejecutando pg_dump: ${error.message}`));
+      });
+
+      // Manejar finalización
+      pgDumpProcess.on('close', (code) => {
+        if (code !== 0) {
+          const errorMsg = stderrBuffer || stdoutBuffer || 'Unknown error';
+          reject(new Error(`pg_dump failed with code ${code}: ${errorMsg}`));
+        } else {
+          // Log final con total de objetos procesados
+          if (objectCount > 0) {
+            addCommandLog('success', `Backup completado: ${objectCount} objetos exportados`).catch(() => {});
+          }
+          resolve();
+        }
+      });
+    });
 
     // Verificar que el archivo se creó
     if (!existsSync(localFilePath)) {
@@ -2177,9 +2246,35 @@ async function executePgRestore(command) {
     pgRestoreArgs.push('--no-owner');
     pgRestoreArgs.push('--no-privileges');
 
+    // Agregar --verbose para obtener información de progreso
+    pgRestoreArgs.push('--verbose');
+
     // Archivo de entrada
     pgRestoreArgs.push(localFilePath);
 
+    // CALCULAR TOTAL DE OBJETOS para el porcentaje
+    let totalObjects = 0;
+    try {
+      const listResult = spawnSync(pgRestorePath, ['--list', localFilePath], {
+        env: process.env,
+        encoding: 'utf-8',
+        stdio: 'pipe',
+      });
+
+      if (listResult.status === 0 && listResult.stdout) {
+        // Contar líneas que representan objetos (excluir comentarios y líneas vacías)
+        const lines = listResult.stdout.split('\n').filter(line => {
+          const trimmed = line.trim();
+          return trimmed && !trimmed.startsWith(';') && /^\d+;/.test(trimmed);
+        });
+        totalObjects = lines.length;
+        logInfo(`Total de objetos a restaurar: ${totalObjects}`);
+        await addCommandLog('info', `Objetos a procesar: ${totalObjects}`);
+      }
+    } catch (e) {
+      logInfo('No se pudo contar objetos, continuando sin porcentaje...');
+    }
+
     // Ejecutar pg_restore con progreso en tiempo real
     logCommand(`Ejecutando: pg_restore [conexión oculta]`);
     await addCommandLog('command', 'Ejecutando pg_restore...');
@@ -2190,24 +2285,64 @@ async function executePgRestore(command) {
     const result = await new Promise((resolve, reject) => {
       const child = spawn(pgRestorePath, pgRestoreArgs, {
         env: process.env,
-        stdio: 'pipe',
+        stdio: ['ignore', 'pipe', 'pipe'],
       });
 
       let stdout = '';
       let stderr = '';
+      let processedObjects = 0;
+      let lastLogTime = Date.now();
 
       child.stdout.on('data', (data) => {
         stdout += data.toString();
       });
 
       child.stderr.on('data', (data) => {
-        stderr += data.toString();
+        const message = data.toString();
+        stderr += message;
+
+        // Contar objetos procesados buscando patrones como "processing item" o nombres de tablas
+        const lines = message.split('\n');
+        for (const line of lines) {
+          if (line.includes('processing') || line.includes('creating') || line.includes('restoring')) {
+            processedObjects++;
+
+            // Enviar log cada 2 segundos para no saturar
+            const now = Date.now();
+            if (now - lastLogTime > 2000) {
+              let progressMsg = '';
+
+              if (totalObjects > 0) {
+                const percentage = Math.min(Math.round((processedObjects / totalObjects) * 100), 100);
+                progressMsg = `Progreso: ${percentage}% (${processedObjects}/${totalObjects})`;
+              } else {
+                progressMsg = `Objetos procesados: ${processedObjects}`;
+              }
+
+              // Agregar detalle de lo que se está procesando
+              const relevantLine = line.substring(0, 100).trim();
+              if (relevantLine) {
+                progressMsg += ` - ${relevantLine}`;
+              }
+
+              addCommandLog('info', progressMsg).catch(() => {});
+              lastLogTime = now;
+            }
+          }
+        }
       });
 
-      // Mostrar progreso cada 10 segundos
+      // Mostrar progreso por tiempo cada 10 segundos como respaldo
       progressInterval = setInterval(() => {
         const elapsed = Math.floor((Date.now() - startTime) / 1000);
-        logInfo(`Restaurando... (${elapsed}s transcurridos)`);
+        if (Date.now() - lastLogTime > 10000) { // Solo si no se ha logueado recientemente
+          let msg = `Restaurando... (${elapsed}s transcurridos)`;
+          if (totalObjects > 0 && processedObjects > 0) {
+            const percentage = Math.min(Math.round((processedObjects / totalObjects) * 100), 100);
+            msg += ` - ${percentage}%`;
+          }
+          logInfo(msg);
+        }
       }, 10000);
 
       child.on('error', (error) => {

package/package.json

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