@purecore/one-server-4-all 0.1.0

package/src/cert-generator.ts

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+export class CertGenerator {
+    private static readonly CERT_DIR = '.hot-server-certs';
+    private static readonly KEY_FILE = 'localhost.key';
+    private static readonly CERT_FILE = 'localhost.crt';
+
+    static async generateCerts() {
+        const certDir = path.join(process.cwd(), this.CERT_DIR);
+        const keyPath = path.join(certDir, this.KEY_FILE);
+        const certPath = path.join(certDir, this.CERT_FILE);
+
+        try {
+            // Verificar se certificados já existem
+            try {
+                await fs.access(keyPath);
+                await fs.access(certPath);
+                console.log('📋 Certificados já existem em:', certDir);
+                return { keyPath, certPath };
+            } catch {
+                // Certificados não existem, vamos criar
+            }
+
+            // Criar diretório se não existir
+            await fs.mkdir(certDir, { recursive: true });
+
+            console.log('🔐 Gerando certificados auto-assinados...');
+
+            // Observação importante:
+            // Gerar um X509 "de verdade" apenas com node:crypto (sem libs externas) não é trivial.
+            // Como este projeto roda no WSL, utilizamos o OpenSSL (toolchain padrão do Linux)
+            // para gerar um par key/cert PEM válido e compatível com Bun/BoringSSL.
+            await this.generateWithOpenSSL({ keyPath, certPath });
+
+            // Validação do PEM (evita subir servidor com arquivo corrompido)
+            const [keyPem, certPem] = await Promise.all([
+                fs.readFile(keyPath, 'utf8'),
+                fs.readFile(certPath, 'utf8')
+            ]);
+            this.validatePem({ keyPem, certPem, keyPath, certPath });
+            this.validateX509(certPem, certPath);
+            this.validateWithOpenSSL(certPath);
+
+            console.log('✅ Certificados gerados com sucesso!');
+            console.log('📁 Localização:', certDir);
+            console.log('🔑 Chave privada:', keyPath);
+            console.log('📄 Certificado:', certPath);
+            console.log('');
+            console.log('⚠️  AVISO: Estes são certificados auto-assinados para desenvolvimento local.');
+            console.log('   Não use em produção!');
+
+            return { keyPath, certPath };
+
+        } catch (error) {
+            console.error('❌ Erro ao gerar certificados:', error);
+            throw error;
+        }
+    }
+
+    private static generateWithOpenSSL(params: { keyPath: string; certPath: string }) {
+        const { keyPath, certPath } = params;
+        const subj = '/C=BR/ST=SP/L=Sao Paulo/O=Purecore/OU=Dev/CN=localhost';
+
+        // Preferimos SAN para evitar problemas em clients modernos.
+        // Nem todo OpenSSL antigo suporta -addext, então fazemos fallback.
+        const baseArgs = ['req', '-x509', '-newkey', 'rsa:2048', '-keyout', keyPath, '-out', certPath, '-days', '365', '-nodes', '-subj', subj];
+
+        try {
+            execFileSync('openssl', [...baseArgs, '-addext', 'subjectAltName=DNS:localhost,IP:127.0.0.1'], { stdio: 'inherit' });
+        } catch {
+            execFileSync('openssl', baseArgs, { stdio: 'inherit' });
+        }
+    }
+
+    private static validatePem(params: { keyPem: string; certPem: string; keyPath: string; certPath: string }) {
+        const { keyPem, certPem, keyPath, certPath } = params;
+        const keyOk =
+            keyPem.includes('-----BEGIN PRIVATE KEY-----') ||
+            keyPem.includes('-----BEGIN RSA PRIVATE KEY-----');
+        const certOk = certPem.includes('-----BEGIN CERTIFICATE-----');
+
+        if (!keyOk || !certOk) {
+            throw new Error(
+                `PEM inválido gerado. ` +
+                `keyOk=${keyOk} certOk=${certOk}. ` +
+                `keyPath=${keyPath} certPath=${certPath}`
+            );
+        }
+    }
+
+    private static validateX509(certPem: string, certPath: string) {
+        try {
+            // Node valida a estrutura do X509 e falha se base64/DER estiverem inválidos.
+            // Isso é um bom "gate" antes de subir o https.createServer().
+            // @ts-ignore - Bun/Node expõem X509Certificate em node:crypto
+            const x509 = new crypto.X509Certificate(certPem);
+            if (!x509.subject) {
+                throw new Error('X509 sem subject');
+            }
+        } catch (error: any) {
+            throw new Error(`Certificado X509 inválido em ${certPath}: ${error?.message || String(error)}`);
+        }
+    }
+
+    private static validateWithOpenSSL(certPath: string) {
+        try {
+            // OpenSSL é a validação "ground truth" no WSL.
+            execFileSync('openssl', ['x509', '-in', certPath, '-noout'], { stdio: 'ignore' });
+        } catch (error: any) {
+            throw new Error(`OpenSSL não conseguiu ler o certificado (${certPath}).`);
+        }
+    }
+
+    static async getCertPaths(): Promise<{ keyPath: string; certPath: string } | null> {
+        const certDir = path.join(process.cwd(), this.CERT_DIR);
+        const keyPath = path.join(certDir, this.KEY_FILE);
+        const certPath = path.join(certDir, this.CERT_FILE);
+
+        try {
+            await fs.access(keyPath);
+            await fs.access(certPath);
+            return { keyPath, certPath };
+        } catch {
+            return null;
+        }
+    }
+
+    static async cleanCerts() {
+        const certDir = path.join(process.cwd(), this.CERT_DIR);
+
+        try {
+            await fs.rm(certDir, { recursive: true, force: true });
+            console.log('🗑️  Certificados removidos:', certDir);
+        } catch (error) {
+            console.error('❌ Erro ao remover certificados:', error);
+        }
+    }
+}
+
+// Executar se chamado diretamente
+if (typeof require !== 'undefined' && require.main === module) {
+    const command = process.argv[2];
+
+    switch (command) {
+        case 'generate':
+        case undefined:
+            CertGenerator.generateCerts().catch(console.error);
+            break;
+        case 'clean':
+            CertGenerator.cleanCerts().catch(console.error);
+            break;
+        case 'info':
+            CertGenerator.getCertPaths().then(paths => {
+                if (paths) {
+                    console.log('📋 Certificados encontrados:');
+                    console.log('🔑 Chave:', paths.keyPath);
+                    console.log('📄 Certificado:', paths.certPath);
+                } else {
+                    console.log('❌ Nenhum certificado encontrado');
+                }
+            }).catch(console.error);
+            break;
+        default:
+            console.log('Uso: cert-generator [generate|clean|info]');
+            console.log('  generate: Gera certificados auto-assinados (padrão)');
+            console.log('  clean: Remove certificados existentes');
+            console.log('  info: Mostra informações dos certificados');
+    }
+}

