@deinossrl/dgp-agent 1.4.21 → 1.4.23

package/index.mjs

@@ -202,8 +202,67 @@ async function fetchPlatformConfig() {
 // Variable para config de la plataforma (se carga async)
 let platformConfig = null;
 
+/**
+ * Obtiene la ruta del archivo de SSH key del agente
+ */
+function getDgpSshKeyPath() {
+  const os = require('os');
+  const path = require('path');
+  return path.join(os.homedir(), '.ssh', 'dgp_key');
+}
+
+/**
+ * Guarda una SSH key en ~/.ssh/dgp_key
+ */
+function saveSshKeyLocally(sshPrivateKey) {
+  try {
+    const fs = require('fs');
+    const os = require('os');
+    const path = require('path');
+
+    const sshDir = path.join(os.homedir(), '.ssh');
+    if (!fs.existsSync(sshDir)) {
+      fs.mkdirSync(sshDir, { recursive: true, mode: 0o700 });
+    }
+
+    const keyPath = getDgpSshKeyPath();
+    // Normalizar saltos de línea
+    const normalizedKey = sshPrivateKey.replace(/\\n/g, '\n').replace(/\r\n/g, '\n');
+    fs.writeFileSync(keyPath, normalizedKey, { mode: 0o600 });
+
+    return keyPath;
+  } catch (e) {
+    console.error('Error guardando SSH key:', e.message);
+    return null;
+  }
+}
+
+/**
+ * Carga la SSH key guardada localmente (si existe)
+ */
+function loadLocalSshKey() {
+  try {
+    const fs = require('fs');
+    const keyPath = getDgpSshKeyPath();
+    if (fs.existsSync(keyPath)) {
+      return fs.readFileSync(keyPath, 'utf8');
+    }
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Verifica si hay una SSH key guardada localmente
+ */
+function hasLocalSshKey() {
+  const fs = require('fs');
+  return fs.existsSync(getDgpSshKeyPath());
+}
+
 // Versión del agente
-const AGENT_VERSION = '1.4.21';
+const AGENT_VERSION = '1.4.23';
 let AGENT_MODE = 'smart'; // Siempre inteligente
 
 // Configuración (prioridad: env vars > archivo config > platform config > defaults)
@@ -1260,10 +1319,34 @@ Analiza este error y sugiere soluciones.`;
  */
 async function executeTestConnection(command) {
   const { server_host, ssh_user, params } = command;
-  const sshPrivateKey = params?.ssh_private_key || null;
+
+  // SSH Key: prioridad params > guardada localmente
+  let sshPrivateKey = params?.ssh_private_key || null;
+  let sshPassword = params?.ssh_password || null;
+  let authMethod = 'ninguno';
+
+  // Si viene SSH key en params, guardarla localmente para futuro uso
+  if (sshPrivateKey) {
+    const savedPath = saveSshKeyLocally(sshPrivateKey);
+    if (savedPath) {
+      logSuccess(`SSH Key guardada en ${savedPath}`);
+      authMethod = 'key (guardada localmente)';
+    } else {
+      authMethod = 'key (plataforma)';
+    }
+  } else if (hasLocalSshKey()) {
+    // Si no viene en params pero hay una guardada, usarla
+    sshPrivateKey = loadLocalSshKey();
+    authMethod = `key (${getDgpSshKeyPath()})`;
+    logInfo(`Usando SSH Key guardada: ${getDgpSshKeyPath()}`);
+  } else if (sshPassword) {
+    authMethod = 'password';
+    logInfo('Usando autenticación por password');
+  }
 
   logCommand(`=== Testing SSH Connection ===`);
   logInfo(`Target: ${ssh_user || 'root'}@${server_host}`);
+  logInfo(`Auth: ${authMethod}`);
 
   // Iniciar tracking de logs
   currentCommandId = command.id;
@@ -1306,26 +1389,36 @@ async function executeTestConnection(command) {
     // Step 2: SSH test
     logInfo('Step 2: Testing SSH connection...');
 
-    // Si hay SSH key, guardarla en archivo temporal
+    const user = ssh_user || 'root';
+    let sshCmd = '';
+
+    // Usar la SSH key guardada en ~/.ssh/dgp_key (ya se guardó arriba si vino de params)
     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()}`);
-      // Normalizar saltos de línea (pueden venir como \n literal del JSON)
-      const normalizedKey = sshPrivateKey.replace(/\\n/g, '\n').replace(/\r\n/g, '\n');
-      fs.writeFileSync(sshKeyPath, normalizedKey, { mode: 0o600 });
-      logInfo('SSH Key: Usando clave desde plataforma');
-      await addCommandLog('info', 'Usando SSH key configurada en la plataforma');
+    if (sshPrivateKey && hasLocalSshKey()) {
+      sshKeyPath = getDgpSshKeyPath();
+      await addCommandLog('info', `Usando SSH key: ${sshKeyPath}`);
+      const sshOpts = `-i ${sshKeyPath} -o StrictHostKeyChecking=no -o ConnectTimeout=10 -o BatchMode=yes`;
+      sshCmd = `ssh ${sshOpts} ${user}@${server_host} "echo 'SSH_OK' && hostname && whoami"`;
+    } else if (sshPassword) {
+      // Usar sshpass para autenticación por password
+      await addCommandLog('info', 'Usando autenticación por password (sshpass)');
+      const isWindows = process.platform === 'win32';
+      if (isWindows) {
+        // En Windows usar plink (PuTTY) o mostrar advertencia
+        await addCommandLog('warning', 'SSH con password en Windows requiere plink (PuTTY)');
+        // Intentar con plink si está disponible
+        sshCmd = `echo y | plink -ssh -pw "${sshPassword}" ${user}@${server_host} "echo SSH_OK && hostname && whoami"`;
+      } else {
+        // En Linux/Mac usar sshpass
+        sshCmd = `sshpass -p "${sshPassword}" ssh -o StrictHostKeyChecking=no -o ConnectTimeout=10 ${user}@${server_host} "echo 'SSH_OK' && hostname && whoami"`;
+      }
+    } else {
+      // Sin key ni password, intentar con key del sistema
+      await addCommandLog('info', 'Intentando conexión con keys del sistema (~/.ssh/)');
+      const sshOpts = `-o StrictHostKeyChecking=no -o ConnectTimeout=10 -o BatchMode=yes`;
+      sshCmd = `ssh ${sshOpts} ${user}@${server_host} "echo 'SSH_OK' && hostname && whoami"`;
     }
 
-    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 {
@@ -1412,13 +1505,7 @@ async function executeTestConnection(command) {
       }
     }
 
-    // Limpiar SSH key temporal
-    if (sshKeyPath) {
-      try {
-        const fs = await import('fs');
-        fs.unlinkSync(sshKeyPath);
-      } catch (e) { /* ignorar */ }
-    }
+    // Nota: No limpiamos la SSH key porque está guardada permanentemente en ~/.ssh/dgp_key
 
     // Determinar estado final
     const overallSuccess = results.ssh.success;

package/package.json

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