new logs, removing sharp as dependency, stickers are resized

[repo] desacoplamento e maior coesão

.gitignore

@@ -1,7 +1,8 @@
-env.js
+env
 .wwebjs_auth
 .wwebjs_cache
 downloads
+src/node_modules/
 node_modules/
 cookies.txt
 bin/

deploy.sh

@@ -1,4 +1,44 @@
 #!/bin/bash
 
-TAG=$(git describe --tags --abbrev=0)
-npm version $TAG --no-git-tag-version
+# development tool
+# ./deploy <commit> <branch> <version (if branch=master)>
+
+COMMIT_MSG="$1"
+BRANCH="$2"
+VERSION="$3"
+
+if [ -z "$COMMIT_MSG" ] || [ -z "$BRANCH" ]; then
+    echo "Uso: ./deploy <commit> <branch> [version if branch=master]"
+    exit 1
+fi
+
+echo "Rewriting config.js"
+cat > "src/config.js" << 'EOF'
+export const CLIENT_ID = "bot_permanente";
+export const BOT_PREFIX = "🤖 *ManyBot:* ";
+export const CHATS = [
+    // coloque os chats que quer aqui
+];
+EOF
+
+# mudar para a branch
+git checkout $BRANCH || { echo "Error ao change to $BRANCH"; exit 1; }
+
+# adicionar alterações e commit
+git add .
+git commit -m "$COMMIT_MSG"
+
+# push
+git push origin $BRANCH
+
+# se for master, atualizar versão
+if [ "$BRANCH" == "master" ] && [ -n "$VERSION" ]; then
+    echo "Updating version to $VERSION"
+    git tag $VERSION
+    npm version $VERSION --no-git-tag-version
+    git add package.json
+    git commit -m "Bump version to $VERSION"
+    git push origin $VERSION
+fi
+
+echo "Deploy completed."

main.js

