CodeCrypto CLI

CLI tool para desplegar aplicaciones Next.js/Express y smart contracts con Foundry.

🚀 Instalación Rápida

# Instalación global (recomendado)
npm install -g codecrypto-cli

# O usar sin instalar
npx codecrypto-cli [command]

# Verificar instalación
codecrypto --help

Primeros pasos:

# 1. Validar que todo está listo
codecrypto doctor

# 2. Autenticarse
codecrypto auth

# 3. ¡Listo para usar!

Desarrollo local:

# Clonar repositorio
git clone https://gitlab.codecrypto.academy/codecrypto/codecrypto-cli.git
cd codecrypto-cli

# Instalar dependencias
npm install

# Compilar
npm run build

# Enlazar localmente
npm link

# Probar
codecrypto --help

📋 Guía Rápida de Comandos

| Comando | Descripción | Uso Básico | |---------|-------------|------------| | auth | Autenticarse con CodeCrypto | codecrypto auth | | doctor | Validar sistema y prerequisitos | codecrypto doctor | | deploy | Desplegar app Next.js/Express | codecrypto deploy <ruta-proyecto> | | deploy-sc | Desplegar smart contract | codecrypto deploy-sc <script.s.sol> | | generate-keys | Generar claves Foundry | codecrypto generate-keys |

Ejemplos Rápidos

Desplegar aplicación:

codecrypto deploy ../mi-app --deploy

Desplegar smart contract en Anvil:

codecrypto deploy-sc ./script/Deploy.s.sol --anvil

Generar claves para desarrollo:

codecrypto generate-keys --count 10

Ver ayuda de un comando:

codecrypto deploy --help
codecrypto deploy-sc --help

📖 Documentación Completa de Comandos

🔐 auth - Autenticación

Autentica el CLI con el servidor CodeCrypto.

codecrypto auth
codecrypto auth --force  # Forzar renovación de token

Funcionamiento:

• Genera código de autenticación
• Abre navegador para autorizar
• Guarda token en ~/.codecrypto/token.json
• Incluye certificados Docker en adminGlobals

🏥 doctor - Validación del Sistema

Valida todos los requisitos necesarios para desplegar.

codecrypto doctor
codecrypto doctor --verbose

Valida:

