@deinossrl/dgp-agent 1.5.7 → 1.5.8

package/index.mjs

@@ -1787,19 +1787,47 @@ async function executePgDump(command) {
       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;
+      }
 
       // 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 lines = message.trim().split('\n');
-          const relevantLine = lines[lines.length - 1];
-          if (relevantLine.includes('processing') || relevantLine.includes('dumping') || relevantLine.includes('table')) {
-            addCommandLog('info', `pg_dump: ${relevantLine.substring(0, 100)}`).catch(() => {});
+          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;
           }
         }
@@ -1821,6 +1849,10 @@ async function executePgDump(command) {
           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();
         }
       });
@@ -2214,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...');
@@ -2227,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.7",
+  "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": {