@@ -1,380 +0,0 @@
-console.log("[CARREGANDO] Aguarde...");
-
-import pkg from 'whatsapp-web.js';
-const { Client, LocalAuth, MessageMedia } = pkg;
-
-import qrcode from 'qrcode-terminal';
-import fs from 'fs';
-import { exec, spawn } from 'child_process';
-import sharp from 'sharp';
-import os from 'os';
-import path from "path";
-
-console.log(os.platform());
-
-import { CHATS } from "./env.js";
-
-const CLIENT_ID = "bot_permanente";
-const BOT_PREFIX = "🤖 *ManyBot:* ";
-
-let jogoAtivo = null;
-
-if (!fs.existsSync("downloads")) fs.mkdirSync("downloads");
-
-const client = new Client({
-    authStrategy: new LocalAuth({ clientId: CLIENT_ID }),
-    puppeteer: { headless: true }
-});
-
-function botMsg(texto) {
-    return `${BOT_PREFIX}\n${texto}`;
-}
-
-function getChatId(chat) {
-    return chat.id._serialized;
-}
-
-// ---------------- Eventos ----------------
-
-client.on("qr", qr => {
-    console.log("[BOT] Escaneie o QR Code");
-    qrcode.generate(qr, { small: true });
-});
-
-client.on("ready", () => {
-    exec("clear");
-    console.log("[BOT] WhatsApp conectado.");
-});
-
-client.on("disconnected", reason => {
-    console.warn("[BOT] Reconectando:", reason);
-    setTimeout(() => client.initialize(), 5000);
-});
-
-client.on("message_create", async msg => {
-    try {
-        const chat = await msg.getChat();
-        const chatId = getChatId(chat);
-
-        if (!CHATS.includes(chatId)) return;
-
-        console.log("==================================");
-        console.log(`CHAT NAME : ${chat.name || chat.id.user}`);
-        console.log(`CHAT ID   : ${chatId}`);
-        console.log(`FROM      : ${msg.from}`);
-        console.log(`BODY      : ${msg.body}`);
-        console.log("==================================\n");
-
-        await processarComando(msg, chat, chatId);
-        await processarJogo(msg, chat);
-
-    } catch (err) {
-        console.error("[ERRO]", err);
-    }
-});
-
-// ---------------- Download ----------------
-
-let downloadQueue = [];
-let processingQueue = false;
-
-function run(cmd, args) {
-    return new Promise((resolve, reject) => {
-        const proc = spawn(cmd, args);
-
-        let stdout = "";
-
-        proc.stdout.on("data", data => {
-            const text = data.toString();
-            stdout += text;
-            console.log("[cmd]", text);
-        });
-
-        proc.stderr.on("data", data => {
-            console.error("[cmd ERR]", data.toString());
-        });
-
-        proc.on("close", code => {
-            if (code !== 0) reject(new Error("Processo saiu com código " + code));
-            else resolve(stdout);
-        });
-    });
-}
-
-const so = os.platform();
-
-async function get_video(url, id) {
-    let cmd = "";
-    const cmd_lin = "./bin/yt-dlp";
-    const cmd_win = ".\\bin\\yt-dlp.exe";
-
-    switch (so) {
-        case "win32":
-            cmd = cmd_win;
-            break;
-        case "linux":
-            cmd = cmd_lin;
-            break;
-    }
-
-    const args = [
-      '--extractor-args', 'youtube:player_client=android', // mantém seu client preferido
-      '-f', 'bv+ba/best',                                 // tentar vídeo+áudio; fallback para best
-      '--print', 'after_move:filepath',
-      '--output', `downloads/${id}.%(ext)s`,
-    
-      // autenticacao (use cookies exportado com yt-dlp ou --cookies-from-browser)
-      '--cookies', 'cookies.txt',                         // arquivo de cookies (gerar antes)
-      // cabeçalhos para reduzir 403
-      '--add-header', 'User-Agent:Mozilla/5.0 (Windows NT 10.0; Win64; x64)',
-      '--add-header', 'Referer:https://www.youtube.com/',
-      // tolerância de rede
-      '--retries', '4',
-      '--fragment-retries', '5',
-      '--socket-timeout', '15',
-      '--sleep-interval', '1', '--max-sleep-interval', '4',
-      // permitir formatos que podem ser marcados como "unplayable" (útil em alguns casos)
-      '--allow-unplayable-formats',
-      // testes / debug: use -v quando precisar diagnosticar
-      // url
-      url
-    ];
-
-    const stdout = await run(cmd, args);
-    const filepath = stdout.trim();
-    if (!filepath) throw new Error("yt-dlp não retornou caminho");
-
-    return filepath;
-}
-
-async function get_audio(url, id) {
-    const video = await get_video(url, id);
-    const output = `downloads/${id}.mp3`;
-
-    let cmd = "";
-    const cmd_lin = "./bin/ffmpeg";
-    const cmd_win = ".\\bin\\ffmpeg.exe";
-
-    switch (so) {
-        case "win32":
-            cmd = cmd_win;
-            break;
-        case "linux":
-            cmd = cmd_lin;
-            break;
-    }
-
-    const args = [
-      '-i', video,
-      '-vn', '-acodec',
-      'libmp3lame', '-q:a', '2',
-      output
-    ];
-
-    await run(cmd, args);
-
-    return output;
-}
-
-function empty_folder(folder) {
-    fs.readdirSync(folder).forEach(file => {
-        const filePath = path.join(folder, file);
-        if (fs.lstatSync(filePath).isFile()) {
-            fs.unlinkSync(filePath);
-        }
-    });
-}
-
-async function enviarVideo(chatId, path) {
-    const file = fs.readFileSync(path);
-    const media = new MessageMedia(
-        "video/mp4",
-        file.toString("base64"),
-        path.split("/").pop()
-    );
-    await client.sendMessage(chatId, media);
-    fs.unlinkSync(path);
-    empty_folder("./downloads");
-}
-
-async function enviarAudio(chatId, path) {
-    const file = fs.readFileSync(path);
-    const media = new MessageMedia(
-        "audio/mpeg",
-        file.toString("base64"),
-        path.split("/").pop()
-    );
-    await client.sendMessage(chatId, media);
-    fs.unlinkSync(path);
-    empty_folder("./downloads");
-}
-
-function enqueueDownload(type, url, msg, chatId) {
-    downloadQueue.push({ type, url, msg, chatId });
-    if (!processingQueue) processQueue();
-}
-
-async function processQueue() {
-    processingQueue = true;
-    while (downloadQueue.length) {
-        const job = downloadQueue.shift();
-        try {
-            let path;
-            if (job.type === "video")
-                path = await get_video(job.url, job.msg.id._serialized);
-            else
-                path = await get_audio(job.url, job.msg.id._serialized);
-
-            if (job.type === "video")
-                await enviarVideo(job.chatId, path);
-            else
-                await enviarAudio(job.chatId, path);
-
-        } catch (err) {
-            await client.sendMessage(
-                job.chatId,
-                botMsg(`❌ Erro ao baixar ${job.type}\n\`${err.message}\``)
-            );
-        }
-    }
-    processingQueue = false;
-}
-
-// ---------------- Figurinha ----------------
-
-async function gerarSticker(msg) {
-    if (!msg.hasMedia) {
-        await msg.reply(botMsg("Envie uma imagem junto com o comando: `!figurinha`."));
-        return;
-    }
-
-    const media = await msg.downloadMedia();
-    const ext = media.mimetype.split("/")[1];
-
-    const input = `downloads/${msg.id._serialized}.${ext}`;
-    const output = `downloads/${msg.id._serialized}.webp`;
-
-    fs.writeFileSync(input, Buffer.from(media.data, "base64"));
-
-    await sharp(input)
-        .resize(512, 512, { fit: "contain", background: { r:0,g:0,b:0,alpha:0 } })
-        .webp()
-        .toFile(output);
-
-    const data = fs.readFileSync(output);
-    const sticker = new MessageMedia("image/webp", data.toString("base64"), "sticker.webp");
-    const chat = await msg.getChat();
-
-    await client.sendMessage(chat.id._serialized, sticker, { sendMediaAsSticker: true });
-
-    fs.unlinkSync(input);
-    fs.unlinkSync(output);
-}
-
-// ---------------- Comandos ----------------
-
-async function processarComando(msg, chat, chatId) {
-    const tokens = msg.body.trim().split(/\s+/);
-    try {
-        switch(tokens[0]) {
-            case "!many":
-                await chat.sendMessage(botMsg(
-                    "Comandos:\n\n"+
-                    "`!ping`\n"+
-                    "`!video <link>`\n"+
-                    "`!audio <link>`\n"+
-                    "`!figurinha`\n"+
-                    "`!adivinhação começar|parar`\n"+
-                    "`!info <comando>`"
-                ));
-            break;
-
-            case "!ping":
-                await msg.reply(botMsg("pong 🏓"));
-            break;
-
-            case "!video":
-                if (!tokens[1]) return;
-                await msg.reply(botMsg("⏳ Baixando vídeo..."));
-                enqueueDownload("video", tokens[1], msg, chatId);
-            break;
-
-            case "!audio":
-                if (!tokens[1]) return;
-                await msg.reply(botMsg("⏳ Baixando áudio..."));
-                enqueueDownload("audio", tokens[1], msg, chatId);
-            break;
-
-            case "!figurinha":
-                await gerarSticker(msg);
-            break;
-
-            case "!adivinhação":
-                if (!tokens[1]) {
-                    await chat.sendMessage(botMsg("`!adivinhação começar`\n`!adivinhação parar`"));
-                    return;
-                }
-                if (tokens[1] === "começar") {
-                    jogoAtivo = Math.floor(Math.random()*100)+1;
-                    await chat.sendMessage(botMsg("Adivinhe o número de 1 a 100!"));
-                }
-                if (tokens[1] === "parar") {
-                    jogoAtivo = null;
-                    await chat.sendMessage(botMsg("Jogo encerrado."));
-                }
-            break;
-
-            case "A":
-            case "a":
-                if (!tokens[1]) await msg.reply(botMsg("B!"));
-            break;
-
-            case "!info":
-                if (!tokens[1]) {
-                    await chat.sendMessage(botMsg("Use:\n`!info <comando>`"));
-                    return;
-                }
-                switch(tokens[1]) {
-                    case "ping":
-                        await chat.sendMessage(botMsg("> `!ping`\nResponde pong."));
-                    break;
-                    case "video":
-                        await chat.sendMessage(botMsg("> `!video <link>`\nBaixa vídeo da internet."));
-                    break;
-                    case "audio":
-                        await chat.sendMessage(botMsg("> `!audio <link>`\nBaixa áudio da internet."));
-                    break;
-                    case "figurinha":
-                        await chat.sendMessage(botMsg("`!figurinha`\nTransforma imagem/GIF em sticker."));
-                    break;
-                    default:
-                        await chat.sendMessage(botMsg(`❌ Comando '${tokens[1]}' não encontrado.`));
-                }
-            break;
-        }
-    } catch(err) {
-        console.error(err);
-        await chat.sendMessage(botMsg("Erro:\n`"+err.message+"`"));
-    }
-}
-
-// ---------------- Jogo ----------------
-
-async function processarJogo(msg, chat) {
-    if (!jogoAtivo) return;
-
-    const tentativa = msg.body.trim();
-    if (!/^\d+$/.test(tentativa)) return;
-
-    const num = parseInt(tentativa);
-    if (num === jogoAtivo) {
-        await msg.reply(botMsg(`Acertou! Número: ${jogoAtivo}`));
-        jogoAtivo = null;
-    } else if (num > jogoAtivo) {
-        await chat.sendMessage(botMsg("Menor."));
-    } else {
-        await chat.sendMessage(botMsg("Maior."));
-    }
-}
-
-client.initialize();