package/src/deployer.ts

@@ -0,0 +1,182 @@
+import { exec } from "node:child_process";
+import readline from "node:readline";
+import path from "node:path";
+import fs from "node:fs/promises";
+
+const cyan = (text: string) => `\x1b[36m${text}\x1b[0m`;
+const green = (text: string) => `\x1b[32m${text}\x1b[0m`;
+const bold = (text: string) => `\x1b[1m${text}\x1b[0m`;
+const gray = (text: string) => `\x1b[90m${text}\x1b[0m`;
+const magenta = (text: string) => `\x1b[35m${text}\x1b[0m`;
+const yellow = (text: string) => `\x1b[33m${text}\x1b[0m`;
+
+export class Deployer {
+  private rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  private question(query: string): Promise<string> {
+    return new Promise((resolve) => this.rl.question(query, resolve));
+  }
+
+  private printBanner() {
+    console.log(
+      `\n  ${bold(magenta("🚀 HOT-SERVER DEPLOYER"))} ${gray("v0.4.0")}`
+    );
+    console.log(`  ${gray("─────────────────────────────────────────")}\n`);
+  }
+
+  public async start() {
+    this.printBanner();
+
+    const domain = await this.question(
+      `  ${cyan("➜")} ${bold("Qual o domínio/subdomínio?")} ${gray(
+        "(ex: app.meusite.com)"
+      )}\n    ${green("❯")} `
+    );
+
+    if (!domain) {
+      console.log(`\n  ${yellow("⚠")} Domínio é obrigatório. Cancelando...\n`);
+      this.rl.close();
+      return;
+    }
+
+    const port =
+      (await this.question(
+        `  ${cyan("➜")} ${bold("Qual a porta do servidor?")} ${gray(
+          "(padrão 6000)"
+        )}\n    ${green("❯")} `
+      )) || "6000";
+
+    const confirmNginx = await this.question(
+      `  ${cyan("➜")} ${bold(
+        "Deseja configurar Nginx + SSL (Certbot) agora?"
+      )} ${gray("(s/n)")}\n    ${green("❯")} `
+    );
+
+    let certPaths = { key: "", cert: "" };
+
+    if (confirmNginx.toLowerCase() === "s") {
+      const success = await this.setupNginx(domain, port);
+      if (success) {
+        // Caminhos padrão do Certbot
+        certPaths.key = `/etc/letsencrypt/live/${domain}/privkey.pem`;
+        certPaths.cert = `/etc/letsencrypt/live/${domain}/fullchain.pem`;
+      }
+    }
+
+    const name = domain.split(".")[0];
+
+    // Monta o comando PM2
+    // Se temos certificados do Certbot e o usuário quer usar no node direto (embora com nginx proxy não precise necessariamente)
+    // O user pediu para "ter o caminho para apontar para eles".
+    // Vamos gerar o comando COM os certificados se eles existirem, e setar https=true
+
+    let pm2Command = `pm2 start dist/index.js --name "${domain}" -- --port=${port} --open=false`;
+
+    if (certPaths.key && certPaths.cert) {
+      // Nota: Node node pode não ter permissão de ler /etc/letsencrypt diretamente dependendo do user
+      // Mas vamos atender o pedido de colocar o caminho
+      pm2Command += ` --https=true --ssl-key="${certPaths.key}" --ssl-cert="${certPaths.cert}"`;
+    } else {
+      // Se nao tem certbot, roda http normal (ou auto-assinado se forcer https)
+      pm2Command += ` --https=false`;
+    }
+
+    console.log(`\n  ${bold("📦 Configuração Final:")}`);
+    console.log(`  ${gray("────────────────────────")}`);
+    console.log(`  ${bold("Dominio:")} ${cyan(domain)}`);
+    console.log(`  ${bold("Porta:")}   ${cyan(port)}`);
+    if (certPaths.key) {
+      console.log(`  ${bold("SSL:")}     ${green("Configurado via Certbot")}`);
+    }
+    console.log(`  ${bold("PM2:")}     ${yellow(pm2Command)}`);
+    console.log(`  ${gray("────────────────────────")}\n`);
+
+    console.log(`  ${bold(green("✨ Deploy concluído com sucesso!"))}`);
+    console.log(
+      `  ${gray("Copie e execute o comando acima para iniciar o servidor.")}\n`
+    );
+
+    this.rl.close();
+  }
+
+  private async setupNginx(domain: string, port: string): Promise<boolean> {
+    console.log(`\n  ${bold("🛠️  Iniciando configuração Nginx...")}`);
+
+    // Configuração inicial HTTP para o Certbot validar
+    const nginxConfig = `
+server {
+    listen 80;
+    server_name ${domain};
+
+    location / {
+        proxy_pass http://127.0.0.1:${port};
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_cache_bypass $http_upgrade;
+    }
+}
+`;
+
+    const tempFilePath = `/tmp/${domain}.conf`;
+    const sitesAvailable = `/etc/nginx/sites-available/${domain}`;
+    const sitesEnabled = `/etc/nginx/sites-enabled/${domain}`;
+
+    try {
+      console.log(`  ${gray("➜")} Criando arquivo temporário...`);
+      await fs.writeFile(tempFilePath, nginxConfig);
+
+      console.log(
+        `  ${gray("➜")} Movendo para sites-available (requer sudo)...`
+      );
+      await this.runCommand(`sudo mv ${tempFilePath} ${sitesAvailable}`);
+
+      console.log(`  ${gray("➜")} Testando configuração do Nginx...`);
+      await this.runCommand(`sudo nginx -t`);
+
+      console.log(`  ${gray("➜")} Ativando site...`);
+      await this.runCommand(`sudo ln -sf ${sitesAvailable} ${sitesEnabled}`);
+
+      console.log(`  ${gray("➜")} Recarregando Nginx...`);
+      await this.runCommand(`sudo systemctl reload nginx`);
+
+      console.log(`  ${gray("➜")} Executando Certbot...`);
+      console.log(`  ${yellow("⚠ Aguarde...")}`);
+
+      // Roda certbot e pede para ele configurar o redirect HTTPS no Nginx automaticamente
+      await this.runCommand(
+        `sudo certbot --nginx -d ${domain} --non-interactive --agree-tos --redirect -m admin@${domain
+          .split(".")
+          .slice(-2)
+          .join(".")}`
+      );
+
+      console.log(`  ${green("✔")} Nginx e SSL configurados com sucesso!`);
+      return true;
+    } catch (error: any) {
+      console.error(
+        `\n  ${yellow("❌ Erro na configuração:")} ${error.message}`
+      );
+      console.log(
+        `  ${gray("Continuando apenas com a geração do comando...")}`
+      );
+      return false;
+    }
+  }
+
+  private runCommand(command: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      exec(command, (error, stdout, stderr) => {
+        if (error) {
+          reject(new Error(stderr || stdout || error.message));
+          return;
+        }
+        resolve(stdout);
+      });
+    });
+  }
+}

