@deinossrl/dgp-agent 1.4.39 → 1.4.41

package/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog - DGP Agent
+
+## [1.4.41] - 2026-01-12
+
+### Added
+- Soporte completo para comandos `pg_dump` desde la plataforma web
+- Integración con Supabase Storage para subir backups automáticamente
+- Nueva dependencia: `@supabase/supabase-js` v2.39.0
+
+### Fixed
+- Corregido schema de comandos: ahora busca en `dgp.agent_commands` correctamente
+- Agregados headers `Accept-Profile` y `Content-Profile` para acceso al schema dgp
+- URL de comandos actualizada de `dgp.agent_commands` a `agent_commands` con headers de schema
+
+### Changed
+- Mejorado manejo de comandos con soporte para múltiples schemas en Supabase
+
+## [1.4.40] - 2026-01-10
+
+### Previous Release
+- Funcionalidad base de reporte de estado Git
+- Comandos deploy, git_commit_push, test_connection
+- Integración con IA (Claude) para tareas automatizadas

package/index.mjs

@@ -25,9 +25,10 @@
 
 import { execSync, spawn, spawnSync } from 'child_process';
 import { hostname, homedir } from 'os';
-import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync, createWriteStream } from 'fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync, createWriteStream, statSync, unlinkSync } from 'fs';
 import { join, dirname } from 'path';
 import https from 'https';
+import { createClient } from '@supabase/supabase-js';
 
 // ============================================
 // CONFIG FILE MANAGEMENT
@@ -352,13 +353,13 @@ function getPlinkPath() {
 }
 
 // Versión del agente
-const AGENT_VERSION = '1.4.39';
+const AGENT_VERSION = '1.4.41';
 let AGENT_MODE = 'smart'; // Siempre inteligente
 
 // Configuración (prioridad: env vars > archivo config > platform config > defaults)
 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/dgp_agent_commands',
+  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.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImFzaXZheWhicnFlbm53aXd0dGRzIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjczMDAwOTcsImV4cCI6MjA4Mjg3NjA5N30.s3a7dR-dPkEXI7B2lUTUXU69923hhuX6meheNeo5EKA',
   interval: parseInt(process.env.DGP_INTERVAL || fileConfig.interval || '30', 10),
   commandPollInterval: parseInt(process.env.DGP_COMMAND_POLL_INTERVAL || fileConfig.commandPollInterval || '10', 10),
@@ -783,6 +784,8 @@ async function runAIMode() {
         headers: {
           'apikey': CONFIG.supabaseKey,
           'Authorization': `Bearer ${CONFIG.supabaseKey}`,
+          'Accept-Profile': 'dgp',
+          'Content-Profile': 'dgp',
         },
       });
 
@@ -887,6 +890,61 @@ function shell(command, options = {}) {
 // Alias para compatibilidad
 const shellSync = shell;
 
+/**
+ * Verifica si un error es recuperable (timeout, conexión, etc)
+ */
+function isRecoverableError(error) {
+  const msg = error.message.toLowerCase();
+  return (
+    msg.includes('timeout') ||
+    msg.includes('timed out') ||
+    msg.includes('connection refused') ||
+    msg.includes('network') ||
+    msg.includes('temporarily unavailable') ||
+    (error.code === 255 && msg.includes('ssh'))
+  );
+}
+
+/**
+ * Ejecuta un comando shell de forma asíncrona con reintentos automáticos
+ */
+async function shellAsyncWithRetry(command, options = {}, maxRetries = 3, baseDelay = 2000) {
+  let lastError;
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      logInfo(`[Attempt ${attempt}/${maxRetries}] Executing: ${command.substring(0, 80)}...`);
+      const result = await shellAsync(command, options);
+      if (attempt > 1) {
+        logSuccess(`✓ Command succeeded after ${attempt} attempts`);
+      }
+      return result;
+    } catch (error) {
+      lastError = error;
+
+      // Si no es recuperable, fallar inmediatamente
+      if (!isRecoverableError(error)) {
+        throw error;
+      }
+
+      // Si es el último intento, fallar
+      if (attempt === maxRetries) {
+        logError(`✗ Command failed after ${maxRetries} attempts`);
+        throw error;
+      }
+
+      // Calcular delay con backoff exponencial
+      const delay = baseDelay * Math.pow(2, attempt - 1);
+      log(`⚠️  Recoverable error (${error.message}), retrying in ${delay}ms...`, 'yellow');
+
+      // Esperar antes de reintentar
+      await new Promise(resolve => setTimeout(resolve, delay));
+    }
+  }
+
+  throw lastError;
+}
+
 /**
  * Ejecuta un comando shell de forma asíncrona con output en tiempo real
  */
