br-agefy 1.0.0

package/index.js

@@ -0,0 +1,65 @@
+const express = require('express');
+const fs = require('fs');
+const fsp = fs.promises;
+const path = require('path');
+const { v4: uuidv4 } = require('uuid');
+const cors = require('cors');
+const { processarDocumento } = require('./processador.js');
+const PORT = process.env.PORT || 3000;
+const app = express();
+app.use(express.json({ limit: '15mb' }));
+app.use(cors());
+
+const uploadsPath = path.join(__dirname, 'uploads');
+if (!fs.existsSync(uploadsPath)) {
+    fs.mkdirSync(uploadsPath);
+}
+
+app.post('/verify', async (req, res) => {
+    let caminhoArquivo = "";
+    try {
+        const { imagem } = req.body;
+        if (!imagem) return res.status(400).json({ sucesso: false, mensagem: "Sem imagem" });
+
+        const base64Limpo = imagem.includes(',') ? imagem.split(',')[1] : imagem;
+        const buffer = Buffer.from(base64Limpo, 'base64');
+
+        // Salvamos como .jpg para fugir do erro de libspng do PNG
+        const nomeArquivo = `${uuidv4()}.jpg`;
+        caminhoArquivo = path.join(uploadsPath, nomeArquivo);
+        
+        await fsp.writeFile(caminhoArquivo, buffer);
+        
+        // Delay de segurança: 100ms para o Windows soltar o arquivo
+        await new Promise(resolve => setTimeout(resolve, 100));
+
+        console.log(`✅ Arquivo pronto para processar: ${nomeArquivo}`);
+
+        const resultado = await processarDocumento(caminhoArquivo);
+
+        // Deleta o original
+        if (fs.existsSync(caminhoArquivo)) fs.unlinkSync(caminhoArquivo);
+
+        if (!resultado || !resultado.sucesso) {
+            return res.status(403).json({ 
+                sucesso: false, 
+                codigo: "INVALID_DOCUMENT", 
+                mensagem: resultado ? resultado.mensagem : "Erro no processamento" 
+            });
+        }
+
+        return res.json({
+            sucesso: true,
+            codigo: "VERIFIED",
+            idade: resultado.idade,
+            cpfValido: resultado.cpfValido
+        });
+
+    } catch (err) {
+        console.error("❌ Erro na Rota:", err.message);
+        if (caminhoArquivo && fs.existsSync(caminhoArquivo)) try { fs.unlinkSync(caminhoArquivo); } catch(e){}
+        return res.status(500).json({ sucesso: false, codigo: "SERVER_ERROR", mensagem: err.message });
+    }
+});
+
+app.listen(PORT, () => console.log("🔥 Agefy API rodando em http://localhost:3000"));

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "br-agefy",
+  "version": "1.0.0",
+  "description": "Um sistema criado para desenvolvedores Brasileiros verificarem a idade de seus usuários sem ter que gastar nada.",
+  "main": "processador.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "cpf-cnpj-validator": "^1.0.3",
+    "sharp": "^0.34.5",
+    "tesseract.js": "^7.0.0",
+    "uuid": "^13.0.0"
+  }
+}

package/processador.js

