codecrypto-cli 1.0.9 → 1.0.10

package/src/commands/deploy.ts

@@ -7,8 +7,8 @@ import * as path from 'path';
 import * as os from 'os';
 
 export const deployCommand = new Command('deploy')
-  .description('Build and deploy Docker image for Next.js standalone application')
-  .argument('<project-path>', 'Path to the Next.js project directory')
+  .description('Build and deploy Docker image for Next.js or Express application')
+  .argument('<project-path>', 'Path to the project directory')
   .argument('[dest-folder]', 'Destination folder for Docker build context', './docker-build')
   .option('--skip-build', 'Skip npm run build (assume already built)', false)
   .option('--no-push', 'Build image but do not push to registry')
@@ -123,129 +123,164 @@ export const deployCommand = new Command('deploy')
       // - Con --no-push: options.push = false (no hace push)
       const shouldPush = options.push !== false;
 
+      // Detectar automáticamente el tipo de proyecto analizando package.json
+      const allDependencies = {
+        ...(packageJson.dependencies || {}),
+        ...(packageJson.devDependencies || {}),
+      };
+      
+      let projectType: 'nextjs' | 'express' | null = null;
+      
+      if (allDependencies.next || allDependencies['nextjs']) {
+        projectType = 'nextjs';
+      } else if (allDependencies.express) {
+        projectType = 'express';
+      }
+      
+      if (!projectType) {
+        console.error(chalk.red(`❌ Error: No se pudo detectar el tipo de proyecto`));
+        console.error(chalk.yellow('   El proyecto debe tener "next" o "express" en las dependencias del package.json'));
+        console.error(chalk.yellow('   Dependencias encontradas:'));
+        const depKeys = Object.keys(allDependencies).slice(0, 10);
+        depKeys.forEach(dep => {
+          console.error(chalk.gray(`     - ${dep}`));
+        });
+        if (Object.keys(allDependencies).length > 10) {
+          console.error(chalk.gray(`     ... y ${Object.keys(allDependencies).length - 10} más`));
+        }
+        process.exit(1);
+      }
+
       console.log(chalk.gray('Deployment Configuration:'));
       console.log(chalk.white(`  Project: ${chalk.green(projectName)}`));
+      console.log(chalk.white(`  Type: ${chalk.green(projectType)}`));
       console.log(chalk.white(`  Version: ${chalk.green(version)}`));
       console.log(chalk.white(`  Image: ${chalk.green(imageName)}`));
       console.log(chalk.white(`  Latest: ${chalk.green(imageLatest)}`));
       console.log(chalk.white(`  Push to Registry: ${shouldPush ? chalk.green('Yes') : chalk.yellow('No')}\n`));
 
-      // Paso 1: Build del proyecto si es necesario
-      if (!options.skipBuild) {
-        const buildSpinner = ora('Building Next.js application...').start();
-        try {
-          execSync('npm run build', { 
-            cwd: resolvedProjectPath, 
-            stdio: 'pipe' 
-          });
-          buildSpinner.succeed('Build completed successfully');
-        } catch (error) {
-          buildSpinner.fail('Build failed');
-          console.error(chalk.red('Error during build. Make sure you have "output: standalone" in next.config.ts'));
-          process.exit(1);
-        }
-      }
-
-      // Verificar que existe .next/standalone
-      const standalonePath = path.join(resolvedProjectPath, '.next', 'standalone');
-      if (!fs.existsSync(standalonePath)) {
-        console.error(chalk.red(`❌ Error: No se encontró .next/standalone`));
-        console.error(chalk.yellow('Asegúrate de tener "output: standalone" en next.config.ts y ejecutar "npm run build"'));
-        process.exit(1);
-      }
-
-      // Paso 2: Preparar directorio destino
+      // Preparar directorio destino
       const resolvedDestFolder = path.resolve(destFolder);
-      const standaloneDest = path.join(resolvedDestFolder, 'standalone');
-      
-      const copySpinner = ora('Copying standalone files...').start();
       if (fs.existsSync(resolvedDestFolder)) {
         fs.rmSync(resolvedDestFolder, { recursive: true, force: true });
       }
-      fs.mkdirSync(standaloneDest, { recursive: true });
+      fs.mkdirSync(resolvedDestFolder, { recursive: true });
 
