@deinossrl/dgp-agent 1.0.0 → 1.1.0

package/index.mjs

@@ -1,18 +1,19 @@
 #!/usr/bin/env node
 /**
  * DGP Agent - Agente local para Despliegue-GPT
- * @deinos/dgp-agent
+ * @deinossrl/dgp-agent
  *
  * Este agente corre en la máquina del desarrollador y:
  * 1. Reporta el estado del repositorio git a la plataforma TenMinute IA
- * 2. (Futuro) Ejecuta comandos enviados desde la plataforma
+ * 2. Ejecuta comandos de deploy enviados desde la plataforma
  *
  * Instalación:
- *   npm install -g @deinos/dgp-agent
+ *   npm install -g @deinossrl/dgp-agent
  *
  * Uso:
  *   dgp-agent              # Inicia el agente (reporta cada 30s)
  *   dgp-agent status       # Muestra estado una vez
+ *   dgp-agent deploy       # Modo deploy (escucha comandos)
  *   dgp-agent help         # Muestra ayuda
  *
  * Variables de entorno:
@@ -22,13 +23,16 @@
  *   DGP_MACHINE_ID    ID personalizado de la máquina
  */
 
-import { execSync } from 'child_process';
+import { execSync, spawn } from 'child_process';
 import { hostname } from 'os';
 
 // Configuración
 const CONFIG = {
   apiUrl: process.env.DGP_API_URL || 'https://asivayhbrqennwiwttds.supabase.co/functions/v1/dgp-agent-status',
+  commandsUrl: process.env.DGP_COMMANDS_URL || 'https://asivayhbrqennwiwttds.supabase.co/rest/v1/dgp_agent_commands',
+  supabaseKey: process.env.DGP_SUPABASE_KEY || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImFzaXZheWhicnFlbm53aXd0dGRzIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjczMDAwOTcsImV4cCI6MjA4Mjg3NjA5N30.s3a7dR-dPkEXI7B2lUTUXU69923hhuX6meheNeo5EKA',
   interval: parseInt(process.env.DGP_INTERVAL || '30', 10),
+  commandPollInterval: parseInt(process.env.DGP_COMMAND_POLL_INTERVAL || '10', 10),
   machineId: process.env.DGP_MACHINE_ID || `${hostname()}-${process.env.USERNAME || process.env.USER || 'dev'}`,
   authToken: process.env.DGP_AUTH_TOKEN || null,
 };
@@ -42,6 +46,7 @@ const colors = {
   red: '\x1b[31m',
   gray: '\x1b[90m',
   cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
   bold: '\x1b[1m',
 };
 
@@ -62,6 +67,10 @@ function logInfo(message) {
   log(message, 'blue');
 }
 
+function logCommand(message) {
+  log(message, 'magenta');
+}
+
 /**
  * Ejecuta un comando git y retorna el resultado
  */
@@ -76,6 +85,64 @@ function git(command) {
   }
 }
 
+/**
+ * Ejecuta un comando shell y retorna el resultado
+ */
+function shell(command, options = {}) {
+  try {
+    return execSync(command, {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      ...options,
+    }).trim();
+  } catch (error) {
+    throw new Error(`Command failed: ${command}\n${error.message}`);
+  }
+}
+
+/**
+ * Ejecuta un comando shell de forma asíncrona con output en tiempo real
+ */
+function shellAsync(command, options = {}) {
+  return new Promise((resolve, reject) => {
+    const isWindows = process.platform === 'win32';
+    const shellCmd = isWindows ? 'cmd' : '/bin/sh';
+    const shellArgs = isWindows ? ['/c', command] : ['-c', command];
+
+    const proc = spawn(shellCmd, shellArgs, {
+      ...options,
+      stdio: ['inherit', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (data) => {
+      const str = data.toString();
+      stdout += str;
+      process.stdout.write(colors.gray + str + colors.reset);
+    });
+
+    proc.stderr.on('data', (data) => {
+      const str = data.toString();
+      stderr += str;
+      process.stderr.write(colors.yellow + str + colors.reset);
+    });
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        resolve({ stdout, stderr, code });
+      } else {
+        reject(new Error(`Command exited with code ${code}\n${stderr}`));
+      }
+    });
+
+    proc.on('error', (error) => {
+      reject(error);
+    });
+  });
+}
+
 /**
  * Verifica si estamos en un repositorio git
  */
@@ -194,6 +261,195 @@ async function reportStatus(status) {
   return await response.json();
 }
 