package.json

@@ -3,8 +3,11 @@
   "version": "2.0.0",
   "type": "module",
   "dependencies": {
+    "node-addon-api": "^7",
+    "node-gyp": "^12.2.0",
+    "node-webpmux": "^3.2.1",
     "qrcode-terminal": "^0.12.0",
-    "sharp": "^0.34.5",
+    "wa-sticker-formatter": "^4.4.4",
     "whatsapp-web.js": "^1.24.0"
   }
 }

setup

@@ -0,0 +1,204 @@
+#!/bin/bash
+set -e
+
+# ------------------------
+# Cores
+# ------------------------
+RESET="\033[0m"
+BOLD="\033[1m"
+
+RED="\033[31m"
+GREEN="\033[32m"
+YELLOW="\033[33m"
+BLUE="\033[34m"
+CYAN="\033[36m"
+MAGENTA="\033[35m"
+GRAY="\033[90m"
+
+timestamp() {
+    date +"%H:%M:%S"
+}
+
+log() {
+    local level="$1"
+    local color="$2"
+    shift 2
+    echo -e "${GRAY}[$(timestamp)]${RESET} ${color}${level}${RESET} $*"
+}
+
+log_info()  { log "[INFO]"  "$BLUE" "$@"; }
+log_ok()    { log "[OK]"    "$GREEN" "$@"; }
+log_warn()  { log "[WARN]"  "$YELLOW" "$@"; }
+log_error() { log "[ERROR]" "$RED" "$@"; }
+log_cmd()   { log "[CMD]"   "$CYAN" "${BOLD}$*${RESET}"; }
+log_debug() { log "[DBG]"   "$GRAY" "$@"; }
+
+# ------------------------
+# Banner
+# ------------------------
+print_banner() {
+echo -e "${MAGENTA}${BOLD}"
+cat << "EOF"
+ _____             _____     _   
+|     |___ ___ _ _| __  |___| |_ 
+| | | | .'|   | | | __ -| . |  _|
+|_|_|_|__,|_|_|_  |_____|___|_|  
+              |___|              
+
+website: www.mlplovers.com.br/manybot
+repo: github.com/synt-xerror/manybot
+
+A Amizade é Mágica!
+
+EOF
+echo -e "${RESET}"
+}
+
+print_banner
+log_info "Inicializando setup..."
+
+# ------------------------
+# Executar comandos
+# ------------------------
+run_cmd() {
+    log_cmd "$*"
+    "$@"
+    log_ok "Comando finalizado: $1"
+}
+
+# ------------------------
+# Download
+# ------------------------
+download_file() {
+    local url="$1"
+    local dest="$2"
+
+    log_debug "download_file(url=$url, dest=$dest)"
+
+    if [[ -f "$dest" ]]; then
+        log_warn "Arquivo já existe: $dest"
+        return
+    fi
+
+    log_info "Baixando $url"
+    log_debug "Destino: $dest"
+
+    if command -v curl >/dev/null 2>&1; then
+        log_debug "Downloader: curl"
+        curl -L "$url" -o "$dest"
+    elif command -v wget >/dev/null 2>&1; then
+        log_debug "Downloader: wget"
+        wget "$url" -O "$dest"
+    else
+        log_error "curl ou wget não encontrados"
+        exit 1
+    fi
+
+    chmod +x "$dest" 2>/dev/null || true
+    log_ok "Arquivo pronto: $dest"
+}
+
+# ------------------------
+# Detectar plataforma
+# ------------------------
+log_info "Detectando plataforma"
+
+UNAME="$(uname -s)"
+ARCH="$(uname -m)"
+
+PLATFORM=""
+case "$UNAME" in
+    Linux*)   PLATFORM="linux";;
+    Darwin*)  PLATFORM="mac";;
+    MINGW*|MSYS*|CYGWIN*) PLATFORM="win";;
+    *)        PLATFORM="unknown";;
+esac
+
+log_info "Sistema: $UNAME"
+log_info "Arquitetura: $ARCH"
+log_info "Plataforma: $PLATFORM"
+
+# ------------------------
+# Informações do ambiente
+# ------------------------
+log_info "Verificando ambiente"
+
+log_debug "Node: $(node -v 2>/dev/null || echo 'não encontrado')"
+log_debug "npm:  $(npm -v 2>/dev/null || echo 'não encontrado')"
+log_debug "PREFIX: ${PREFIX:-<vazio>}"
+
+# ------------------------
+# Termux
+# ------------------------
+install_deps() {
+    local packages=("$@")
+
+    for pkg in "${packages[@]}"; do
+        if ! dpkg -s "$pkg" >/dev/null 2>&1; then
+            log_warn "$pkg não encontrado, instalando"
+            run_cmd pkg install -y "$pkg"
+        else
+            log_ok "$pkg já instalado"
+        fi
+    done
+}
+
+if [[ "$PREFIX" == *"com.termux"* ]]; then
+    log_info "Ambiente Termux detectado"
+
+    deps=(
+        chromium
+    )
+
+    install_deps "${deps[@]}"
+fi
+
+# ------------------------
+# Setup npm
+# ------------------------
+log_info "Instalando dependências npm"
+
+export PUPPETEER_SKIP_DOWNLOAD=1
+run_cmd npm install
+
+# ------------------------
+# Diretórios
+# ------------------------
+log_info "Preparando diretórios"
+mkdir -p bin
+log_debug "Diretório bin garantido"
+
+# ------------------------
+# Arquivos por plataforma
+# ------------------------
+log_info "Selecionando dependências binárias"
+
+files=()
+if [[ "$PLATFORM" == "win" ]]; then
+    log_debug "Usando binários Windows"
+    files=(
+        "https://github.com/synt-xerror/manybot/releases/download/dependencies/yt-dlp.exe bin/yt-dlp.exe"
+        "https://github.com/synt-xerror/manybot/releases/download/dependencies/ffmpeg.exe bin/ffmpeg.exe"
+    )
+else
+    log_debug "Usando binários Unix"
+    files=(
+        "https://github.com/synt-xerror/manybot/releases/download/dependencies/yt-dlp bin/yt-dlp"
+        "https://github.com/synt-xerror/manybot/releases/download/dependencies/ffmpeg bin/ffmpeg"
+    )
+fi
+
+log_debug "Total de arquivos para baixar: ${#files[@]}"
+
+# ------------------------
+# Download
+# ------------------------
+for file in "${files[@]}"; do
+    url="${file%% *}"
+    dest="${file##* }"
+
+    log_info "Processando dependência"
+    download_file "$url" "$dest"
+done
+
+log_ok "Setup concluído com sucesso"