-      // Copiar contenido de standalone
-      const nextDir = findDirectory(standalonePath, '.next');
-      if (nextDir) {
-        const parentDir = path.dirname(nextDir);
-        copyDirectory(parentDir, standaloneDest);
-      } else {
-        copyDirectory(standalonePath, standaloneDest);
-      }
-
-      // Copiar .next/static
-      const staticPath = path.join(resolvedProjectPath, '.next', 'static');
-      if (fs.existsSync(staticPath)) {
-        const staticDest = path.join(standaloneDest, '.next', 'static');
-        fs.mkdirSync(staticDest, { recursive: true });
-        copyDirectory(staticPath, staticDest);
-      }
-
-      // Copiar public
-      const publicPath = path.join(resolvedProjectPath, 'public');
-      if (fs.existsSync(publicPath)) {
-        const publicDest = path.join(standaloneDest, 'public');
-        fs.mkdirSync(publicDest, { recursive: true });
-        copyDirectory(publicPath, publicDest);
-      }
-
-      // Verificar server.js
-      const serverJsPath = path.join(standaloneDest, 'server.js');
-      if (!fs.existsSync(serverJsPath)) {
-        copySpinner.fail('server.js not found in standalone');
-        process.exit(1);
-      }
-
-      copySpinner.succeed('Files copied successfully');
-
-      // Leer y procesar archivo .env si existe
-      let nextPublicEnvVars: string[] = [];
       let runtimeEnvVars: string[] = [];
+      let nextPublicEnvVars: string[] = [];
+      let dockerfileContent: string;
+      
+      // Determinar ruta del archivo .env (común para ambos tipos de proyecto)
       const envFilePath = options.envFile 
         ? path.resolve(options.envFile)
         : path.join(resolvedProjectPath, '.env');