+/**
+ * Obtiene comandos pendientes de la plataforma
+ */
+async function getPendingCommands() {
+  const url = `${CONFIG.commandsUrl}?status=eq.pending&select=*&order=created_at.asc&limit=1`;
+
+  const response = await fetch(url, {
+    headers: {
+      'apikey': CONFIG.supabaseKey,
+      'Authorization': `Bearer ${CONFIG.supabaseKey}`,
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to get commands: HTTP ${response.status}`);
+  }
+
+  return await response.json();
+}
+
+/**
+ * Actualiza el estado de un comando
+ */
+async function updateCommandStatus(commandId, status, result = {}, errorMessage = null) {
+  const payload = {
+    status,
+    result,
+    error_message: errorMessage,
+    ...(status === 'running' ? { picked_up_at: new Date().toISOString() } : {}),
+    ...(status === 'success' || status === 'failed' ? { completed_at: new Date().toISOString() } : {}),
+  };
+
+  const url = `${CONFIG.commandsUrl}?id=eq.${commandId}`;
+
+  const response = await fetch(url, {
+    method: 'PATCH',
+    headers: {
+      'apikey': CONFIG.supabaseKey,
+      'Authorization': `Bearer ${CONFIG.supabaseKey}`,
+      'Content-Type': 'application/json',
+      'Prefer': 'return=minimal',
+    },
+    body: JSON.stringify(payload),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to update command: HTTP ${response.status}`);
+  }
+}
+
+/**
+ * Ejecuta un comando de deploy
+ */
+async function executeDeploy(command) {
+  const { id, environment, branch, server_host, ssh_user, deploy_url } = command;
+
+  logCommand(`=== Executing Deploy Command ===`);
+  logInfo(`Environment: ${environment}`);
+  logInfo(`Branch: ${branch}`);
+  logInfo(`Server: ${ssh_user}@${server_host}`);
+
+  const steps = [];
+  let currentStep = '';
+
+  try {
+    // Mark as running
+    await updateCommandStatus(id, 'running');
+
+    // Step 1: Git fetch and checkout
+    currentStep = 'git_checkout';
+    logCommand(`[1/5] Checkout branch ${branch}...`);
+    steps.push({ step: currentStep, status: 'running' });
+
+    await shellAsync(`git fetch origin`);
+    await shellAsync(`git checkout ${branch}`);
+    await shellAsync(`git pull origin ${branch}`);
+
+    steps[steps.length - 1].status = 'success';
+    logSuccess(`Branch ${branch} updated`);
+
+    // Step 2: Install dependencies
+    currentStep = 'npm_install';
+    logCommand(`[2/5] Installing dependencies...`);
+    steps.push({ step: currentStep, status: 'running' });
+
+    await shellAsync(`npm ci`);
+
+    steps[steps.length - 1].status = 'success';
+    logSuccess(`Dependencies installed`);
+
+    // Step 3: Build
+    currentStep = 'npm_build';
+    logCommand(`[3/5] Building application...`);
+    steps.push({ step: currentStep, status: 'running' });
+
+    await shellAsync(`npm run build`);
+
+    steps[steps.length - 1].status = 'success';
+    logSuccess(`Build completed`);
+
+    // Step 4: Deploy via rsync
+    currentStep = 'rsync_deploy';
+    logCommand(`[4/5] Deploying to server...`);
+    steps.push({ step: currentStep, status: 'running' });
+
+    const deployFolder = environment === 'production'
+      ? '/var/www/tenminuteia-prod/'
+      : '/var/www/tenminuteia-staging/';
+
+    // Rsync the dist folder
+    await shellAsync(`rsync -avz --delete dist/ ${ssh_user}@${server_host}:${deployFolder}`);
+
+    steps[steps.length - 1].status = 'success';
+    logSuccess(`Files deployed to ${server_host}:${deployFolder}`);
+
+    // Step 5: Reload nginx
+    currentStep = 'reload_nginx';
+    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"`);
+
+    steps[steps.length - 1].status = 'success';
+    logSuccess(`Nginx reloaded`);
+
+    // Healthcheck (optional)
+    if (deploy_url) {
+      logCommand(`Verifying deployment at ${deploy_url}...`);
+      try {
+        const healthResponse = await fetch(deploy_url);
+        if (healthResponse.ok) {
+          logSuccess(`Healthcheck passed`);
+        } else {
+          log(`Healthcheck returned ${healthResponse.status}`, 'yellow');
+        }
+      } catch (e) {
+        log(`Healthcheck failed: ${e.message}`, 'yellow');
+      }
+    }
+
+    // Mark as success
+    await updateCommandStatus(id, 'success', { steps, deploy_url });
+
+    console.log('');
+    logSuccess(`=== Deploy to ${environment} completed successfully! ===`);
+    console.log('');
+
+    return { success: true };
+
+  } catch (error) {
+    logError(`Deploy failed at step: ${currentStep}`);
+    logError(error.message);
+
+    steps[steps.length - 1].status = 'failed';
+    steps[steps.length - 1].error = error.message;
+
+    await updateCommandStatus(id, 'failed', { steps }, error.message);
+
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Ejecuta un comando recibido
+ */
+async function executeCommand(command) {
+  logCommand(`Received command: ${command.command}`);
+
+  switch (command.command) {
+    case 'deploy':
+      return await executeDeploy(command);
+
+    case 'status':
+      const status = getRepoStatus();
+      await updateCommandStatus(command.id, 'success', { status });
+      return { success: true, status };
+
+    case 'rollback':
+      logError('Rollback not implemented yet');
+      await updateCommandStatus(command.id, 'failed', {}, 'Rollback not implemented');
+      return { success: false };
+
+    default:
+      logError(`Unknown command: ${command.command}`);
+      await updateCommandStatus(command.id, 'failed', {}, `Unknown command: ${command.command}`);
+      return { success: false };
+  }
+}
+
 /**
  * Muestra el estado en consola
  */
@@ -223,11 +479,11 @@ function printStatus(status) {
 /**
  * Loop principal del agente
  */
-async function runAgent() {
+async function runAgent(deployMode = false) {
   console.log('');
   console.log(`${colors.green}╔═══════════════════════════════════════════════════════╗${colors.reset}`);
   console.log(`${colors.green}║     DGP Agent - Despliegue-GPT Local Agent            ║${colors.reset}`);
-  console.log(`${colors.green}║     @deinos/dgp-agent v1.0.0                          ║${colors.reset}`);
+  console.log(`${colors.green}║     @deinossrl/dgp-agent v1.1.0                        ║${colors.reset}`);
   console.log(`${colors.green}╚═══════════════════════════════════════════════════════╝${colors.reset}`);
   console.log('');
 
@@ -240,6 +496,11 @@ async function runAgent() {
   logInfo(`Report interval: ${CONFIG.interval}s`);
   logInfo(`API URL: ${CONFIG.apiUrl}`);
 
+  if (deployMode) {
+    logInfo(`Deploy mode: ACTIVE`);
+    logInfo(`Command poll interval: ${CONFIG.commandPollInterval}s`);
+  }
+
   if (!CONFIG.authToken) {
     log('INFO: No auth token. Reporting anonymously.', 'yellow');
     log('Set DGP_AUTH_TOKEN to associate with your user.', 'gray');
@@ -249,7 +510,8 @@ async function runAgent() {
   logInfo('Press Ctrl+C to stop');
   console.log('');
 
-  const runCycle = async () => {
+  // Status reporting cycle
+  const runStatusCycle = async () => {
     try {
       const status = getRepoStatus();
       printStatus(status);
@@ -262,8 +524,36 @@ async function runAgent() {
     }
   };
 
-  await runCycle();
-  setInterval(runCycle, CONFIG.interval * 1000);
+  // Command polling cycle (only in deploy mode)
+  const runCommandCycle = async () => {
+    try {
+      const commands = await getPendingCommands();
+      if (commands.length > 0) {
+        const command = commands[0];
+        logCommand(`Found pending command: ${command.id}`);
+        await executeCommand(command);
+      }
+    } catch (error) {
+      // Silent fail for command polling - don't spam logs
+      if (error.message.includes('42P01')) {
+        // Table doesn't exist yet - ignore
+      } else {
+        logError(`Command poll failed: ${error.message}`);
+      }
+    }
+  };
+
+  // Initial run
+  await runStatusCycle();
+  if (deployMode) {
+    await runCommandCycle();
+  }
+
+  // Set intervals
+  setInterval(runStatusCycle, CONFIG.interval * 1000);
+  if (deployMode) {
+    setInterval(runCommandCycle, CONFIG.commandPollInterval * 1000);
+  }
 }
 
 /**
@@ -309,37 +599,53 @@ async function showStatus() {
 function showHelp() {
   console.log(`
 ${colors.bold}${colors.cyan}DGP Agent - Despliegue-GPT Local Agent${colors.reset}
-${colors.gray}@deinos/dgp-agent v1.0.0${colors.reset}
+${colors.gray}@deinossrl/dgp-agent v1.1.0${colors.reset}
 
 ${colors.bold}DESCRIPCIÓN${colors.reset}
   Agente local que reporta el estado de tu repositorio Git
-  a la plataforma TenMinute IA (Despliegue-GPT).
+  a la plataforma TenMinute IA (Despliegue-GPT) y puede
+  ejecutar comandos de deploy remotos.
 
 ${colors.bold}INSTALACIÓN${colors.reset}
-  ${colors.green}npm install -g @deinos/dgp-agent${colors.reset}
+  ${colors.green}npm install -g @deinossrl/dgp-agent${colors.reset}
 
 ${colors.bold}USO${colors.reset}
-  ${colors.cyan}dgp-agent${colors.reset}              Inicia el agente (reporta cada 30s)
+  ${colors.cyan}dgp-agent${colors.reset}              Inicia el agente (solo reporta estado)
+  ${colors.cyan}dgp-agent deploy${colors.reset}       Modo deploy (reporta + escucha comandos)
   ${colors.cyan}dgp-agent status${colors.reset}       Muestra el estado actual una vez
   ${colors.cyan}dgp-agent help${colors.reset}         Muestra esta ayuda
 
+${colors.bold}MODOS DE OPERACIÓN${colors.reset}
+  ${colors.yellow}Default${colors.reset}      Solo reporta estado del repo cada 30s
+  ${colors.yellow}Deploy${colors.reset}       Reporta estado + escucha comandos de la plataforma
+              Puede ejecutar: build, deploy via rsync, reload nginx
+
 ${colors.bold}VARIABLES DE ENTORNO${colors.reset}
-  ${colors.yellow}DGP_AUTH_TOKEN${colors.reset}    Token JWT para asociar a tu usuario
-                    (Obtenerlo desde la plataforma)
-  ${colors.yellow}DGP_API_URL${colors.reset}       URL del endpoint API
-  ${colors.yellow}DGP_INTERVAL${colors.reset}      Intervalo de reporte en segundos (default: 30)
-  ${colors.yellow}DGP_MACHINE_ID${colors.reset}    ID personalizado de la máquina
+  ${colors.yellow}DGP_AUTH_TOKEN${colors.reset}         Token JWT para asociar a tu usuario
+  ${colors.yellow}DGP_API_URL${colors.reset}            URL del endpoint API
+  ${colors.yellow}DGP_INTERVAL${colors.reset}           Intervalo de reporte en segundos (default: 30)
+  ${colors.yellow}DGP_COMMAND_POLL_INTERVAL${colors.reset}  Intervalo de polling comandos (default: 10)
+  ${colors.yellow}DGP_MACHINE_ID${colors.reset}         ID personalizado de la máquina
 
 ${colors.bold}EJEMPLOS${colors.reset}
-  # Iniciar agente básico
+  # Iniciar agente básico (solo reporta)
   ${colors.gray}$ dgp-agent${colors.reset}
 
+  # Iniciar en modo deploy (puede ejecutar deploys)
+  ${colors.gray}$ dgp-agent deploy${colors.reset}
+
   # Con token de autenticación
-  ${colors.gray}$ DGP_AUTH_TOKEN=eyJ... dgp-agent${colors.reset}
+  ${colors.gray}$ DGP_AUTH_TOKEN=eyJ... dgp-agent deploy${colors.reset}
 
   # Intervalo personalizado (60 segundos)
   ${colors.gray}$ DGP_INTERVAL=60 dgp-agent${colors.reset}
 
+${colors.bold}REQUISITOS PARA DEPLOY${colors.reset}
+  - SSH key configurada para acceso al servidor
+  - Node.js y npm en el PATH
+  - rsync instalado (Linux/Mac) o equivalente (Windows)
+  - Permisos sudo para reload nginx (vía sudoers sin password)
+
 ${colors.bold}MÁS INFO${colors.reset}
   https://github.com/DEINOS-SRL/tenminuteia
 `);
@@ -350,6 +656,11 @@ const args = process.argv.slice(2);
 const command = args[0];
 
 switch (command) {
+  case 'deploy':
+  case '-d':
+  case '--deploy':
+    runAgent(true); // Deploy mode
+    break;
   case 'status':
   case '-s':
   case '--status':
@@ -363,8 +674,8 @@ switch (command) {
   case 'version':
   case '-v':
   case '--version':
-    console.log('@deinos/dgp-agent v1.0.0');
+    console.log('@deinossrl/dgp-agent v1.1.0');
     break;
   default:
-    runAgent();
+    runAgent(false); // Status-only mode
 }

package/package.json

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