@@ -0,0 +1,118 @@
+const sharp = require('sharp');
+const Tesseract = require('tesseract.js');
+const fs = require('fs');
+const path = require('path');
+const { cpf: cpfValidator } = require('cpf-cnpj-validator');
+
+/**
+ * Agefy: Motor de OCR e Validação de Identidade
+ * Desenvolvido por Davi de Castro
+ */
+async function processarDocumento(caminho) {
+    // Define o nome do arquivo temporário para o processamento
+    const caminhoTratado = `${caminho}_treated.jpg`;
+    const diretorio = path.dirname(caminho);
+
+    try {
+        // 1. Garantia de Infraestrutura: Cria a pasta se ela não existir
+        if (!fs.existsSync(diretorio)) {
+            fs.mkdirSync(diretorio, { recursive: true });
+        }
+
+        // 2. Verificação de Entrada
+        if (!fs.existsSync(caminho)) {
+            throw new Error("Arquivo original não encontrado no caminho especificado.");
+        }
+
+        // 3. Pré-processamento com Sharp (Otimizado para Tesseract)
+        // Aplicamos grayscale e threshold para remover ruídos do fundo do RG/CIN
+        await sharp(caminho)
+            .resize(1300) 
+            .grayscale()
+            .threshold(120) 
+            .jpeg({ quality: 90 })
+            .toFile(caminhoTratado);
+
+        // 4. Execução do OCR
+        const { data: { text } } = await Tesseract.recognize(caminhoTratado, 'por');
+
+        if (!text || text.trim().length < 10) {
+            return { sucesso: false, mensagem: "Não foi possível extrair texto legível da imagem." };
+        }
+
+        // 5. Validação de Autenticidade Básica
+        const textoNormalizado = text.normalize("NFD")
+            .replace(/[\u0300-\u036f]/g, "")
+            .toUpperCase()
+            .replace(/\s+/g, "");
+
+        if (!textoNormalizado.includes("REPUBLICAFEDERATIVADOBRASIL")) {
+            return { sucesso: false, mensagem: "O documento não parece ser uma Identidade Brasileira oficial." };
+        }
+
+        // 6. Extração de Dados com Regex
+        const regexCPF = /\d{3}[.\s]?\d{3}[.\s]?\d{3}[-\s]?\d{2}/;
+        const regexData = /\d{2}\/\d{2}\/\d{4}/g;
+
+        const cpfEncontrado = text.match(regexCPF);
+        const datasEncontradas = text.match(regexData);
+
+        if (!cpfEncontrado || !datasEncontradas || datasEncontradas.length < 2) {
+            return { sucesso: false, mensagem: "CPF ou datas (nascimento/validade) não detectados." };
+        }
+
+        // 7. Validação de CPF
+        const cpfLimpo = cpfEncontrado[0].replace(/[^\d]/g, '');
+        if (!cpfValidator.isValid(cpfLimpo)) {
+            return { sucesso: false, mensagem: "O CPF lido é matematicamente inválido." };
+        }
+
+        // 8. Cálculo de Idade e Validade
+        // Assumindo: data[0] = Nascimento, data[1] = Validade (Padrão CIN)
+        const [diaN, mesN, anoN] = datasEncontradas[0].split('/').map(Number);
+        const [diaV, mesV, anoV] = datasEncontradas[1].split('/').map(Number);
+
+        const dataAtual = new Date();
+        const anoAtual = dataAtual.getFullYear();
+
+        if (anoV < anoAtual) {
+            return { sucesso: false, mensagem: "Documento expirado." };
+        }
+
+        const dataNascimento = new Date(anoN, mesN - 1, diaN);
+        let idade = anoAtual - dataNascimento.getFullYear();
+        
+        if (dataAtual.getMonth() < dataNascimento.getMonth() || 
+           (dataAtual.getMonth() === dataNascimento.getMonth() && dataAtual.getDate() < dataNascimento.getDate())) {
+            idade--;
+        }
+
+        // 9. Retorno de Sucesso
+        return { 
+            sucesso: true, 
+            dados: {
+                idade: idade,
+                cpf: cpfLimpo,
+                validade: datasEncontradas[1]
+            }
+        };
+
+    } catch (error) {
+        console.error(`[Agefy Engine Error]: ${error.message}`);
+        return { 
+            sucesso: false, 
+            mensagem: "Erro interno ao processar o documento." 
+        };
+    } finally {
+        // 10. Limpeza de Arquivos Temporários (Privacidade/LGPD)
+        if (fs.existsSync(caminhoTratado)) {
+            try {
+                fs.unlinkSync(caminhoTratado);
+            } catch (err) {
+                console.error("[Agefy Security]: Erro ao deletar rastro temporário.");
+            }
+        }
+    }
+}
+
+module.exports = { processarDocumento };