src/client/whatsappClient.js

@@ -0,0 +1,102 @@
+import pkg from "whatsapp-web.js";
+import qrcode from "qrcode-terminal";
+import { exec } from "child_process";
+import { CLIENT_ID } from "../config.js";
+import os from "os";
+
+export const { Client, LocalAuth, MessageMedia } = pkg;
+
+// ── Logger ──────────────────────────────────────────────────
+const c = {
+  reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+  green: "\x1b[32m", yellow: "\x1b[33m", cyan: "\x1b[36m",
+  red: "\x1b[31m", gray: "\x1b[90m", white: "\x1b[37m",
+  blue: "\x1b[34m", magenta: "\x1b[35m",
+};
+
+const now = () =>
+  new Date().toLocaleString("pt-BR", { dateStyle: "short", timeStyle: "short" });
+
+export const logger = {
+  info:    (...a) => console.log(`${c.gray}${now()}${c.reset} ℹ️ `, ...a),
+  success: (...a) => console.log(`${c.gray}${now()}${c.reset} ${c.green}✅${c.reset}`, ...a),
+  warn:    (...a) => console.log(`${c.gray}${now()}${c.reset} ${c.yellow}⚠️ ${c.reset}`, ...a),
+  error:   (...a) => console.log(`${c.gray}${now()}${c.reset} ${c.red}❌${c.reset}`, ...a),
+  bot:     (...a) => console.log(`${c.gray}${now()}${c.reset} ${c.magenta}🤖${c.reset}`, ...a),
+};
+
+// ── Banner ───────────────────────────────────────────────────
+function printBanner() {
+  console.log(`${c.blue}${c.bold}`);
+  console.log(` _____             _____     _   `);
+  console.log(`|     |___ ___ _ _| __  |___| |_ `);
+  console.log(`| | | | .'|   | | | __ -| . |  _|`);
+  console.log(`|_|_|_|__,|_|_|_  |_____|___|_|  `);
+  console.log(`              |___|               `);
+  console.log();
+  console.log(`  website : ${c.reset}${c.cyan}www.mlplovers.com.br/manybot${c.reset}`);
+  console.log(`  repo    : ${c.reset}${c.cyan}github.com/synt-xerror/manybot${c.reset}`);
+  console.log();
+  console.log(`  ${c.bold}✨ A Amizade é Mágica!${c.reset}`);
+  console.log();
+}
+
+// ── Ambiente ─────────────────────────────────────────────────
+const isTermux =
+  (os.platform() === "linux" || os.platform() === "android") &&
+  process.env.PREFIX?.startsWith("/data/data/com.termux");
+
+logger.info(isTermux
+  ? `Ambiente: ${c.yellow}${c.bold}Termux${c.reset} — usando Chromium do sistema`
+  : `Ambiente: ${c.blue}${c.bold}${os.platform()}${c.reset} — usando Puppeteer padrão`
+);
+
+const puppeteerConfig = isTermux
+  ? {
+      executablePath: "/data/data/com.termux/files/usr/bin/chromium-browser",
+      args: [
+        "--headless=new", "--no-sandbox", "--disable-setuid-sandbox",
+        "--disable-dev-shm-usage", "--disable-gpu", "--single-process",
+        "--no-zygote", "--disable-software-rasterizer",
+      ],
+    }
+  : {};
+
+// ── Cliente ──────────────────────────────────────────────────
+export const client = new Client({
+  authStrategy: new LocalAuth({ clientId: CLIENT_ID }),
+  puppeteer: { headless: true, ...puppeteerConfig },
+});
+
+client.on("qr", async qr => {
+  if (isTermux) {
+    try {
+      await QRCode.toFile(QR_PATH, qr, { width: 400 });
+      logger.bot(`QR Code salvo em: ${c.cyan}${c.bold}${QR_PATH}${c.reset}`);
+      logger.bot(`Abra com: ${c.yellow}termux-open qr.png${c.reset}`);
+    } catch (err) {
+      logger.error("Falha ao salvar QR Code:", err.message);
+    }
+  } else {
+    logger.bot(`Escaneie o ${c.yellow}${c.bold}QR Code${c.reset} abaixo:`);
+    qrcode.generate(qr, { small: true });
+  }
+});
+
+client.on("ready", () => {
+  exec("clear");
+  printBanner();
+  logger.success(`${c.green}${c.bold}WhatsApp conectado e pronto!${c.reset}`);
+  logger.info(`Client ID: ${c.cyan}${CLIENT_ID}${c.reset}`);
+});
+
+client.on("disconnected", reason => {
+  logger.warn(`Desconectado — motivo: ${c.yellow}${reason}${c.reset}`);
+  logger.info(`Reconectando em ${c.cyan}5s${c.reset}...`);
+  setTimeout(() => {
+    logger.bot("Reinicializando cliente...");
+    client.initialize();
+  }, 5000);
+});
+
+export default client;

src/commands/figurinha.js