package/src/index.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+// File: src/index.ts
+import { HotServer } from "./server.js";
+import { Deployer } from "./deployer.js";
+import { configSchema } from "./validator.js";
+import path from "node:path";
+
+const args = process.argv.slice(2);
+
+// Check for deploy command
+if (args[0] === "deploy") {
+  const deployer = new Deployer();
+  deployer.start();
+} else {
+  // Parsing manual simplificado de args (ex: --port=3000)
+  // ... resto do código
+  const getArg = (key: string, defaultVal: string) => {
+    const arg = args.find((a) => a.startsWith(`--${key}=`));
+    const arg2 = args.find((a) => a.startsWith(`-${key}=`));
+    return arg ? arg.split("=")[1] : arg2 ? arg2.split("=")[1] : defaultVal;
+  };
+
+  // Se o primeiro argumento não tiver --, assumimos que é a pasta
+  const rootArg = args[0] && !args[0].startsWith("--") ? args[0] : ".";
+
+  const rawConfig = {
+    port: parseInt(getArg("port", "6000")),
+    root: path.resolve(process.cwd(), rootArg),
+    open: getArg("open", "true"), // 'true' por padrão
+    spa: getArg("spa", "false"), // 'false' por padrão
+    https: getArg("https", "false"), // 'false' por padrão
+  };
+
+  try {
+    // Validação "Zod-like"
+    const config = configSchema.parse(rawConfig);
+
+    const app = new HotServer(config);
+    app.start();
+  } catch (error: any) {
+    console.error("❌ Erro de configuração:", error.message);
+    process.exit(1);
+  }
+}