@@ -1064,6 +1122,8 @@ async function getPendingCommands() {
     headers: {
       'apikey': CONFIG.supabaseKey,
       'Authorization': `Bearer ${CONFIG.supabaseKey}`,
+      'Accept-Profile': 'dgp',
+      'Content-Profile': 'dgp',
     },
   });
 
@@ -1115,6 +1175,8 @@ async function updateCommandLogs(commandId, logs) {
       'Authorization': `Bearer ${CONFIG.supabaseKey}`,
       'Content-Type': 'application/json',
       'Prefer': 'return=minimal',
+      'Accept-Profile': 'dgp',
+      'Content-Profile': 'dgp',
     },
     body: JSON.stringify({
       result: { logs: logs },
@@ -1225,10 +1287,10 @@ async function executeDeploy(command) {
       ? '/var/www/tenminuteia-prod/'
       : '/var/www/tenminuteia-staging/');
 
-    // Construir base del comando SSH
+    // Construir base del comando SSH con timeout largo para conexiones lentas
     const sshBase = sshKeyPath
-      ? `ssh -i ${sshKeyPath} -o StrictHostKeyChecking=no ${ssh_user}@${server_host}`
-      : `ssh ${ssh_user}@${server_host}`;
+      ? `ssh -i ${sshKeyPath} -o StrictHostKeyChecking=no -o ConnectTimeout=60 -o ServerAliveInterval=10 ${ssh_user}@${server_host}`
+      : `ssh -o ConnectTimeout=60 -o ServerAliveInterval=10 ${ssh_user}@${server_host}`;
 
     // Step 1: Git clone/pull on server
     currentStep = 'git_setup_server';
@@ -1240,7 +1302,7 @@ async function executeDeploy(command) {
     try {
       logInfo(`Attempting to update existing repository...`);
       const gitPullCmd = `${sshBase} "cd ${projectFolder} && git fetch origin && git checkout ${branch} && git pull origin ${branch}"`;
-      await shellAsync(gitPullCmd);
+      await shellAsyncWithRetry(gitPullCmd, {}, 5, 3000); // 5 reintentos, 3s base delay
       logSuccess(`Code updated on server`);
     } catch (pullError) {
       // Si falla el pull, probablemente el repo no existe
@@ -1260,7 +1322,7 @@ async function executeDeploy(command) {
       // Crear directorio padre y clonar
       const parentDir = projectFolder.substring(0, projectFolder.lastIndexOf('/'));
       const cloneCmd = `${sshBase} "mkdir -p ${parentDir} && git clone ${repoUrl} ${projectFolder} && cd ${projectFolder} && git checkout ${branch}"`;
-      await shellAsync(cloneCmd);
+      await shellAsyncWithRetry(cloneCmd, {}, 5, 3000); // 5 reintentos, 3s base delay
 
       logSuccess(`Repository cloned successfully`);
     }
@@ -1273,7 +1335,7 @@ async function executeDeploy(command) {
     steps.push({ step: currentStep, status: 'running' });
 
     const npmInstallCmd = `${sshBase} "cd ${projectFolder} && npm ci"`;
-    await shellAsync(npmInstallCmd);
+    await shellAsyncWithRetry(npmInstallCmd, {}, 3, 2000); // 3 reintentos, 2s base delay
 
     steps[steps.length - 1].status = 'success';
     logSuccess(`Dependencies installed on server`);
@@ -1284,7 +1346,7 @@ async function executeDeploy(command) {
     steps.push({ step: currentStep, status: 'running' });
 
     const npmBuildCmd = `${sshBase} "cd ${projectFolder} && npm run build"`;
-    await shellAsync(npmBuildCmd);
+    await shellAsyncWithRetry(npmBuildCmd, {}, 3, 2000); // 3 reintentos, 2s base delay
 
     steps[steps.length - 1].status = 'success';
     logSuccess(`Build completed on server`);
@@ -1295,7 +1357,7 @@ async function executeDeploy(command) {
     steps.push({ step: currentStep, status: 'running' });
 
     const reloadNginxCmd = `${sshBase} "sudo nginx -t && sudo systemctl reload nginx"`;
-    await shellAsync(reloadNginxCmd);
+    await shellAsyncWithRetry(reloadNginxCmd, {}, 3, 2000); // 3 reintentos, 2s base delay
 
     steps[steps.length - 1].status = 'success';
     logSuccess(`Nginx reloaded`);
@@ -1354,6 +1416,246 @@ async function executeDeploy(command) {
   }
 }
 
+/**
+ * Ejecuta pg_dump para crear backup de PostgreSQL
+ */
+async function executePgDump(command) {
+  const { id, params } = command;
+  const backupId = params.backup_id;
+  const environmentId = params.environment_id;
+
+  logCommand(`=== Ejecutando pg_dump (Backup) ===`);
+  logInfo(`Backup ID: ${backupId}`);
+  logInfo(`Environment ID: ${environmentId}`);
+
+  // Iniciar tracking de logs
+  currentCommandId = id;
+  commandLogs = [];
+
+  // Crear directorio para backups si no existe
+  const backupsDir = join(CONFIG_DIR, 'backups');
+  if (!existsSync(backupsDir)) {
+    mkdirSync(backupsDir, { recursive: true });
+  }
+
+  let localFilePath = null;
+  let storagePath = null;
+
+  try {
+    await updateCommandStatus(id, 'running', {});
+    await addCommandLog('info', 'Iniciando backup de base de datos...');
+
+    // Determinar extensión según formato
+    const format = params.format || 'custom';
+    const extension = format === 'custom' ? 'dump' : format === 'tar' ? 'tar' : 'sql';
+
+    // Generar nombre de archivo local
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+    const fileName = `backup_${environmentId}_${timestamp}.${extension}`;
+    localFilePath = join(backupsDir, fileName);
+
+    // Construir comando pg_dump
+    let pgDumpCmd = 'pg_dump';
+    const pgDumpArgs = [];
+
+    // Configurar conexión según tipo
+    if (params.connection_type === 'postgresql') {
+      // PostgreSQL genérico
+      pgDumpArgs.push(`--host=${params.host}`);
+      pgDumpArgs.push(`--port=${params.port || 5432}`);
+      pgDumpArgs.push(`--username=${params.username}`);
+      pgDumpArgs.push(`--dbname=${params.database}`);
+
+      // Si hay password, configurar PGPASSWORD
+      if (params.password_encrypted) {
+        // TODO: Desencriptar password si está encriptado
+        process.env.PGPASSWORD = params.password_encrypted;
+      }
+    } else {
+      // Supabase
+      const projectRef = params.project_ref;
+      pgDumpArgs.push(`--host=db.${projectRef}.supabase.co`);
+      pgDumpArgs.push(`--port=5432`);
+      pgDumpArgs.push(`--username=postgres`);
+      pgDumpArgs.push(`--dbname=postgres`);
+
+      // Para Supabase, necesitamos el service_role_key como password
+      if (params.service_role_key) {
+        process.env.PGPASSWORD = params.service_role_key;
+      }
+    }
+
+    // Opciones de formato
+    if (format === 'custom') {
+      pgDumpArgs.push('--format=custom');
+    } else if (format === 'tar') {
+      pgDumpArgs.push('--format=tar');
+    } else {
+      pgDumpArgs.push('--format=plain');
+    }
+
+    // Opciones de contenido
+    if (params.backup_type === 'schema') {
+      pgDumpArgs.push('--schema-only');
+    } else if (params.backup_type === 'data') {
+      pgDumpArgs.push('--data-only');
+    }
+
+    // Incluir opciones adicionales
+    if (params.include_privileges) {
+      pgDumpArgs.push('--no-privileges');
+    }
+    if (params.include_owner) {
+      pgDumpArgs.push('--no-owner');
+    }
+
+    // Schemas específicos
+    if (params.schemas && params.schemas.length > 0) {
+      params.schemas.forEach(schema => {
+        pgDumpArgs.push(`--schema=${schema}`);
+      });
+    }
+
+    // Tablas específicas
+    if (params.tables && params.tables.length > 0) {
+      params.tables.forEach(table => {
+        pgDumpArgs.push(`--table=${table}`);
+      });
+    }
+
+    // Archivo de salida
+    pgDumpArgs.push(`--file=${localFilePath}`);
+
+    // Ejecutar pg_dump
+    const fullCommand = `${pgDumpCmd} ${pgDumpArgs.join(' ')}`;
+    logCommand(`Ejecutando: pg_dump [conexión oculta]`);
+    await addCommandLog('command', 'Ejecutando pg_dump...');
+
+    await shellAsync(fullCommand);
+
+    // Verificar que el archivo se creó
+    if (!existsSync(localFilePath)) {
+      throw new Error('El archivo de backup no se generó correctamente');
+    }
+
+    const fileSize = statSync(localFilePath).size;
+    logSuccess(`Backup creado localmente (${(fileSize / 1024 / 1024).toFixed(2)} MB)`);
+    await addCommandLog('success', `Backup creado: ${(fileSize / 1024 / 1024).toFixed(2)} MB`);
+
+    // Subir a Supabase Storage
+    logInfo('Subiendo backup a Supabase Storage...');
+    await addCommandLog('info', 'Subiendo a Storage...');
+
+    const supabase = createClient(
+      CONFIG.apiUrl.replace('/functions/v1/dgp-agent-status', ''),
+      CONFIG.supabaseKey
+    );
+
+    // Usar storage_path de los params (ya definido en la DB)
+    storagePath = params.storage_path;
+    if (!storagePath) {
+      throw new Error('storage_path no definido en los parámetros');
+    }
+
+    // Leer archivo y subirlo
+    const fileBuffer = readFileSync(localFilePath);
+    const { data: uploadData, error: uploadError } = await supabase.storage
+      .from('database-backups')
+      .upload(storagePath, fileBuffer, {
+        contentType: format === 'sql' ? 'application/sql' : 'application/octet-stream',
+        upsert: false
+      });
+
+    if (uploadError) {
+      throw new Error(`Error subiendo a Storage: ${uploadError.message}`);
+    }
+
+    logSuccess(`Archivo subido a Storage: ${storagePath}`);
+    await addCommandLog('success', `Subido a: ${storagePath}`);
+
+    // Actualizar registro en db_backups
+    logInfo('Actualizando registro de backup...');
+    const { error: updateError } = await supabase
+      .schema('dgp')
+      .from('db_backups')
+      .update({
+        status: 'completed',
+        storage_path: storagePath,
+        size_bytes: fileSize,
+        completed_at: new Date().toISOString()
+      })
+      .eq('id', backupId);
+
+    if (updateError) {
+      logError(`Error actualizando registro: ${updateError.message}`);
+      await addCommandLog('error', `Error actualizando DB: ${updateError.message}`);
+    } else {
+      logSuccess('Registro de backup actualizado');
+      await addCommandLog('success', 'Backup registrado en DB');
+    }
+
+    // Limpiar archivo local (opcional)
+    try {
+      unlinkSync(localFilePath);
+      logInfo('Archivo local eliminado');
+    } catch (e) {
+      // Ignorar errores al eliminar
+    }
+
+    // Marcar comando como completado
+    await updateCommandStatus(id, 'completed', {
+      backup_id: backupId,
+      storage_path: storagePath,
+      size_bytes: fileSize,
+      local_path: localFilePath
+    });
+
+    console.log('');
+    logSuccess(`=== Backup completado exitosamente ===`);
+    console.log('');
+
+    return { success: true };
+
+  } catch (error) {
+    logError(`Backup 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 backup en DB
+    try {
+      const supabase = createClient(
+        CONFIG.apiUrl.replace('/functions/v1/dgp-agent-status', ''),
+        CONFIG.supabaseKey
+      );
+
+      await supabase
+        .schema('dgp')
+        .from('db_backups')
+        .update({
+          status: 'failed',
+          error_message: error.message
+        })
+        .eq('id', backupId);
+    } 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
@@ -1377,6 +1679,9 @@ async function executeCommand(command, useAI = false) {
     case 'test_connection':
       return await executeTestConnection(command);
 
+    case 'pg_dump':
+      return await executePgDump(command);
+
     case 'rollback':
       logError('Rollback not implemented yet');
       await updateCommandStatus(command.id, 'failed', {}, 'Rollback not implemented');
@@ -1907,6 +2212,8 @@ async function runAgent() {
         headers: {
           'apikey': CONFIG.supabaseKey,
           'Authorization': `Bearer ${CONFIG.supabaseKey}`,
+          'Accept-Profile': 'dgp',
+          'Content-Profile': 'dgp',
         },
       });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deinossrl/dgp-agent",
-  "version": "1.4.39",
+  "version": "1.4.41",
   "description": "Agente local para Despliegue-GPT - Reporta el estado del repositorio Git a la plataforma TenMinute IA",
   "main": "index.mjs",
   "bin": {
@@ -29,5 +29,8 @@
   "homepage": "https://github.com/DEINOS-SRL/tenminuteia#readme",
   "engines": {
     "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.39.0"
   }
 }