@@ -0,0 +1,256 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+import pkg from "whatsapp-web.js";
+import { createSticker } from "wa-sticker-formatter";
+
+import { client } from "../client/whatsappClient.js";
+import { botMsg } from "../utils/botMsg.js";
+import { emptyFolder } from "../utils/file.js";
+import { stickerSessions } from "./index.js";
+
+const { MessageMedia } = pkg;
+const execFileAsync = promisify(execFile);
+
+const DOWNLOADS_DIR = path.resolve("downloads");
+const FFMPEG = os.platform() === "win32"
+  ? ".\\bin\\ffmpeg.exe"
+  : "./bin/ffmpeg";
+
+const MAX_STICKER_SIZE = 900 * 1024;
+const SESSION_TIMEOUT = 2 * 60 * 1000;
+const MAX_MEDIA = 10;
+
+// ───────────────── Helpers ─────────────────
+
+function ensureDownloadsDir() {
+  if (!fs.existsSync(DOWNLOADS_DIR)) {
+    fs.mkdirSync(DOWNLOADS_DIR, { recursive: true });
+  }
+}
+
+function cleanupFiles(...files) {
+  for (const f of files) {
+    if (f && fs.existsSync(f)) fs.unlinkSync(f);
+  }
+}
+
+// Converte vídeo/gif → GIF 512x512 com paleta preservada
+async function convertVideoToGif(inputPath, outputPath, fps = 12) {
+
+  const clampedFps = Math.min(fps, 12);
+
+  const filter = [
+    `fps=${clampedFps},scale=512:512:flags=lanczos,split[s0][s1]`,
+    `[s0]palettegen=max_colors=256:reserve_transparent=1[p]`,
+    `[s1][p]paletteuse=dither=bayer`
+  ].join(";");
+
+  await execFileAsync(FFMPEG, [
+    "-i", inputPath,
+    "-filter_complex", filter,  // <-- era -vf, tem que ser -filter_complex pro split funcionar
+    "-loop", "0",
+    "-y",
+    outputPath
+  ]);
+}
+
+// Força imagem estática para 512x512
+async function resizeToSticker(inputPath, outputPath) {
+
+  await execFileAsync(FFMPEG, [
+    "-i", inputPath,
+    "-vf", "scale=512:512:flags=lanczos",  // lanczos = melhor qualidade no resize
+    "-y",
+    outputPath
+  ]);
+
+}
+
+async function createStickerWithFallback(stickerInputPath, isAnimated) {
+
+  const qualities = [80, 60, 40, 20];
+
+  for (const quality of qualities) {
+
+    const buffer = await createSticker(
+      fs.readFileSync(stickerInputPath),
+      {
+        pack: "Criada por ManyBot\n",
+        author: "\ngithub.com/synt-xerror/manybot",
+        type: isAnimated ? "FULL" : "STATIC",
+        categories: ["🤖"],
+        quality,
+      }
+    );
+
+    if (buffer.length <= MAX_STICKER_SIZE) {
+      return buffer;
+    }
+
+  }
+
+  throw new Error("Não foi possível reduzir o sticker para menos de 900 KB.");
+}
+
+// ───────────────── Sessão ─────────────────
+
+export function iniciarSessao(chatId, author) {
+
+  if (stickerSessions.has(chatId)) return false;
+
+  const timeout = setTimeout(() => {
+
+    stickerSessions.delete(chatId);
+    client.sendMessage(chatId, botMsg("Sessão de figurinha expirou."));
+
+  }, SESSION_TIMEOUT);
+
+  stickerSessions.set(chatId, {
+    author,
+    medias: [],
+    timeout
+  });
+
+  return true;
+
+}
+
+// ───────────────── Coleta de mídia ─────────────────
+
+export async function coletarMidia(msg) {
+
+  const chat = await msg.getChat();
+  const chatId = chat.id._serialized;
+
+  const session = stickerSessions.get(chatId);
+  if (!session) return;
+
+  const sender = msg.author || msg.from;
+  if (sender !== session.author) return;
+  if (!msg.hasMedia) return;
+
+  const media = await msg.downloadMedia();
+  if (!media) return;
+
+  const isGif =
+    media.mimetype === "image/gif" ||
+    (media.mimetype === "video/mp4" && msg._data?.isGif);
+
+  if (
+    !media.mimetype ||
+    (!media.mimetype.startsWith("image/") &&
+     !media.mimetype.startsWith("video/") &&
+     !isGif)
+  ) {
+    return;
+  }
+
+  if (session.medias.length < MAX_MEDIA) {
+    session.medias.push(media);
+  }
+
+}
+
+// ───────────────── Criar stickers ─────────────────
+
+export async function gerarSticker(msg, chatId) {
+
+  const sender = msg.author || msg.from;
+  const session = stickerSessions.get(chatId);
+
+  if (!session) {
+    return msg.reply(botMsg("Nenhuma sessão de figurinha ativa."));
+  }
+
+  if (session.author !== sender) {
+    return msg.reply(botMsg("Apenas quem iniciou a sessão pode criar as figurinhas."));
+  }
+
+  const medias = session.medias;
+
+  if (!medias.length) {
+    return msg.reply(botMsg("Nenhuma imagem recebida."));
+  }
+
+  clearTimeout(session.timeout);
+
+  console.log("midias:", medias.length);
+
+  await msg.reply(botMsg("Aguarde! Estou criando as suas figurinhas..."));
+
+  ensureDownloadsDir();
+
+    for (const media of medias) {
+    try {
+      const ext = media.mimetype.split("/")[1];
+      const isVideo = media.mimetype.startsWith("video/");
+      const isGif = media.mimetype === "image/gif";
+      const isAnimated = isVideo || isGif;
+
+      const id = Date.now() + "-" + Math.random().toString(36).slice(2);
+      const inputPath = path.join(DOWNLOADS_DIR, `${id}.${ext}`);
+      const gifPath = path.join(DOWNLOADS_DIR, `${id}.gif`);
+      const resizedPath = path.join(DOWNLOADS_DIR, `${id}-scaled.${ext}`);
+
+      fs.writeFileSync(inputPath, Buffer.from(media.data, "base64"));
+
+      // LOG 1 — arquivo de entrada
+      const inputSize = fs.statSync(inputPath).size;
+      console.log(`[1] mimetype: ${media.mimetype} | isAnimated: ${isAnimated} | inputPath: ${inputPath} | size: ${inputSize} bytes`);
+
+      let stickerInputPath = inputPath;
+
+      if (isAnimated) {
+        console.log("[2] Convertendo para GIF...");
+        await convertVideoToGif(inputPath, gifPath, isVideo ? 12 : 24);
+
+        // LOG 2 — gif gerado
+        if (fs.existsSync(gifPath)) {
+          console.log(`[2] GIF gerado: ${fs.statSync(gifPath).size} bytes`);
+        } else {
+          console.error("[2] ERRO: gifPath não foi criado pelo ffmpeg!");
+        }
+
+        stickerInputPath = gifPath;
+      } else {
+        console.log("[2] Redimensionando imagem estática...");
+        await resizeToSticker(inputPath, resizedPath);
+
+        if (fs.existsSync(resizedPath)) {
+          console.log(`[2] Resized gerado: ${fs.statSync(resizedPath).size} bytes`);
+        } else {
+          console.error("[2] ERRO: resizedPath não foi criado!");
+        }
+
+        stickerInputPath = resizedPath;
+      }
+
+      // LOG 3 — antes de criar o sticker
+      console.log(`[3] stickerInputPath: ${stickerInputPath} | exists: ${fs.existsSync(stickerInputPath)} | size: ${fs.existsSync(stickerInputPath) ? fs.statSync(stickerInputPath).size : "N/A"} bytes`);
+
+      const stickerBuffer = await createStickerWithFallback(stickerInputPath, isAnimated);
+
+      // LOG 4 — sticker gerado
+      console.log(`[4] Sticker buffer: ${stickerBuffer.length} bytes`);
+
+      const stickerMedia = new MessageMedia("image/webp", stickerBuffer.toString("base64"));
+      await client.sendMessage(chatId, stickerMedia, { sendMediaAsSticker: true });
+
+      cleanupFiles(inputPath, gifPath, resizedPath);
+
+    } catch (err) {
+      console.error("Erro ao gerar sticker:", err);
+      await msg.reply(botMsg("Erro ao gerar uma das figurinhas."));
+    }
+  }
+
+  await msg.reply(botMsg("Figurinhas geradas com sucesso!"));
+
+  stickerSessions.delete(chatId);
+  emptyFolder("downloads");
+
+}

