@deinossrl/dgp-agent 1.4.16 → 1.4.20

package/index.mjs

@@ -203,7 +203,7 @@ async function fetchPlatformConfig() {
 let platformConfig = null;
 
 // Versión del agente
-const AGENT_VERSION = '1.4.16';
+const AGENT_VERSION = '1.4.20';
 let AGENT_MODE = 'smart'; // Siempre inteligente
 
 // Configuración (prioridad: env vars > archivo config > platform config > defaults)
@@ -953,11 +953,12 @@ async function addCommandLog(type, message) {
 }
 
 /**
- * Actualiza los logs de un comando en la DB
+ * Actualiza los logs de un comando en la DB (guarda en result.logs)
  */
 async function updateCommandLogs(commandId, logs) {
   const url = `${CONFIG.commandsUrl}?id=eq.${commandId}`;
 
+  // Guardar en result para que la web lo lea
   await fetch(url, {
     method: 'PATCH',
     headers: {
@@ -967,7 +968,7 @@ async function updateCommandLogs(commandId, logs) {
       'Prefer': 'return=minimal',
     },
     body: JSON.stringify({
-      logs: logs,
+      result: { logs: logs },
       updated_at: new Date().toISOString(),
     }),
   });
@@ -1016,12 +1017,28 @@ async function updateCommandStatus(commandId, status, result = {}, errorMessage
  * Ejecuta un comando de deploy
  */
 async function executeDeploy(command) {
-  const { id, environment, branch, server_host, ssh_user, deploy_url } = command;
+  const { id, environment, branch, server_host, ssh_user, deploy_url, params } = command;
+  const sshPrivateKey = params?.ssh_private_key || null;
 
   logCommand(`=== Executing Deploy Command ===`);
   logInfo(`Environment: ${environment}`);
   logInfo(`Branch: ${branch}`);
   logInfo(`Server: ${ssh_user}@${server_host}`);
+  if (sshPrivateKey) {
+    logInfo(`SSH Key: Configurada desde plataforma`);
+  }
+
+  // Si hay SSH key, guardarla en archivo temporal
+  let sshKeyPath = null;
+  let sshOptions = '';
+  if (sshPrivateKey) {
+    const os = await import('os');
+    const fs = await import('fs');
+    const path = await import('path');
+    sshKeyPath = path.join(os.tmpdir(), `dgp_deploy_key_${Date.now()}`);
+    fs.writeFileSync(sshKeyPath, sshPrivateKey, { mode: 0o600 });
+    sshOptions = `-e "ssh -i ${sshKeyPath} -o StrictHostKeyChecking=no"`;
+  }
 
   const steps = [];
   let currentStep = '';
@@ -1071,8 +1088,11 @@ async function executeDeploy(command) {
       ? '/var/www/tenminuteia-prod/'
       : '/var/www/tenminuteia-staging/';
 
-    // Rsync the dist folder
-    await shellAsync(`rsync -avz --delete dist/ ${ssh_user}@${server_host}:${deployFolder}`);
+    // Rsync the dist folder (con SSH key si disponible)
+    const rsyncCmd = sshOptions
+      ? `rsync -avz --delete ${sshOptions} dist/ ${ssh_user}@${server_host}:${deployFolder}`
+      : `rsync -avz --delete dist/ ${ssh_user}@${server_host}:${deployFolder}`;
+    await shellAsync(rsyncCmd);
 
     steps[steps.length - 1].status = 'success';
     logSuccess(`Files deployed to ${server_host}:${deployFolder}`);
@@ -1082,7 +1102,11 @@ async function executeDeploy(command) {
     logCommand(`[5/5] Reloading Nginx...`);
     steps.push({ step: currentStep, status: 'running' });
 
-    await shellAsync(`ssh ${ssh_user}@${server_host} "sudo nginx -t && sudo systemctl reload nginx"`);
+    // SSH con key si disponible
+    const sshCmd = sshKeyPath
+      ? `ssh -i ${sshKeyPath} -o StrictHostKeyChecking=no ${ssh_user}@${server_host} "sudo nginx -t && sudo systemctl reload nginx"`
+      : `ssh ${ssh_user}@${server_host} "sudo nginx -t && sudo systemctl reload nginx"`;
+    await shellAsync(sshCmd);
 
     steps[steps.length - 1].status = 'success';
     logSuccess(`Nginx reloaded`);
@@ -1105,6 +1129,15 @@ async function executeDeploy(command) {
     // Mark as success
     await updateCommandStatus(id, 'success', { steps, deploy_url });
 
+    // Limpiar SSH key temporal
+    if (sshKeyPath) {
+      try {
+        const fs = await import('fs');
+        fs.unlinkSync(sshKeyPath);
+        logInfo('SSH key temporal eliminada');
+      } catch (e) { /* ignorar */ }
+    }
+
     console.log('');
     logSuccess(`=== Deploy to ${environment} completed successfully! ===`);
     console.log('');
@@ -1120,6 +1153,14 @@ async function executeDeploy(command) {
 
     await updateCommandStatus(id, 'failed', { steps }, error.message);
 
+    // Limpiar SSH key temporal
+    if (sshKeyPath) {
+      try {
+        const fs = await import('fs');
+        fs.unlinkSync(sshKeyPath);
+      } catch (e) { /* ignorar */ }
+    }
+
     return { success: false, error: error.message };
   }
 }
@@ -1144,6 +1185,9 @@ async function executeCommand(command, useAI = false) {
     case 'git_commit_push':
       return await executeGitCommitPush(command, useAI);
 
+    case 'test_connection':
+      return await executeTestConnection(command);
+
     case 'rollback':
       logError('Rollback not implemented yet');
       await updateCommandStatus(command.id, 'failed', {}, 'Rollback not implemented');
@@ -1165,6 +1209,241 @@ async function executeCommand(command, useAI = false) {
   }
 }
 
+/**
+ * Analiza un error de conexión con IA y sugiere soluciones
+ */
+async function analyzeConnectionErrorWithAI(error, context) {
+  if (!CONFIG.anthropicApiKey) {
+    return null;
+  }
+
+  const systemPrompt = `Eres un experto en DevOps y administración de servidores.
+Analiza el error de conexión y proporciona:
+1. Un diagnóstico claro del problema
+2. Posibles causas
+3. Pasos para solucionarlo
+
+Responde en español, de forma concisa y práctica.
+Responde SOLO con JSON válido:
+{
+  "diagnosis": "explicación breve del problema",
+  "causes": ["causa 1", "causa 2"],
+  "solutions": ["solución 1", "solución 2"],
+  "next_steps": "qué hacer primero"
+}`;
+
+  const prompt = `Error de conexión SSH:
+- Host: ${context.host}
+- Usuario: ${context.user}
+- Error: ${error}
+- Ping exitoso: ${context.pingOk ? 'Sí' : 'No'}
+- Latencia ping: ${context.pingLatency || 'N/A'}ms
+
+Analiza este error y sugiere soluciones.`;
+
+  try {
+    const response = await callClaude(prompt, systemPrompt);
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+  } catch (e) {
+    // Silently fail
+  }
+  return null;
+}
+
+/**
+ * Ejecuta test de conexión SSH a un servidor (con IA para diagnóstico)
+ */
+async function executeTestConnection(command) {
+  const { server_host, ssh_user, params } = command;
+  const sshPrivateKey = params?.ssh_private_key || null;
+
+  logCommand(`=== Testing SSH Connection ===`);
+  logInfo(`Target: ${ssh_user || 'root'}@${server_host}`);
+
+  // Iniciar tracking de logs
+  currentCommandId = command.id;
+  commandLogs = [];
+
+  try {
+    await updateCommandStatus(command.id, 'running', {});
+    await addCommandLog('info', `Probando conexión a ${server_host}...`);
+
+    const results = {
+      ping: { success: false, latency: null, error: null },
+      ssh: { success: false, error: null, hostname: null, user: null },
+      ai_diagnosis: null,
+    };
+
+    // Step 1: Ping test
+    logInfo('Step 1: Testing network connectivity (ping)...');
+    await addCommandLog('command', `ping ${server_host}`);
+
+    try {
+      const isWindows = process.platform === 'win32';
+      const pingCmd = isWindows ? `ping -n 2 -w 5000 ${server_host}` : `ping -c 2 -W 5 ${server_host}`;
+      const pingResult = shellSync(pingCmd);
+
+      // Extraer latencia
+      const latencyMatch = pingResult.match(/tiempo[=<](\d+)ms|time[=<](\d+(?:\.\d+)?)\s*ms/i);
+      if (latencyMatch) {
+        results.ping.latency = parseFloat(latencyMatch[1] || latencyMatch[2]);
+      }
+
+      results.ping.success = true;
+      logSuccess(`Ping OK (${results.ping.latency || '?'}ms)`);
+      await addCommandLog('success', `Ping exitoso - Latencia: ${results.ping.latency || '?'}ms`);
+    } catch (e) {
+      results.ping.error = e.message;
+      logError(`Ping failed: ${e.message}`);
+      await addCommandLog('error', `Ping falló: ${e.message}`);
+    }
+
+    // Step 2: SSH test
+    logInfo('Step 2: Testing SSH connection...');
+
+    // Si hay SSH key, guardarla en archivo temporal
+    let sshKeyPath = null;
+    if (sshPrivateKey) {
+      const os = await import('os');
+      const fs = await import('fs');
+      const path = await import('path');
+      sshKeyPath = path.join(os.tmpdir(), `dgp_test_key_${Date.now()}`);
+      fs.writeFileSync(sshKeyPath, sshPrivateKey, { mode: 0o600 });
+      logInfo('SSH Key: Usando clave desde plataforma');
+      await addCommandLog('info', 'Usando SSH key configurada en la plataforma');
+    }
+
+    const user = ssh_user || 'root';
+    const sshOpts = sshKeyPath
+      ? `-i ${sshKeyPath} -o StrictHostKeyChecking=no -o ConnectTimeout=10 -o BatchMode=yes`
+      : `-o StrictHostKeyChecking=no -o ConnectTimeout=10 -o BatchMode=yes`;
+
+    const sshCmd = `ssh ${sshOpts} ${user}@${server_host} "echo 'SSH_OK' && hostname && whoami"`;
+    await addCommandLog('command', `ssh ${user}@${server_host} "hostname && whoami"`);
+
+    try {
+      const sshResult = shellSync(sshCmd);
+      const lines = sshResult.split('\n').filter(Boolean);
+
+      if (lines[0] === 'SSH_OK') {
+        results.ssh.success = true;
+        results.ssh.hostname = lines[1] || 'unknown';
+        results.ssh.user = lines[2] || user;
+
+        logSuccess(`SSH OK - Connected as ${results.ssh.user}@${results.ssh.hostname}`);
+        await addCommandLog('success', `Conexión SSH exitosa`);
+        await addCommandLog('output', `Hostname: ${results.ssh.hostname}`);
+        await addCommandLog('output', `Usuario: ${results.ssh.user}`);
+      } else {
+        results.ssh.error = 'Unexpected response';
+        await addCommandLog('error', 'Respuesta inesperada del servidor');
+      }
+    } catch (e) {
+      results.ssh.error = e.message;
+
+      // Analizar el error para dar mejor feedback
+      let errorDescription = '';
+      if (e.message.includes('Permission denied')) {
+        errorDescription = 'Permiso denegado: La clave SSH no es válida o no está autorizada en el servidor';
+        logError('SSH failed: Permission denied (clave SSH incorrecta o no autorizada)');
+      } else if (e.message.includes('Connection timed out') || e.message.includes('timed out')) {
+        errorDescription = 'Timeout: El puerto 22 está bloqueado o el servidor no es accesible por SSH';
+        logError('SSH failed: Connection timed out (puerto 22 bloqueado o servidor no accesible)');
+      } else if (e.message.includes('Connection refused')) {
+        errorDescription = 'Conexión rechazada: SSH no está corriendo en el servidor';
+        logError('SSH failed: Connection refused (SSH no está corriendo en el servidor)');
+      } else if (e.message.includes('Host key verification failed')) {
+        errorDescription = 'Verificación de host fallida';
+        logError('SSH failed: Host key verification failed');
+      } else {
+        errorDescription = `Error SSH: ${e.message}`;
+        logError(`SSH failed: ${e.message}`);
+      }
+      await addCommandLog('error', errorDescription);
+
+      // === IA: Analizar el error y sugerir soluciones ===
+      if (CONFIG.anthropicApiKey) {
+        logAI('Analizando error con IA...');
+        await addCommandLog('ai', 'Analizando error con IA...');
+
+        const aiAnalysis = await analyzeConnectionErrorWithAI(e.message, {
+          host: server_host,
+          user: user,
+          pingOk: results.ping.success,
+          pingLatency: results.ping.latency,
+        });
+
+        if (aiAnalysis) {
+          results.ai_diagnosis = aiAnalysis;
+
+          logAI(`Diagnóstico: ${aiAnalysis.diagnosis}`);
+          await addCommandLog('ai', `Diagnóstico: ${aiAnalysis.diagnosis}`);
+
+          if (aiAnalysis.causes && aiAnalysis.causes.length > 0) {
+            logAI('Posibles causas:');
+            await addCommandLog('ai', 'Posibles causas:');
+            for (const cause of aiAnalysis.causes) {
+              log(`  • ${cause}`, 'cyan');
+              await addCommandLog('ai', `  • ${cause}`);
+            }
+          }
+
+          if (aiAnalysis.solutions && aiAnalysis.solutions.length > 0) {
+            logAI('Soluciones sugeridas:');
+            await addCommandLog('ai', 'Soluciones sugeridas:');
+            for (const solution of aiAnalysis.solutions) {
+              log(`  ✓ ${solution}`, 'green');
+              await addCommandLog('ai', `  ✓ ${solution}`);
+            }
+          }
+
+          if (aiAnalysis.next_steps) {
+            logAI(`Siguiente paso: ${aiAnalysis.next_steps}`);
+            await addCommandLog('ai', `Siguiente paso: ${aiAnalysis.next_steps}`);
+          }
+        }
+      }
+    }
+
+    // Limpiar SSH key temporal
+    if (sshKeyPath) {
+      try {
+        const fs = await import('fs');
+        fs.unlinkSync(sshKeyPath);
+      } catch (e) { /* ignorar */ }
+    }
+
+    // Determinar estado final
+    const overallSuccess = results.ssh.success;
+    const status = overallSuccess ? 'completed' : 'failed';
+    const errorMsg = overallSuccess ? null : (results.ssh.error || 'SSH connection failed');
+
+    await updateCommandStatus(command.id, status, results, errorMsg);
+
+    console.log('');
+    if (overallSuccess) {
+      logSuccess(`=== Connection Test PASSED ===`);
+    } else {
+      logError(`=== Connection Test FAILED ===`);
+      if (results.ai_diagnosis) {
+        log('Ver diagnóstico de IA arriba para posibles soluciones', 'yellow');
+      }
+    }
+    console.log('');
+
+    return { success: overallSuccess, results };
+
+  } catch (error) {
+    logError(`Connection test failed: ${error.message}`);
+    await addCommandLog('error', error.message);
+    await updateCommandStatus(command.id, 'failed', {}, error.message);
+    return { success: false, error: error.message };
+  }
+}
+
 /**
  * Ejecuta git add, commit y push (con mejoras de IA si está disponible)
  */

package/package.json

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