• ✅ Node.js y npm
• ✅ Docker y Docker Buildx
• ✅ Docker Hub authentication
• ✅ CodeCrypto token
• ✅ Certificados Docker (desde token.json)
• ✅ Acceso al servidor proyectos.codecrypto.academy
• ✅ Git
• ✅ Foundry (forge, cast, anvil)
• ✅ Anvil corriendo (puerto 8545)
• ✅ Acceso a cuenta Anvil 0
• ✅ Acceso a red Besu1 (https://besu1.proyectos.codecrypto.academy)
• ✅ Acceso a red Besu2 (https://besu2.proyectos.codecrypto.academy)

🐳 deploy - Despliegue de Aplicaciones

Despliega aplicaciones Next.js o Express usando Docker.

Detección automática: Analiza package.json para detectar el tipo:

• Si tiene next → Next.js
• Si tiene express → Express

# Básico
codecrypto deploy <project-path>

# Con opciones
codecrypto deploy <project-path> [dest-folder] \
  --deploy \
  --service-name mi-app \
  --port 3000 \
  --domain-base proyectos.codecrypto.academy \
  --env-file .env \
  --image-version 1.0.0 \
  --skip-build \
  --no-push \
  --skip-git-check

Opciones:

• <project-path> - Ruta al proyecto (requerido)
• [dest-folder] - Carpeta destino para build Docker (default: ./docker-build)
• --deploy - Desplegar en servidor remoto después del build
• --service-name <name> - Nombre del servicio para Traefik
• --port <port> - Puerto de la aplicación (default: 3000)
• --domain-base <domain> - Dominio base (default: proyectos.codecrypto.academy)
• --env-file <path> - Archivo .env con variables de entorno
• --image-version <version> - Versión/tag de la imagen (sobrescribe package.json)
• --skip-build - Omitir npm run build
• --no-push - Construir pero no hacer push a Docker Hub
• --skip-git-check - Omitir verificación de estado Git

Proceso:

1. Detecta tipo de proyecto (Next.js/Express)
2. Valida estado Git (a menos que se omita)
3. Build del proyecto (si no se omite)
4. Genera Dockerfile optimizado
5. Construye imagen multi-plataforma (linux/amd64, linux/arm64)
6. Push a Docker Hub (si no se omite)
7. Despliega en servidor remoto (si --deploy)

Dockerfile generado:

• Next.js: Usa node:20-alpine, copia .next/standalone, .next/static, public
• Express: Usa node:20-alpine, multi-stage build, solo dependencias de producción

Certificados Docker:

• Se leen desde ~/.codecrypto/token.json → adminGlobals
• Keys: docker-client/ca-pem, docker-client/cert.pem, docker-client/key.pem

🔷 deploy-sc - Despliegue de Smart Contracts

Despliega smart contracts usando Foundry.

# Básico
codecrypto deploy-sc <script-path>

# Con opciones
codecrypto deploy-sc <script-path> \
  --url http://localhost:8545 \
  --private-key 0x... \
  --account 0 \
  --anvil \
  --broadcast \
  --verify \
  --slow \
  --debug

Opciones:

• <script-path> - Ruta al script Foundry .s.sol (requerido)
• -u, --url <rpc-url> - URL RPC (default: https://besu1.proyectos.codecrypto.academy)
• -k, --private-key <key> - Clave privada (o usar PRIVATE_KEY env var)
• --account <index> - Índice de cuenta (para Anvil, usa 0)
• --anvil - Forzar uso de cuenta Anvil 0 (ignora private-key)
• --verify - Verificar contrato en block explorer
• --broadcast - Transmitir transacción (default: true)
• --slow - Modo lento para deployment
• --debug - Mostrar información de debug

Proceso:

1. Valida que el script existe y es .s.sol
2. Detecta proyecto Foundry (busca foundry.toml)
3. Valida el saldo de la cuenta (si se usa --private-key, verifica que tenga al menos 0.001 ETH)
4. Ejecuta forge script con configuración
5. Guarda resultados en broadcast/
6. Sube transacciones a BD vía /api/uploadSmartContract en https://proyectos.proyectos.codecrypto.academy

Validación de saldo:

• Se valida automáticamente cuando se usa --private-key
• Requiere un saldo mínimo de 1.0 ETH para continuar
• Muestra la dirección y el saldo actual antes de desplegar
• Si el saldo es insuficiente, sugiere usar el faucet: https://faucet.codecrypto.academy
• No se valida cuando se usa --anvil o --account (desarrollo local)

Datos subidos a BD:

• Email del usuario
• Carpeta del proyecto
• JSON completo de transacciones (run-latest.json)
• RPC URL usado
• Clave privada (o account-{index})

URL de subida:

• Por defecto: https://proyectos.proyectos.codecrypto.academy/api/uploadSmartContract
• Configurable mediante variable de entorno: CODECRYPTO_UPLOAD_URL o UPLOAD_SMART_CONTRACT_URL

🔑 generate-keys - Generación de Claves Foundry

Genera un archivo de claves Foundry con mnemonic y cuentas derivadas para desarrollo y testing.

# Generar claves con mnemonic aleatorio (10 cuentas por defecto)
codecrypto generate-keys

# Especificar número de cuentas
codecrypto generate-keys --count 20

# Usar mnemonic existente
codecrypto generate-keys --mnemonic "word1 word2 ... word12"

# Especificar archivo de salida
codecrypto generate-keys --output ~/.foundry/keys.json

# Combinar opciones
codecrypto generate-keys \
  --mnemonic "your twelve word mnemonic phrase here" \
  --count 5 \
  --output ./my-keys.json

Opciones:

• -m, --mnemonic <mnemonic> - Frase mnemonic (si no se proporciona, se genera una aleatoria)
• -n, --count <number> - Número de cuentas a generar (default: 10, máximo: 100)
• -o, --output <path> - Ruta del archivo de salida (default: ~/.foundry/keys.json)

Funcionamiento:

1. Genera o valida mnemonic (12 palabras)
2. Deriva cuentas usando el path estándar BIP44: m/44'/60'/0'/0/{index}
3. Guarda todas las cuentas con sus direcciones y claves privadas
4. Crea el directorio de salida si no existe

Formato del archivo generado:

{
  "mnemonic": "word1 word2 word3 ... word12",
  "accounts": [
    {
      "address": "0x...",
      "private_key": "0x..."
    },
    ...
  ]
}

Uso con Foundry:

# Generar claves
codecrypto generate-keys --output ~/.foundry/keys.json

# Usar en scripts Foundry
# Las claves privadas se pueden usar directamente en forge script
forge script Deploy.s.sol \
  --private-key $(jq -r '.accounts[0].private_key' ~/.foundry/keys.json) \
  --rpc-url http://localhost:8545 \
  --broadcast

Seguridad:

• ⚠️ Nunca compartas tu mnemonic o claves privadas
• ⚠️ Nunca commitees el archivo de claves a control de versiones
• ⚠️ Usa estas claves solo para desarrollo y testing
• ⚠️ Para producción, usa un wallet seguro (MetaMask, Ledger, etc.)

Ejemplos de Uso

Desplegar aplicación Next.js

# Build y push a Docker Hub
codecrypto deploy ../mi-app-nextjs

# Build, push y deploy en servidor
codecrypto deploy ../mi-app-nextjs \
  --deploy \
  --service-name mi-app \
  --env-file ../mi-app-nextjs/.env

Desplegar aplicación Express

# Build y push
codecrypto deploy ../mi-api-express

# Con variables de entorno
codecrypto deploy ../mi-api-express \
  --env-file ../mi-api-express/.env \
  --port 3000

Desplegar Smart Contract

# En Anvil local
codecrypto deploy-sc ./script/Deploy.s.sol \
  --url http://localhost:8545 \
  --anvil \
  --broadcast

# En red remota con clave privada
codecrypto deploy-sc ./script/Deploy.s.sol \
  --url https://besu1.proyectos.codecrypto.academy \
  --private-key 0x1234567890abcdef... \
  --broadcast \
  --verify

Generar claves para desarrollo

# Generar claves Foundry
codecrypto generate-keys --count 10

# Usar en script de despliegue
codecrypto deploy-sc ./script/Deploy.s.sol \
  --private-key $(jq -r '.accounts[0].private_key' ~/.foundry/keys.json) \
  --anvil

Workflow completo

# 1. Validar sistema
codecrypto doctor

# 2. Autenticarse (si es necesario)
codecrypto auth

# 3. Generar claves (opcional, para smart contracts)
codecrypto generate-keys

# 4. Desplegar aplicación
codecrypto deploy ../mi-app --deploy

# 5. Desplegar smart contract
codecrypto deploy-sc ./script/Deploy.s.sol --anvil

Estructura del Proyecto

cli-cc/
├── src/
│   ├── index.ts              # Punto de entrada
│   └── commands/
│       ├── auth.ts           # Autenticación
│       ├── deploy.ts         # Deploy Next.js/Express
│       ├── deploy-sc.ts      # Deploy Smart Contracts
│       ├── doctor.ts         # Validación del sistema
│       └── generate-keys.ts  # Generación de claves Foundry
├── dist/                     # Build output
├── package.json
├── tsconfig.json
└── README.md

Desarrollo

# Instalar dependencias
npm install

# Desarrollo (sin compilar)
npm run dev -- deploy --help

# Compilar
npm run build

# Probar localmente
npm link
codecrypto --help

Configuración

Token de autenticación

Guardado en: ~/.codecrypto/token.json

{
  "email": "[email protected]",
  "token": "jwt-token",
  "serverUrl": "http://server.codecrypto.academy",
  "adminGlobals": [
    {
      "key": "docker-client/ca-pem",
      "value": "..."
    },
    {
      "key": "docker-client/cert.pem",
      "value": "..."
    },
    {
      "key": "docker-client/key.pem",
      "value": "..."
    }
  ]
}

Variables de entorno

El CLI puede leer variables de entorno de dos formas:

1. Variables del sistema operativo

Configura las variables en tu shell:

# Linux/Mac
export CODECRYPTO_API_URL=http://server.codecrypto.academy:3000
export API_URL=http://server.codecrypto.academy:3000

# Windows (PowerShell)
$env:CODECRYPTO_API_URL="http://server.codecrypto.academy:3000"
$env:API_URL="http://server.codecrypto.academy:3000"

# Windows (CMD)
set CODECRYPTO_API_URL=http://server.codecrypto.academy:3000
set API_URL=http://server.codecrypto.academy:3000

2. Archivo .env (recomendado)

Crea un archivo ~/.codecrypto/.env con tus variables:

# El folder ~/.codecrypto se crea automáticamente cuando ejecutas 'codecrypto auth' por primera vez
# O puedes crearlo manualmente:
mkdir -p ~/.codecrypto

# Crear archivo .env
cat > ~/.codecrypto/.env << EOF
CODECRYPTO_API_URL=http://server.codecrypto.academy:3000
# O usar API_URL como alternativa
# API_URL=http://server.codecrypto.academy:3000
EOF

Nota: El folder ~/.codecrypto se crea automáticamente la primera vez que ejecutas codecrypto auth, pero puedes crearlo manualmente antes si lo necesitas.

Variables disponibles:

• CODECRYPTO_API_URL o API_URL - URL del servidor API (default: https://proyectos.codecrypto.academy)
• CODECRYPTO_UPLOAD_URL o UPLOAD_SMART_CONTRACT_URL - URL para subir smart contracts (default: https://proyectos.proyectos.codecrypto.academy)

Nota: Las variables del sistema operativo tienen prioridad sobre el archivo .env.

📋 Prerequisitos Detallados

Antes de usar el CLI, asegúrate de tener instalados y configurados los siguientes componentes:

Requisitos Obligatorios

1. Node.js y npm

• Node.js >= 16.0.0 (recomendado: >= 18.0.0)
• npm (incluido con Node.js)

Instalación:

# Verificar versión instalada
node --version
npm --version

# Si no está instalado, descargar desde:
# https://nodejs.org/

2. Docker y Docker Buildx

• Docker >= 20.10.0
• Docker Buildx (incluido en Docker Desktop o instalable por separado)

Instalación:

# Verificar instalación
docker --version
docker buildx version

# Instalar Docker Desktop desde:
# https://www.docker.com/get-started

# O en Linux:
# Ubuntu/Debian
sudo apt-get update
sudo apt-get install docker.io docker-buildx-plugin

# Verificar que el daemon está corriendo
docker info

Configuración Docker Hub:

# Autenticarse en Docker Hub
docker login

# Verificar autenticación
docker info | grep Username

3. Git

• Git >= 2.0.0

Instalación:

# Verificar versión
git --version

# Si no está instalado:
# macOS: viene con Xcode Command Line Tools
xcode-select --install

# Linux
sudo apt-get install git  # Ubuntu/Debian
sudo yum install git      # CentOS/RHEL

# Windows: https://git-scm.com/download/win

Requisitos para Smart Contracts

4. Foundry

• forge (compilador de Solidity)
• cast (herramienta CLI para interactuar con contratos)
• anvil (blockchain local para desarrollo)

Instalación:

# Instalar Foundry
curl -L https://foundry.paradigm.xyz | bash
foundryup

# Verificar instalación
forge --version
cast --version
anvil --version

Configuración:

# Crear proyecto Foundry (opcional, para testing)
forge init my-project
cd my-project

5. Anvil (Blockchain Local)

Anvil debe estar corriendo para desplegar smart contracts localmente.

Iniciar Anvil:

# Configuración recomendada para CodeCrypto
anvil --chain-id 3133731337 --port 55556

# O en puerto estándar
anvil --chain-id 3133731337 --port 8545

Verificar que está corriendo:

# Verificar conexión
cast block-number --rpc-url http://localhost:8545

# O si usas puerto 55556
cast block-number --rpc-url http://localhost:55556

Requisitos para Despliegue Remoto

6. Acceso a Servidores CodeCrypto

• Acceso a proyectos.codecrypto.academy (para despliegue de aplicaciones)
• Acceso a besu1.proyectos.codecrypto.academy (red blockchain Besu 1)
• Acceso a besu2.proyectos.codecrypto.academy (red blockchain Besu 2)

Verificar conectividad:

# Verificar acceso a servidor de proyectos
curl -I https://proyectos.codecrypto.academy

# Verificar acceso a redes blockchain
curl -I https://besu1.proyectos.codecrypto.academy
curl -I https://besu2.proyectos.codecrypto.academy

Verificación Completa

Ejecuta el comando doctor para validar todos los prerequisitos:

codecrypto doctor

O con información detallada:

codecrypto doctor --verbose

Requisitos (Resumen)

Resumen rápido:

• Node.js >= 16.0.0 (recomendado >= 18.0.0)
• Docker y Docker Buildx
• Git
• Foundry (forge, cast, anvil)
• Anvil corriendo (puerto 8545 o 55556)
• Acceso a servidores CodeCrypto

Verificación rápida:

codecrypto doctor

Para instrucciones detalladas de instalación, consulta la sección Prerequisitos Detallados arriba.

Ayuda

# Ayuda general
codecrypto --help

# Ayuda de comando específico
codecrypto deploy --help
codecrypto deploy-sc --help
codecrypto auth --help
codecrypto doctor --help
codecrypto generate-keys --help

Publicación a NPM

# 1. Build
npm run build

# 2. Login
npm login

# 3. Publicar
npm publish

# 4. Actualizar versión
npm version patch|minor|major
npm publish

Licencia

MIT