src/commands/index.js

@@ -0,0 +1,129 @@
+import { enqueueDownload } from "../download/queue.js";
+import { iniciarSessao, gerarSticker } from "./figurinha.js";
+import { botMsg } from "../utils/botMsg.js";
+import { iniciarJogo, pararJogo } from "../games/adivinhacao.js";
+import { processarInfo } from "./info.js";
+
+export const stickerSessions = new Map();
+
+const c = {
+  reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+  green: "\x1b[32m", yellow: "\x1b[33m", cyan: "\x1b[36m",
+  red: "\x1b[31m", gray: "\x1b[90m",
+};
+
+const now = () =>
+  new Date().toLocaleString("pt-BR", { dateStyle: "short", timeStyle: "medium" });
+
+const log = {
+  cmd:   (cmd, ...a) => console.log(`${c.gray}${now()}${c.reset} ${c.cyan}⚙️  ${c.bold}${cmd}${c.reset}`, ...a),
+  ok:    (...a)      => console.log(`${c.gray}${now()}${c.reset} ${c.green}✅${c.reset}`, ...a),
+  warn:  (...a)      => console.log(`${c.gray}${now()}${c.reset} ${c.yellow}⚠️  ${c.reset}`, ...a),
+  error: (...a)      => console.log(`${c.gray}${now()}${c.reset} ${c.red}❌${c.reset}`, ...a),
+};
+
+export async function processarComando(msg, chat, chatId) {
+  const tokens = msg.body.trim().split(/\s+/);
+  const cmd = tokens[0]?.toLowerCase();
+
+  if (!cmd?.startsWith("!") && cmd !== "a") return;
+
+  log.cmd(cmd);
+
+  try {
+    switch (cmd) {
+      case "!many":
+        await chat.sendMessage(botMsg(
+          "Comandos:\n\n" +
+          "- `!ping`\n" +
+          "- `!video <link>`\n" +
+          "- `!audio <link>`\n" +
+          "- `!figurinha`\n" +
+          "- `!adivinhação começar|parar`\n" +
+          "- `!info <comando>`"
+        ));
+        break;
+
+      case "!ping":
+        await msg.reply(botMsg("pong 🏓"));
+        log.ok("pong enviado");
+        break;
+
+      case "!video":
+        if (!tokens[1]) { log.warn("!video sem link"); return; }
+        await msg.reply(botMsg("⏳ Baixando vídeo..."));
+        enqueueDownload("video", tokens[1], msg, chatId);
+        log.ok("vídeo enfileirado →", tokens[1]);
+        break;
+
+      case "!audio":
+        if (!tokens[1]) { log.warn("!audio sem link"); return; }
+        await msg.reply(botMsg("⏳ Baixando áudio..."));
+        enqueueDownload("audio", tokens[1], msg, chatId);
+        log.ok("áudio enfileirado →", tokens[1]);
+        break;
+
+      case "!figurinha":
+        const author = msg.author || msg.from;
+      
+        if (tokens[1] === "criar") {
+          await gerarSticker(msg, chatId);
+        } else {
+          if (stickerSessions.has(chatId)) {
+             return msg.reply("Já existe uma sessão ativa.");
+          }
+
+          iniciarSessao(chatId, author);
+          
+          await msg.reply(
+            `Sessão de figurinha iniciada por @${author.split("@")[0]}. Envie no máximo 10 imagens, quando estiver pronto mande \`!figurinha criar\``,
+            null,
+            { mentions: [author] }
+          );
+        }
+      
+        break;
+      
+
+      case "!adivinhação":
+        if (!tokens[1]) {
+          await chat.sendMessage(botMsg("`!adivinhação começar`\n`!adivinhação parar`"));
+          return;
+        }
+        if (tokens[1] === "começar") {
+          iniciarJogo();
+          await chat.sendMessage(botMsg("Jogo iniciado! Tente adivinhar o número de 1 a 100."));
+          log.ok("jogo iniciado");
+        } else if (tokens[1] === "parar") {
+          pararJogo();
+          await chat.sendMessage(botMsg("Jogo parado."));
+          log.ok("jogo parado");
+        } else {
+          log.warn("!adivinhação — subcomando desconhecido:", tokens[1]);
+        }
+        break;
+
+      case "!info":
+        if (!tokens[1]) {
+          await chat.sendMessage(botMsg("Use:\n`!info <comando>`"));
+          return;
+        }
+        processarInfo(tokens[1], chat);
+        log.ok("info →", tokens[1]);
+        break;
+
+      case "!obrigado":
+      case "!valeu":
+      case "!brigado":
+        await msg.reply(botMsg("Por nada!"));
+        break;
+
+      case "a":
+        if (!tokens[1]) await msg.reply(botMsg("B"));
+        break;
+    }
+  } catch (err) {
+    log.error("Falha em", cmd, "—", err.message);
+    await chat.sendMessage(botMsg("Erro:\n`" + err.message + "`"));
+  }
+}

src/commands/info.js

@@ -0,0 +1,20 @@
+import { botMsg } from "../utils/botMsg.js";
+
+export async function processarInfo(cmd, chat) {
+    switch(cmd) {
+        case "ping":
+            await chat.sendMessage(botMsg("> `!ping`\nResponde pong."));
+        break;
+        case "video":
+            await chat.sendMessage(botMsg("> `!video <link>`\nBaixa vídeo da internet."));
+        break;
+        case "audio":
+            await chat.sendMessage(botMsg("> `!audio <link>`\nBaixa áudio da internet."));
+        break;
+        case "figurinha":
+            await chat.sendMessage(botMsg("`!figurinha`\nTransforma imagem/GIF em sticker."));
+        break;
+        default:
+            await chat.sendMessage(botMsg(`❌ Comando '${tokens[1]}' não encontrado.`));
+    }
+}

src/download/audio.js

