@deinossrl/dgp-agent 1.4.40 → 1.4.42

package/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog - DGP Agent
+
+## [1.4.42] - 2026-01-12
+
+### Added
+- El agente ahora muestra su versión al iniciar
+- Versión leída automáticamente desde package.json (no hardcoded)
+- Versión visible en comando `dgp-agent status`
+
+### Changed
+- Mejorado display de información de versión en startup y status
+
+## [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,17 @@
 
 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 { fileURLToPath } from 'url';
 import https from 'https';
+import { createClient } from '@supabase/supabase-js';
+
+// Get version from package.json
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(__dirname, 'package.json'), 'utf-8'));
+const AGENT_VERSION = packageJson.version;
 
 // ============================================
 // CONFIG FILE MANAGEMENT
@@ -351,14 +359,12 @@ function getPlinkPath() {
   }
 }
 
-// Versión del agente
-const AGENT_VERSION = '1.4.40';
 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 +789,8 @@ async function runAIMode() {
         headers: {
           'apikey': CONFIG.supabaseKey,
           'Authorization': `Bearer ${CONFIG.supabaseKey}`,
+          'Accept-Profile': 'dgp',
+          'Content-Profile': 'dgp',
         },
       });
 
@@ -1119,6 +1127,8 @@ async function getPendingCommands() {
     headers: {
       'apikey': CONFIG.supabaseKey,
       'Authorization': `Bearer ${CONFIG.supabaseKey}`,
+      'Accept-Profile': 'dgp',
+      'Content-Profile': 'dgp',
     },
   });
 
@@ -1170,6 +1180,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 },
@@ -1409,6 +1421,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
@@ -1432,6 +1684,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');
@@ -1874,7 +2129,7 @@ async function executeGitCommitPush(command, useAI = false) {
 function printStatus(status) {
   console.log('');
   console.log(`${colors.blue}═══════════════════════════════════════════════════════${colors.reset}`);
-  console.log(`${colors.blue}  DGP Agent Status${colors.reset}`);
+  console.log(`${colors.blue}  DGP Agent Status v${AGENT_VERSION}${colors.reset}`);
   console.log(`${colors.blue}═══════════════════════════════════════════════════════${colors.reset}`);
   console.log(`  Machine:  ${colors.yellow}${CONFIG.machineId}${colors.reset}`);
   console.log(`  Branch:   ${colors.green}${status.branch}${colors.reset}`);
@@ -1927,6 +2182,7 @@ async function runAgent() {
     }
   }
 
+  logInfo(`DGP Agent v${AGENT_VERSION}`);
   logInfo(`Machine ID: ${CONFIG.machineId}`);
   logInfo(`IA: ${CONFIG.anthropicApiKey ? '✓ Habilitada' : '✗ No configurada'}`);
   logInfo(`Reporta cada ${CONFIG.interval}s | Escucha cada ${CONFIG.commandPollInterval}s`);
@@ -1962,6 +2218,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.40",
+  "version": "1.4.42",
   "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"
   }
 }