-      
-      if (fs.existsSync(envFilePath)) {
-        const envContent = fs.readFileSync(envFilePath, 'utf-8');
-        const envLines = envContent.split('\n');
+
+      if (projectType === 'nextjs') {
+        // ========== LÓGICA PARA NEXT.JS ==========
         
-        for (const line of envLines) {
-          const trimmed = line.trim();
-          // Ignorar comentarios y líneas vacías
-          if (!trimmed || trimmed.startsWith('#')) continue;
-          
-          const equalIndex = trimmed.indexOf('=');
-          if (equalIndex === -1) continue;
-          
-          const key = trimmed.substring(0, equalIndex).trim();
-          const value = trimmed.substring(equalIndex + 1).trim();
+        // Paso 1: Build del proyecto si es necesario
+        if (!options.skipBuild) {
+          const buildSpinner = ora('Building Next.js application...').start();
+          try {
+            execSync('npm run build', { 
+              cwd: resolvedProjectPath, 
+              stdio: 'pipe' 
+            });
+            buildSpinner.succeed('Build completed successfully');
+          } catch (error) {
+            buildSpinner.fail('Build failed');
+            console.error(chalk.red('Error during build. Make sure you have "output: standalone" in next.config.ts'));
+            process.exit(1);
+          }
+        }
+
+        // Verificar que existe .next/standalone
+        const standalonePath = path.join(resolvedProjectPath, '.next', 'standalone');
+        if (!fs.existsSync(standalonePath)) {
+          console.error(chalk.red(`❌ Error: No se encontró .next/standalone`));
+          console.error(chalk.yellow('Asegúrate de tener "output: standalone" en next.config.ts y ejecutar "npm run build"'));
+          process.exit(1);
+        }
+
+        // Paso 2: Preparar directorio destino
+        const standaloneDest = path.join(resolvedDestFolder, 'standalone');
+        
+        const copySpinner = ora('Copying standalone files...').start();
+        fs.mkdirSync(standaloneDest, { recursive: true });
+
+        // Copiar contenido de standalone
+        const nextDir = findDirectory(standalonePath, '.next');
+        if (nextDir) {
+          const parentDir = path.dirname(nextDir);
+          copyDirectory(parentDir, standaloneDest);
+        } else {
+          copyDirectory(standalonePath, standaloneDest);
+        }
+
+        // Copiar .next/static
+        const staticPath = path.join(resolvedProjectPath, '.next', 'static');
+        if (fs.existsSync(staticPath)) {
+          const staticDest = path.join(standaloneDest, '.next', 'static');
+          fs.mkdirSync(staticDest, { recursive: true });
+          copyDirectory(staticPath, staticDest);
+        }
+
+        // Copiar public
+        const publicPath = path.join(resolvedProjectPath, 'public');
+        if (fs.existsSync(publicPath)) {
+          const publicDest = path.join(standaloneDest, 'public');
+          fs.mkdirSync(publicDest, { recursive: true });
+          copyDirectory(publicPath, publicDest);
+        }
+
+        // Verificar server.js
+        const serverJsPath = path.join(standaloneDest, 'server.js');
+        if (!fs.existsSync(serverJsPath)) {
+          copySpinner.fail('server.js not found in standalone');
+          process.exit(1);
+        }
+
+        copySpinner.succeed('Files copied successfully');
+
+        // Leer y procesar archivo .env si existe
+        // (envFilePath ya está definido arriba)
+        if (fs.existsSync(envFilePath)) {
+          const envContent = fs.readFileSync(envFilePath, 'utf-8');
+          const envLines = envContent.split('\n');
           
-          if (key.startsWith('NEXT_PUBLIC_')) {
-            nextPublicEnvVars.push(`${key}=${value}`);
-          } else {
-            runtimeEnvVars.push(`${key}=${value}`);
+          for (const line of envLines) {
+            const trimmed = line.trim();
+            // Ignorar comentarios y líneas vacías
+            if (!trimmed || trimmed.startsWith('#')) continue;
+            
+            const equalIndex = trimmed.indexOf('=');
+            if (equalIndex === -1) continue;
+            
+            const key = trimmed.substring(0, equalIndex).trim();
+            const value = trimmed.substring(equalIndex + 1).trim();
+            
+            if (key.startsWith('NEXT_PUBLIC_')) {
+              nextPublicEnvVars.push(`${key}=${value}`);
+            } else {
+              runtimeEnvVars.push(`${key}=${value}`);
+            }
           }
         }
-      }
 
-      // Paso 3: Crear Dockerfile con variables NEXT_PUBLIC_*
-      const dockerfileSpinner = ora('Creating Dockerfile...').start();
-      const dockerfilePath = path.join(resolvedDestFolder, 'Dockerfile');
-      
-      // Construir ARG y ENV para NEXT_PUBLIC_*
-      const buildArgs = nextPublicEnvVars.map(env => {
-        const [key, ...valueParts] = env.split('=');
-        const value = valueParts.join('=');
-        return `ARG ${key}=${value}`;
-      }).join('\n');
-      
-      const buildEnvs = nextPublicEnvVars.map(env => {
-        const [key, ...valueParts] = env.split('=');
-        const value = valueParts.join('=');
-        return `ENV ${key}=${value}`;
-      }).join('\n');
-      
-      const dockerfileContent = `FROM node:20-alpine
+        // Construir ARG y ENV para NEXT_PUBLIC_*
+        const buildArgs = nextPublicEnvVars.map(env => {
+          const [key, ...valueParts] = env.split('=');
+          const value = valueParts.join('=');
+          return `ARG ${key}=${value}`;
+        }).join('\n');
+        
+        const buildEnvs = nextPublicEnvVars.map(env => {
+          const [key, ...valueParts] = env.split('=');
+          const value = valueParts.join('=');
+          return `ENV ${key}=${value}`;
+        }).join('\n');
+        
+        dockerfileContent = `FROM node:20-alpine
 WORKDIR /app
 
 ENV NODE_ENV=production
@@ -264,12 +299,197 @@ EXPOSE 3000
 # Arrancamos directamente con Node
 CMD ["node", "server.js"]
 `;
+
+      } else {
+        // ========== LÓGICA PARA EXPRESS ==========
+        
+        // Paso 1: Instalar dependencias de producción si es necesario
+        if (!options.skipBuild) {
+          const installSpinner = ora('Installing production dependencies...').start();
+          try {
+            // Verificar si node_modules existe
+            const nodeModulesPath = path.join(resolvedProjectPath, 'node_modules');
+            if (!fs.existsSync(nodeModulesPath)) {
+              execSync('npm install --production', { 
+                cwd: resolvedProjectPath, 
+                stdio: 'pipe' 
+              });
+            }
+            installSpinner.succeed('Dependencies ready');
+          } catch (error) {
+            installSpinner.fail('Failed to install dependencies');
+            console.error(chalk.red('Error installing dependencies'));
+            process.exit(1);
+          }
+        }
+
+        // Paso 2: Copiar archivos del proyecto (sin node_modules, Docker lo instalará)
+        const copySpinner = ora('Copying project files...').start();
+        
+        // Copiar todos los archivos excepto los que están en .dockerignore
+        const ignorePatterns = [
+          'node_modules',
+          '.git',
+          '.next',
+          'dist',
+          'build',
+          '.env',
+          '.env.local',
+          '.env.*.local',
+          'npm-debug.log*',
+          'yarn-debug.log*',
+          'yarn-error.log*',
+          '.DS_Store',
+          'coverage',
+          '.nyc_output',
+        ];
+
+        function shouldIgnore(filePath: string, basePath: string): boolean {
+          const relativePath = path.relative(basePath, filePath);
+          return ignorePatterns.some(pattern => {
+            if (relativePath.includes(pattern)) return true;
+            // Verificar si es un archivo que empieza con el patrón
+            const parts = relativePath.split(path.sep);
+            return parts.some(part => part === pattern || part.startsWith(pattern));
+          });
+        }
+
+        function copyProjectFiles(src: string, dest: string): void {
+          if (!fs.existsSync(dest)) {
+            fs.mkdirSync(dest, { recursive: true });
+          }
+          
+          const entries = fs.readdirSync(src, { withFileTypes: true });
+          for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            
+            // Ignorar archivos y directorios según los patrones
+            if (shouldIgnore(srcPath, resolvedProjectPath)) {
+              continue;
+            }
+            
+            try {
+              const stats = fs.lstatSync(srcPath);
+              
+              if (stats.isDirectory()) {
+                copyProjectFiles(srcPath, destPath);
+              } else if (stats.isFile()) {
+                fs.copyFileSync(srcPath, destPath);
+              }
+            } catch (error: any) {
+              // Ignorar errores al copiar archivos especiales
+              if (error.code === 'ENOTSUP' || error.code === 'EINVAL' || error.code === 'EOPNOTSUPP') {
+                continue;
+              }
+              throw error;
+            }
+          }
+        }
+
+        // Copiar archivos del proyecto
+        copyProjectFiles(resolvedProjectPath, resolvedDestFolder);
+
+        // Verificar que existe package.json en el destino
+        const destPackageJson = path.join(resolvedDestFolder, 'package.json');
+        if (!fs.existsSync(destPackageJson)) {
+          copySpinner.fail('package.json not found');
+          console.error(chalk.red('❌ Error: package.json is required for Express application'));
+          process.exit(1);
+        }
+
+        // Verificar que existe un archivo principal
+        const packageJson = JSON.parse(fs.readFileSync(destPackageJson, 'utf-8'));
+        const mainFile = packageJson.main || 'index.js';
+        const mainFilePath = path.join(resolvedDestFolder, mainFile);
+        
+        if (!fs.existsSync(mainFilePath)) {
+          // Buscar otros archivos comunes
+          const commonFiles = ['index.js', 'server.js', 'app.js', 'main.js'];
+          let found = false;
+          for (const file of commonFiles) {
+            if (fs.existsSync(path.join(resolvedDestFolder, file))) {
+              found = true;
+              break;
+            }
+          }
+          if (!found) {
+            copySpinner.fail(`Main entry file not found: ${mainFile}`);
+            console.error(chalk.red(`❌ Error: Could not find main entry file (${mainFile}) for Express application`));
+            process.exit(1);
+          }
+        }
+
+        copySpinner.succeed('Files copied successfully');
+
+        // Leer y procesar archivo .env si existe
+        // (envFilePath ya está definido arriba)
+        if (fs.existsSync(envFilePath)) {
+          const envContent = fs.readFileSync(envFilePath, 'utf-8');
+          const envLines = envContent.split('\n');
+          
+          for (const line of envLines) {
+            const trimmed = line.trim();
+            // Ignorar comentarios y líneas vacías
+            if (!trimmed || trimmed.startsWith('#')) continue;
+            
+            const equalIndex = trimmed.indexOf('=');
+            if (equalIndex === -1) continue;
+            
+            const key = trimmed.substring(0, equalIndex).trim();
+            const value = trimmed.substring(equalIndex + 1).trim();
+            
+            runtimeEnvVars.push(`${key}=${value}`);
+          }
+        }
+
+        // Crear Dockerfile optimizado para Express
+        // (destPackageJson, packageJson y mainFile ya están declaradas arriba)
+        const startScript = packageJson.scripts?.start;
+        
+        // Determinar el comando de inicio
+        let startCmd: string[];
+        if (startScript) {
+          // Si hay un script start, usarlo
+          startCmd = startScript.split(' ');
+        } else {
+          // Si no, usar node con el archivo principal
+          startCmd = ['node', mainFile];
+        }
+        
+        dockerfileContent = `FROM node:20-alpine
+
+WORKDIR /app
+
+ENV NODE_ENV=production
+ENV PORT=3000
+
+# Copiar package files primero para aprovechar cache de Docker
+COPY package*.json ./
+
+# Instalar solo dependencias de producción
+RUN npm ci --only=production && npm cache clean --force
+
+# Copiar código fuente
+COPY . .
+
+# Exponemos el puerto
+EXPOSE 3000
+
+# Comando de inicio
+CMD ${JSON.stringify(startCmd)}
+`;
+      }
+
+      // Paso 3: Crear Dockerfile
+      const dockerfileSpinner = ora('Creating Dockerfile...').start();
+      const dockerfilePath = path.join(resolvedDestFolder, 'Dockerfile');
       fs.writeFileSync(dockerfilePath, dockerfileContent);
       
       dockerfileSpinner.succeed('Dockerfile created');
       
-      // Mostrar contenido del Dockerfile si hay variables NEXT_PUBLIC_*
-      if (nextPublicEnvVars.length > 0) {
+      // Mostrar contenido del Dockerfile
+      if (projectType === 'nextjs' && nextPublicEnvVars.length > 0) {
         console.log(chalk.gray('\n📄 Dockerfile content:'));
         console.log(chalk.gray('─'.repeat(60)));
         console.log(chalk.white(dockerfileContent));
@@ -280,7 +500,7 @@ CMD ["node", "server.js"]
           console.log(chalk.gray(`    - ${chalk.cyan(key)}`));
         });
       } else {
-        console.log(chalk.gray('\n📄 Dockerfile created (no NEXT_PUBLIC_* variables found)'));
+        console.log(chalk.gray(`\n📄 Dockerfile created for ${projectType} application`));
       }
 
       // Paso 4: Verificar/crear builder multi-plataforma

package/docker-build/Dockerfile

@@ -1,18 +0,0 @@
-FROM node:20-alpine
-WORKDIR /app
-
-ENV NODE_ENV=production
-ENV PORT=3000
-
-ARG NEXT_PUBLIC_API_URL=http://localhost:3000
-
-ENV NEXT_PUBLIC_API_URL=http://localhost:3000
-
-# Copiamos el contenido de standalone
-COPY standalone/ .
-
-# Exponemos el puerto para Traefik
-EXPOSE 3000
-
-# Arrancamos directamente con Node
-CMD ["node", "server.js"]

package/docker-build/standalone/.next/BUILD_ID

@@ -1 +0,0 @@
-_NbfI2TKfapiyxsQgIG3h

package/docker-build/standalone/.next/app-path-routes-manifest.json

@@ -1,6 +0,0 @@
-{
-  "/_global-error/page": "/_global-error",
-  "/_not-found/page": "/_not-found",
-  "/favicon.ico/route": "/favicon.ico",
-  "/page": "/"
-}

package/docker-build/standalone/.next/build-manifest.json

@@ -1,19 +0,0 @@
-{
-  "pages": {
-    "/_app": []
-  },
-  "devFiles": [],
-  "polyfillFiles": [
-    "static/chunks/a6dad97d9634a72d.js"
-  ],
-  "lowPriorityFiles": [
-    "static/_NbfI2TKfapiyxsQgIG3h/_ssgManifest.js",
-    "static/_NbfI2TKfapiyxsQgIG3h/_buildManifest.js"
-  ],
-  "rootMainFiles": [
-    "static/chunks/6ae71d5e8ea4d1eb.js",
-    "static/chunks/70977d70c9306213.js",
-    "static/chunks/777dac7104fe2a30.js",
-    "static/chunks/turbopack-0ce517fb6224c1f0.js"
-  ]
-}

package/docker-build/standalone/.next/package.json

@@ -1 +0,0 @@
-{"type": "commonjs"}

package/docker-build/standalone/.next/prerender-manifest.json

@@ -1,114 +0,0 @@
-{
-  "version": 4,
-  "routes": {
-    "/_global-error": {
-      "experimentalBypassFor": [
-        {
-          "type": "header",
-          "key": "next-action"
-        },
-        {
-          "type": "header",
-          "key": "content-type",
-          "value": "multipart/form-data;.*"
-        }
-      ],
-      "initialRevalidateSeconds": false,
-      "srcRoute": "/_global-error",
-      "dataRoute": "/_global-error.rsc",
-      "allowHeader": [
-        "host",
-        "x-matched-path",
-        "x-prerender-revalidate",
-        "x-prerender-revalidate-if-generated",
-        "x-next-revalidated-tags",
-        "x-next-revalidate-tag-token"
-      ]
-    },
-    "/_not-found": {
-      "initialStatus": 404,
-      "experimentalBypassFor": [
-        {
-          "type": "header",
-          "key": "next-action"
-        },
-        {
-          "type": "header",
-          "key": "content-type",
-          "value": "multipart/form-data;.*"
-        }
-      ],
-      "initialRevalidateSeconds": false,
-      "srcRoute": "/_not-found",
-      "dataRoute": "/_not-found.rsc",
-      "allowHeader": [
-        "host",
-        "x-matched-path",
-        "x-prerender-revalidate",
-        "x-prerender-revalidate-if-generated",
-        "x-next-revalidated-tags",
-        "x-next-revalidate-tag-token"
-      ]
-    },
-    "/favicon.ico": {
-      "initialHeaders": {
-        "cache-control": "public, max-age=0, must-revalidate",
-        "content-type": "image/x-icon",
-        "x-next-cache-tags": "_N_T_/layout,_N_T_/favicon.ico/layout,_N_T_/favicon.ico/route,_N_T_/favicon.ico"
-      },
-      "experimentalBypassFor": [
-        {
-          "type": "header",
-          "key": "next-action"
-        },
-        {
-          "type": "header",
-          "key": "content-type",
-          "value": "multipart/form-data;.*"
-        }
-      ],
-      "initialRevalidateSeconds": false,
-      "srcRoute": "/favicon.ico",
-      "dataRoute": null,
-      "allowHeader": [
-        "host",
-        "x-matched-path",
-        "x-prerender-revalidate",
-        "x-prerender-revalidate-if-generated",
-        "x-next-revalidated-tags",
-        "x-next-revalidate-tag-token"
-      ]
-    },
-    "/": {
-      "experimentalBypassFor": [
-        {
-          "type": "header",
-          "key": "next-action"
-        },
-        {
-          "type": "header",
-          "key": "content-type",
-          "value": "multipart/form-data;.*"
-        }
-      ],
-      "initialRevalidateSeconds": false,
-      "srcRoute": "/",
-      "dataRoute": "/index.rsc",
-      "allowHeader": [
-        "host",
-        "x-matched-path",
-        "x-prerender-revalidate",
-        "x-prerender-revalidate-if-generated",
-        "x-next-revalidated-tags",
-        "x-next-revalidate-tag-token"
-      ]
-    }
-  },
-  "dynamicRoutes": {},
-  "notFoundRoutes": [],
-  "preview": {
-    "previewModeId": "97906e79384b81f9f7dfdaf2500bd376",
-    "previewModeSigningKey": "c8a81f6f74dd50351ecd5dbef909560e00593cf675251719bb21e6883e641dd0",
-    "previewModeEncryptionKey": "19b4f3ad1cee9c6cca1d9181bc9538fb585641fa19708384b8411c7dc5bd32bc"
-  }
-}