@@ -0,0 +1,24 @@
+import { get_video } from "./video.js";
+import { spawn } from "child_process";
+import os from "os";
+
+const so = os.platform();
+
+export async function get_audio(url, id) {
+    const video = await get_video(url, id);
+    const output = `downloads/${id}.mp3`;
+    const cmd = so === "win32" ? ".\\bin\\ffmpeg.exe" : "./bin/ffmpeg";
+    const args = ['-i', video, '-vn', '-acodec', 'libmp3lame', '-q:a', '2', output];
+
+    await runCmd(cmd, args);
+    return output;
+}
+
+async function runCmd(cmd, args) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn(cmd, args);
+        proc.stdout.on("data", data => console.log("[cmd]", data.toString()));
+        proc.stderr.on("data", data => console.error("[cmd ERR]", data.toString()));
+        proc.on("close", code => code === 0 ? resolve() : reject(new Error("Processo saiu com código "+code)));
+    });
+}

src/download/queue.js

@@ -0,0 +1,42 @@
+import { get_video } from "./video.js";
+import { get_audio } from "./audio.js";
+import pkg from "whatsapp-web.js";
+const { MessageMedia } = pkg;
+import fs from "fs";
+import { botMsg } from "../utils/botMsg.js";
+import { emptyFolder } from "../utils/file.js";
+import client from "../client/whatsappClient.js";
+
+let downloadQueue = [];
+let processingQueue = false;
+
+export function enqueueDownload(type, url, msg, chatId) {
+    downloadQueue.push({ type, url, msg, chatId });
+    if (!processingQueue) processQueue();
+}
+
+async function processQueue() {
+    processingQueue = true;
+    while (downloadQueue.length) {
+        const job = downloadQueue.shift();
+        try {
+            let path;
+            if (job.type === "video") path = await get_video(job.url, job.msg.id._serialized);
+            else path = await get_audio(job.url, job.msg.id._serialized);
+
+            const file = fs.readFileSync(path);
+            const media = new MessageMedia(
+                job.type === "video" ? "video/mp4" : "audio/mpeg",
+                file.toString("base64"),
+                path.split("/").pop()
+            );
+            await client.sendMessage(job.chatId, media);
+            fs.unlinkSync(path);
+            emptyFolder("downloads");
+
+        } catch (err) {
+            await client.sendMessage(job.chatId, botMsg(`❌ Erro ao baixar ${job.type}\n\`${err.message}\``));
+        }
+    }
+    processingQueue = false;
+}

src/download/video.js

@@ -0,0 +1,55 @@
+import { spawn } from "child_process";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+const platform = os.platform();
+
+export async function get_video(url, id) {
+    // garante que a pasta exista
+    const downloadsDir = path.resolve("downloads");
+    fs.mkdirSync(downloadsDir, { recursive: true });
+
+    const cmd = platform === "win32" ? ".\\bin\\yt-dlp.exe" : "./bin/yt-dlp";
+    const args = [
+        '--extractor-args', 'youtube:player_client=android',
+        '-f', 'bv+ba/best',
+        '--print', 'after_move:filepath',
+        '--output', path.join(downloadsDir, `${id}.%(ext)s`),
+        '--cookies', 'cookies.txt',
+        '--add-header', 'User-Agent:Mozilla/5.0',
+        '--add-header', 'Referer:https://www.youtube.com/',
+        '--retries', '4',
+        '--fragment-retries', '5',
+        '--socket-timeout', '15',
+        '--sleep-interval', '1', '--max-sleep-interval', '4',
+        '--no-playlist',
+        url
+    ];
+
+    return await runCmd(cmd, args);
+}
+
+async function runCmd(cmd, args) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn(cmd, args);
+        let stdout = "";
+
+        proc.stdout.on("data", data => stdout += data.toString());
+        proc.stderr.on("data", data => console.error("[yt-dlp ERR]", data.toString()));
+
+        proc.on("close", code => {
+            if (code !== 0) return reject(new Error("yt-dlp saiu com código " + code));
+
+            // Pega a última linha, que é o caminho final do arquivo
+            const lines = stdout.trim().split("\n").filter(l => l.trim());
+            const filepath = lines[lines.length - 1];
+
+            if (!fs.existsSync(filepath)) {
+                return reject(new Error("Arquivo não encontrado: " + filepath));
+            }
+
+            resolve(filepath);
+        });
+    });
+}

src/games/adivinhacao.js

@@ -0,0 +1,29 @@
+import { botMsg } from "../utils/botMsg.js";
+
+let jogoAtivo = null;
+
+export function iniciarJogo() {
+    jogoAtivo = Math.floor(Math.random()*100)+1;
+    return jogoAtivo;
+}
+
+export function pararJogo() {
+    jogoAtivo = null;
+}
+
+export async function processarJogo(msg, chat) {
+    if (!jogoAtivo) return;
+
+    const tentativa = msg.body.trim();
+    if (!/^\d+$/.test(tentativa)) return;
+
+    const num = parseInt(tentativa);
+    if (num === jogoAtivo) {
+        await msg.reply(botMsg(`Acertou! Número: ${jogoAtivo}`));
+        pararJogo();
+    } else if (num > jogoAtivo) {
+        await chat.sendMessage(botMsg("Menor."));
+    } else {
+        await chat.sendMessage(botMsg("Maior."));
+    }
+}

src/main.js

@@ -0,0 +1,134 @@
+import client from "./client/whatsappClient.js";
+import { CHATS, BOT_PREFIX } from "./config.js";  // <- importar PREFIX
+import { processarComando } from "./commands/index.js";
+import { coletarMidia } from "./commands/figurinha.js";
+import { processarJogo } from "./games/adivinhacao.js";
+import { getChatId } from "./utils/getChatId.js";
+
+// ── Cores ────────────────────────────────────────────────────
+const c = {
+  reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+  green: "\x1b[32m", yellow: "\x1b[33m", cyan: "\x1b[36m",
+  red: "\x1b[31m", gray: "\x1b[90m", white: "\x1b[37m",
+  blue: "\x1b[34m", magenta: "\x1b[35m",
+};
+
+const now = () =>
+  new Date().toLocaleString("pt-BR", { dateStyle: "short", timeStyle: "medium" });
+
+const SEP = `${c.gray}${"─".repeat(52)}${c.reset}`;
+
+// ── Logger ───────────────────────────────────────────────────
+const logger = {
+  info:    (...a) => console.log(`${SEP}\n${c.gray}[${now()}]${c.reset} ${c.cyan}INFO   ${c.reset}`, ...a),
+  success: (...a) => console.log(`${c.gray}[${now()}]${c.reset} ${c.green}OK     ${c.reset}`, ...a),
+  warn:    (...a) => console.log(`${c.gray}[${now()}]${c.reset} ${c.yellow}WARN   ${c.reset}`, ...a),
+  error:   (...a) => console.log(`${c.gray}[${now()}]${c.reset} ${c.red}ERROR  ${c.reset}`, ...a),
+
+  msg: async (chatName, chatId, from, body, msg = {}) => {
+    const number = String(from).split("@")[0];
+    const isGroup = /@g\.us$/.test(chatId);
+    let name = msg?.notifyName || number;
+
+    try {
+      if (typeof client?.getContactById === "function") {
+        const contact = await client.getContactById(from);
+        name = contact?.pushname || contact?.formattedName || name;
+      }
+    } catch {}
+
+    const type = msg?.type || "text";
+    const typeLabel =
+      type === "sticker"  ? `${c.magenta}sticker${c.reset}` :
+      type === "image"    ? `${c.cyan}imagem${c.reset}`     :
+      type === "video"    ? `${c.cyan}vídeo${c.reset}`      :
+      type === "audio"    ? `${c.cyan}áudio${c.reset}`      :
+      type === "ptt"      ? `${c.cyan}áudio${c.reset}`      :
+      type === "document" ? `${c.cyan}arquivo${c.reset}`    :
+      type === "chat"     ? `${c.white}texto${c.reset}`     :
+                            `${c.gray}${type}${c.reset}`;
+
+    const isCommand = body?.trimStart().startsWith(BOT_PREFIX);
+
+    const context = isGroup
+      ? `${c.bold}${chatName}${c.reset} ${c.dim}(grupo)${c.reset}`
+      : `${c.bold}${chatName}${c.reset} ${c.dim}(privado)${c.reset}`;
+
+    const bodyPreview = body?.trim()
+      ? `${isCommand ? c.yellow : c.green}"${body.length > 80 ? body.slice(0, 80) + "…" : body}"${c.reset}`
+      : `${c.dim}<${typeLabel}>${c.reset}`;
+
+    // Resolve reply
+    let replyLine = "";
+    if (msg?.hasQuotedMsg) {
+      try {
+        const quoted = await msg.getQuotedMessage();
+        const quotedNumber = String(quoted.from).split("@")[0];
+        let quotedName = quotedNumber;
+        try {
+          const quotedContact = await client.getContactById(quoted.from);
+          quotedName = quotedContact?.pushname || quotedContact?.formattedName || quotedNumber;
+        } catch {}
+        const quotedPreview = quoted.body?.trim()
+          ? `"${quoted.body.length > 60 ? quoted.body.slice(0, 60) + "…" : quoted.body}"`
+          : `<${quoted.type}>`;
+        replyLine =
+          `\n${c.gray}            ↩ Para: ${c.reset}${c.white}${quotedName}${c.reset} ${c.dim}+${quotedNumber}${c.reset}` +
+          `\n${c.gray}            ↩ Msg:  ${c.reset}${c.dim}${quotedPreview}${c.reset}`;
+      } catch {}
+    }
+
+    console.log(
+      `${SEP}\n` +
+      `${c.gray}[${now()}]${c.reset} ${c.cyan}MSG    ${c.reset}${context}\n` +
+      `${c.gray}            De:   ${c.reset}${c.white}${name}${c.reset} ${c.dim}+${number}${c.reset}\n` +
+      `${c.gray}            Tipo: ${c.reset}${typeLabel}${isCommand ? `  ${c.yellow}(bot)${c.reset}` : ""}\n` +
+      `${c.gray}            Text: ${c.reset}${bodyPreview}` +
+      replyLine
+    );
+  },
+
+  cmd: (cmd, extra = "") =>
+    console.log(
+      `${c.gray}[${now()}]${c.reset} ${c.yellow}CMD    ${c.reset}` +
+      `${c.bold}${cmd}${c.reset}` +
+      (extra ? `  ${c.dim}${extra}${c.reset}` : "")
+    ),
+
+  done: (cmd, detail = "") =>
+    console.log(
+      `${c.gray}[${now()}]${c.reset} ${c.green}DONE   ${c.reset}` +
+      `${c.dim}${cmd}${c.reset}` +
+      (detail ? ` — ${detail}` : "")
+    ),
+};
+
+export { logger };
+
+// ── Boot ─────────────────────────────────────────────────────
+logger.info("Iniciando ManyBot...");
+
+client.on("message_create", async msg => {
+  try {
+    const chat = await msg.getChat();
+    const chatId = getChatId(chat);
+
+    if (!CHATS.includes(chatId)) return;
+
+    await logger.msg(chat.name || chat.id.user, chatId, msg.from, msg.body, msg);
+
+    await coletarMidia(msg);
+    await processarComando(msg, chat, chatId);
+    await processarJogo(msg, chat);
+
+    logger.done("message_create", `de +${String(msg.from).split("@")[0]}`);
+  } catch (err) {
+    logger.error(
+      `Falha ao processar — ${err.message}`,
+      `\n             Stack: ${err.stack?.split("\n")[1]?.trim() ?? ""}`
+    );
+  }
+});
+
+client.initialize();
+logger.info("Cliente inicializado. Aguardando conexão com WhatsApp...");

src/utils/botMsg.js

@@ -0,0 +1,5 @@
+import { BOT_PREFIX } from "../config.js";
+
+export function botMsg(texto) {
+    return `${BOT_PREFIX}\n${texto}`;
+}

src/utils/file.js

@@ -0,0 +1,9 @@
+import fs from "fs";
+import path from "path";
+
+export function emptyFolder(folder) {
+    fs.readdirSync(folder).forEach(file => {
+        const filePath = path.join(folder, file);
+        if (fs.lstatSync(filePath).isFile()) fs.unlinkSync(filePath);
+    });
+}

src/utils/getChatId.js

@@ -0,0 +1,3 @@
+export function getChatId(chat) {
+    return chat.id._serialized;
+}

teste.js

@@ -1,7 +0,0 @@
-const str = "<22>»⃟⃫⚡️⃥<EFB88F><E283A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>☆<EFBFBD>";
-
-// percorre cada caractere
-for (const char of str) {
-    const code = char.codePointAt(0); // pega o ponto de código Unicode
-    process.stdout.write(`${char} (U+${code.toString(16).toUpperCase()})\n`);
-}

todo.txt

@@ -0,0 +1,9 @@
+Deixar o log mais claro, permanecendo limpo e simples
+
+Possibilidade de tirar fundo de figurinhas
+
+Salvar mensagens num banco de dados
+
+Mudar a licença para GPLv3
+
+Possibilidade de baixar playlists do youtube