vatts 2.0.2 → 2.1.0-canary.1

package/dist/api/console.js

@@ -27,13 +27,13 @@ const node_readline_1 = __importDefault(require("node:readline"));
 class DynamicLine {
     _id = Symbol();
     constructor(initialContent) {
-        Console['registerDynamicLine'](this._id, initialContent);
+        Console["registerDynamicLine"](this._id, initialContent);
     }
     update(newContent) {
-        Console['updateDynamicLine'](this._id, newContent);
+        Console["updateDynamicLine"](this._id, newContent);
     }
     end(finalContent) {
-        Console['endDynamicLine'](this._id, finalContent);
+        Console["endDynamicLine"](this._id, finalContent);
     }
 }
 exports.DynamicLine = DynamicLine;
@@ -75,113 +75,240 @@ var Levels;
     Levels["SUCCESS"] = "SUCCESS";
 })(Levels || (exports.Levels = Levels = {}));
 class Console {
-    static activeLines = [];
-    static lastRenderedLines = 0;
-    // --- RENDERIZAÇÃO ---
-    static redrawDynamicLines() {
-        const stream = process.stdout;
-        if (this.lastRenderedLines > 0) {
-            try {
-                node_readline_1.default.moveCursor(stream, 0, -this.lastRenderedLines);
-            }
-            catch { }
-        }
-        node_readline_1.default.cursorTo(stream, 0);
-        node_readline_1.default.clearScreenDown(stream);
-        if (this.activeLines.length > 0) {
-            stream.write(this.activeLines.map(l => this.formatLog('WAIT', l.content)).join('\n') + '\n');
-        }
-        this.lastRenderedLines = this.activeLines.length;
+    // Map storing active lines and their offset from the current cursor position (rows up)
+    static activeLines = new Map();
+    // Hook para interceptar stdout
+    static originalStdoutWrite = process.stdout.write.bind(process.stdout);
+    static isHooked = false;
+    static isWriting = false;
+    // --- THEME / HELPERS VISUAIS ---
+    static ANSI_REGEX = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+    static stripAnsi(text) {
+        return text.replace(this.ANSI_REGEX, "");
     }
-    static writeStatic(content) {
-        const stream = process.stdout;
-        if (this.lastRenderedLines > 0) {
-            try {
-                node_readline_1.default.moveCursor(stream, 0, -this.lastRenderedLines);
-            }
-            catch { }
-            node_readline_1.default.cursorTo(stream, 0);
-            node_readline_1.default.clearScreenDown(stream);
-        }
-        console.log(content.replace(/\n$/, ''));
-        if (this.activeLines.length > 0) {
-            stream.write(this.activeLines.map(l => this.formatLog('WAIT', l.content)).join('\n') + '\n');
-            this.lastRenderedLines = this.activeLines.length;
-        }
-        else {
-            this.lastRenderedLines = 0;
+    static fg(r, g, b) {
+        return `\x1b[38;2;${r};${g};${b}m`;
+    }
+    static bg(r, g, b) {
+        return `\x1b[48;2;${r};${g};${b}m`;
+    }
+    static padCenter(text, width) {
+        const cleanLen = this.stripAnsi(text).length;
+        if (cleanLen >= width)
+            return text;
+        const total = width - cleanLen;
+        const left = Math.floor(total / 2);
+        const right = total - left;
+        return " ".repeat(left) + text + " ".repeat(right);
+    }
+    static padRight(text, width) {
+        const cleanLen = this.stripAnsi(text).length;
+        if (cleanLen >= width)
+            return text;
+        return text + " ".repeat(width - cleanLen);
+    }
+    static getTime() {
+        return new Date().toLocaleTimeString("pt-BR", { hour12: false });
+    }
+    static normalizeLevelName(level) {
+        if (level === null || level === undefined)
+            return "";
+        return String(level).trim();
+    }
+    static isKnownLevel(level) {
+        const normalized = this.normalizeLevelName(level);
+        if (!normalized)
+            return false;
+        const upper = normalized.toUpperCase();
+        return (upper === Levels.ERROR ||
+            upper === Levels.WARN ||
+            upper === Levels.INFO ||
+            upper === Levels.DEBUG ||
+            upper === Levels.SUCCESS ||
+            upper === "WAIT");
+    }
+    /**
+     * Converte uma cor ANSI (Colors.FgX) em um background 24-bit escuro combinando.
+     * Isso faz teu methodColor virar um badge bonitinho (fg + bg).
+     */
+    static bgForFgColor(fgColor) {
+        switch (fgColor) {
+            case Colors.FgRed:
+                return this.bg(86, 24, 24);
+            case Colors.FgGreen:
+                return this.bg(18, 64, 34);
+            case Colors.FgYellow:
+                return this.bg(72, 58, 20);
+            case Colors.FgBlue:
+                return this.bg(18, 38, 70);
+            case Colors.FgMagenta:
+                return this.bg(46, 28, 66);
+            case Colors.FgCyan:
+                return this.bg(18, 56, 64);
+            case Colors.FgGray:
+                return this.bg(48, 48, 48);
+            case Colors.FgWhite:
+            case Colors.FgAlmostWhite:
+                return this.bg(64, 64, 64);
+            case Colors.FgBlack:
+                return this.bg(20, 20, 20);
+            default:
+                return this.bg(64, 64, 64);
         }
     }
-    static formatLog(level, message, color) {
-        let icon = '•';
-        let baseColor = Colors.FgWhite;
+    static levelStyle(level) {
+        const C = {
+            red: { fg: this.fg(255, 95, 95), bg: this.bg(86, 24, 24) },
+            yellow: { fg: this.fg(255, 210, 90), bg: this.bg(72, 58, 20) },
+            cyan: { fg: this.fg(120, 230, 255), bg: this.bg(18, 56, 64) },
+            green: { fg: this.fg(120, 255, 165), bg: this.bg(18, 64, 34) },
+            gray: { fg: this.fg(170, 170, 170), bg: this.bg(48, 48, 48) },
+            white: { fg: this.fg(230, 230, 230), bg: this.bg(64, 64, 64) },
+            purple: { fg: this.fg(200, 160, 255), bg: this.bg(46, 28, 66) },
+        };
         switch (level) {
             case Levels.ERROR:
-                icon = '✕';
-                baseColor = Colors.FgRed;
-                break;
+                return { icon: "✖", badgeFg: C.red.fg, badgeBg: C.red.bg, msgFg: Colors.FgAlmostWhite };
             case Levels.WARN:
-                icon = '▲';
-                baseColor = Colors.FgYellow;
-                break;
+                return { icon: "▲", badgeFg: C.yellow.fg, badgeBg: C.yellow.bg, msgFg: Colors.FgAlmostWhite };
             case Levels.INFO:
-                icon = 'ℹ';
-                baseColor = Colors.FgCyan;
-                break;
+                return { icon: "ℹ", badgeFg: C.cyan.fg, badgeBg: C.cyan.bg, msgFg: Colors.FgAlmostWhite };
             case Levels.SUCCESS:
-                icon = '✓';
-                baseColor = Colors.FgGreen;
-                break;
+                return { icon: "✓", badgeFg: C.green.fg, badgeBg: C.green.bg, msgFg: Colors.FgAlmostWhite };
             case Levels.DEBUG:
-                icon = '›';
-                baseColor = Colors.FgGray;
-                break;
-            case 'WAIT':
-                icon = '○';
-                baseColor = Colors.FgCyan;
-                break;
+                return { icon: "›", badgeFg: C.gray.fg, badgeBg: C.gray.bg, msgFg: Colors.FgGray };
+            case "WAIT":
+                return { icon: "", badgeFg: C.purple.fg, badgeBg: C.purple.bg, msgFg: Colors.FgAlmostWhite };
             default:
-                icon = '•';
-                baseColor = color || Colors.FgWhite;
-                break;
+                return { icon: "", badgeFg: C.white.fg, badgeBg: C.white.bg, msgFg: Colors.FgAlmostWhite };
         }
-        const gray = Colors.FgGray;
-        const bold = Colors.Bright;
+    }
+    /**
+     * Agora aceita override de cor pro badge (pra custom levels tipo GET/POST).
+     */
+    static renderBadge(level, badgeFgOverride) {
         const reset = Colors.Reset;
-        const time = new Date().toLocaleTimeString('pt-BR', { hour12: false });
-        const levelStr = level === 'WAIT' ? '' : ` ${bold}${level}${reset}`;
-        return ` ${gray}${time}${reset}  ${baseColor}${icon}${levelStr}${reset}  ${message}`;
+        const bold = Colors.Bright;
+        const normalized = this.normalizeLevelName(level);
+        if (normalized === "")
+            return "";
+        const name = normalized.toUpperCase();
+        const trimmed = name.length > 7 ? name.slice(0, 7) : name;
+        // centraliza dentro do badge
+        const padded = this.padCenter(trimmed, 7);
+        const base = this.levelStyle(level);
+        const fg = badgeFgOverride ?? base.badgeFg;
+        const bg = badgeFgOverride ? this.bgForFgColor(badgeFgOverride) : base.badgeBg;
+        return `${bg}${fg}${bold} ${padded} ${reset}`;
+    }
+    static indentMultiline(msg, indent) {
+        return msg
+            .split("\n")
+            .map((line, i) => (i === 0 ? line : indent + line))
+            .join("\n");
+    }
+    // --- HELPER PARA CALCULAR ALTURA ADICIONADA ---
+    static countRowsAdded(text) {
+        const columns = process.stdout.columns || 80;
+        const clean = text.replace(this.ANSI_REGEX, "");
+        let rowsAdded = 0;
+        const lines = clean.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+            const width = lines[i].length;
+            if (width > 0) {
+                rowsAdded += Math.floor((width - 1) / columns);
+            }
+            if (i < lines.length - 1) {
+                rowsAdded++;
+            }
+        }
+        return rowsAdded;
+    }
+    // --- HOOK SYSTEM ---
+    static hook() {
+        if (this.isHooked)
+            return;
+        this.isHooked = true;
+        process.stdout.write = (chunk, encoding, callback) => {
+            if (this.isWriting) {
+                return this.originalStdoutWrite(chunk, encoding, callback);
+            }
+            const text = chunk.toString();
+            const rowsAdded = this.countRowsAdded(text);
+            if (rowsAdded > 0) {
+                for (const line of this.activeLines.values()) {
+                    line.offset += rowsAdded;
+                }
+            }
+            return this.originalStdoutWrite(chunk, encoding, callback);
+        };
+    }
+    // --- HELPER WRITER ---
+    static writeStatic(content) {
+        console.log(content.replace(/\n$/, ""));
     }
-    // --- INTERATIVIDADE (SELECTION) ---
     /**
-     * Menu de seleção interativo usando setas do teclado.
-     * @param options Objeto no formato { "valor_retornado": "Label Exibida" }
+     * IMPORTANT: o `color` aqui (quando custom level) agora pinta o BADGE também.
      */
+    static formatLog(level, message, color) {
+        if (message === "end_clear")
+            return "";
+        const reset = Colors.Reset;
+        const dim = Colors.Dim;
+        const time = this.getTime();
+        const timePart = `${dim}${Colors.FgGray}${time}${reset}`;
+        const normalizedLevel = this.normalizeLevelName(level);
+        const isEmptyLevel = normalizedLevel === "";
+        const known = this.isKnownLevel(level);
+        const st = this.levelStyle(level);
+        // Se for custom (não-known) e tiver color, usa ele no badge
+        const shouldOverrideBadge = !known && !!color && !isEmptyLevel;
+        const badge = isEmptyLevel ? "" : this.renderBadge(level, shouldOverrideBadge ? color : null);
+        const gapAfterTime = "  ";
+        const gapAfterBadge = badge ? "  " : " ";
+        // Icon também acompanha cor do custom
+        const iconFg = shouldOverrideBadge ? color : st.badgeFg;
+        const iconSymbol = isEmptyLevel ? "" : st.icon || "";
+        const iconPart = `${iconFg}${iconSymbol}${reset}`;
+        const prefix = badge
+            ? ` ${timePart}${gapAfterTime}${badge}${gapAfterBadge}${iconPart} `
+            : ` ${timePart}${gapAfterTime}${iconPart} `;
+        // Mensagem: mantém msgFg padrão, mas tu pode também colorir o texto todo se quiser.
+        const msgColor = st.msgFg;
+        const indent = " ".repeat(this.stripAnsi(prefix).length);
+        const prettyMsg = this.indentMultiline(message, indent);
+        return `${prefix}${msgColor}${prettyMsg}${reset}`;
+    }
+    // --- INTERATIVIDADE (SELECTION) ---
     static async selection(question, options) {
         const entries = Object.entries(options);
         let currentIndex = 0;
         const stream = process.stdout;
         let firstRender = true;
-        if (this.lastRenderedLines > 0) {
-            node_readline_1.default.moveCursor(stream, 0, -this.lastRenderedLines);
-            node_readline_1.default.cursorTo(stream, 0);
-            node_readline_1.default.clearScreenDown(stream);
-        }
-        stream.write('\x1b[?25l'); // Hide cursor
+        stream.write("\x1b[?25l");
         const render = () => {
-            // Se não for a primeira vez, sobe as linhas do menu anterior para sobrescrever
             if (!firstRender) {
-                node_readline_1.default.moveCursor(stream, 0, -(entries.length + 1));
+                // FIXED: Changed from +3 to +2 so it doesn't eat the previous logs
+                node_readline_1.default.moveCursor(stream, 0, -(entries.length + 2));
             }
             node_readline_1.default.cursorTo(stream, 0);
             node_readline_1.default.clearScreenDown(stream);
-            stream.write(` ${Colors.FgCyan}?${Colors.Reset} ${Colors.Bright}${question}${Colors.Reset}\n`);
-            entries.forEach(([key, label], i) => {
+            const title = ` ${Colors.FgCyan}${Colors.Bright}◆${Colors.Reset} ${Colors.Bright}${question}${Colors.Reset}`;
+            let output = `${title}\n ${Colors.Dim}${Colors.FgGray}Use ↑/↓ e Enter${Colors.Reset}\n`;
+            entries.forEach(([_key, label], i) => {
                 const isSelected = i === currentIndex;
-                const prefix = isSelected ? `${Colors.FgCyan}❯${Colors.Reset}` : ' ';
-                const text = isSelected ? `${Colors.FgCyan}${Colors.Bright}${label}${Colors.Reset}` : `${Colors.FgGray}${label}${Colors.Reset}`;
-                stream.write(`  ${prefix} ${text}\n`);
+                const bullet = isSelected
+                    ? `${this.bg(18, 56, 64)}${this.fg(120, 230, 255)} ${Colors.Bright}❯${Colors.Reset}${this.bg(18, 56, 64)}${this.fg(120, 230, 255)} `
+                    : `   `;
+                const text = isSelected
+                    ? `${this.bg(18, 56, 64)}${this.fg(220, 245, 255)}${Colors.Bright}${String(label)}${Colors.Reset}`
+                    : `${Colors.FgGray}${String(label)}${Colors.Reset}`;
+                const suffix = isSelected ? `${this.bg(18, 56, 64)}${Colors.Reset}` : "";
+                output += ` ${bullet}${text}${suffix}\n`;
             });
+            this.isWriting = true;
+            this.originalStdoutWrite(output);
+            this.isWriting = false;
             firstRender = false;
         };
         render();
@@ -189,30 +316,30 @@ class Console {
             const handleKey = (_chunk, key) => {
                 if (!key)
                     return;
-                if (key.name === 'up') {
+                if (key.name === "up") {
                     currentIndex = (currentIndex - 1 + entries.length) % entries.length;
                     render();
                 }
-                else if (key.name === 'down') {
+                else if (key.name === "down") {
                     currentIndex = (currentIndex + 1) % entries.length;
                     render();
                 }
-                else if (key.name === 'return') {
-                    process.stdin.removeListener('keypress', handleKey);
+                else if (key.name === "return") {
+                    process.stdin.removeListener("keypress", handleKey);
                     if (process.stdin.isTTY)
                         process.stdin.setRawMode(false);
                     process.stdin.pause();
-                    stream.write('\x1b[?25h'); // Show cursor
-                    // Limpa o menu final antes de escrever o log estático
-                    node_readline_1.default.moveCursor(stream, 0, -(entries.length + 1));
+                    stream.write("\x1b[?25h");
+                    // FIXED: Changed from +3 to +2 here as well for proper cleanup
+                    node_readline_1.default.moveCursor(stream, 0, -(entries.length + 2));
                     node_readline_1.default.cursorTo(stream, 0);
                     node_readline_1.default.clearScreenDown(stream);
-                    const [selectedKey, selectedLabel] = entries[currentIndex];
-                    this.writeStatic(` ${Colors.FgCyan}✓${Colors.Reset} ${Colors.Bright}${question}${Colors.Reset} ${Colors.FgGray}›${Colors.Reset} ${selectedLabel}`);
-                    resolve(selectedKey);
+                    const [_selectedKey, selectedLabel] = entries[currentIndex];
+                    this.writeStatic(this.formatLog(Levels.SUCCESS, `${question} ${Colors.FgGray}›${Colors.Reset} ${String(selectedLabel)}`));
+                    resolve(_selectedKey);
                 }
-                else if (key.ctrl && key.name === 'c') {
-                    stream.write('\x1b[?25h');
+                else if (key.ctrl && key.name === "c") {
+                    stream.write("\x1b[?25h");
                     process.exit();
                 }
             };
@@ -220,22 +347,36 @@ class Console {
             if (process.stdin.isTTY)
                 process.stdin.setRawMode(true);
             process.stdin.resume();
-            process.stdin.on('keypress', handleKey);
+            process.stdin.on("keypress", handleKey);
         });
     }
     // --- MÉTODOS PÚBLICOS ---
-    static error(...args) { this.log(Levels.ERROR, null, ...args); }
-    static warn(...args) { this.log(Levels.WARN, null, ...args); }
-    static info(...args) { this.log(Levels.INFO, null, ...args); }
-    static success(...args) { this.log(Levels.SUCCESS, null, ...args); }
-    static default_log(...args) { this.log(Levels.INFO, null, ...args); }
-    static debug(...args) { this.log(Levels.DEBUG, null, ...args); }
+    static error(...args) {
+        this.log(Levels.ERROR, null, ...args);
+    }
+    static warn(...args) {
+        this.log(Levels.WARN, null, ...args);
+    }
+    static info(...args) {
+        this.log(Levels.INFO, null, ...args);
+    }
+    static success(...args) {
+        this.log(Levels.SUCCESS, null, ...args);
+    }
+    static default_log(...args) {
+        this.log(Levels.INFO, null, ...args);
+    }
+    static debug(...args) {
+        this.log(Levels.DEBUG, null, ...args);
+    }
     static logCustomLevel(levelName, without = true, color, ...args) {
+        const normalized = this.normalizeLevelName(levelName);
+        const lvl = normalized;
         if (without) {
-            this.logWithout(levelName, color, ...args);
+            this.logWithout(lvl, color, ...args);
         }
         else {
-            this.log(levelName, color, ...args);
+            this.log(lvl, color, ...args);
         }
     }
     static logWithout(level, colors, ...args) {
@@ -244,75 +385,102 @@ class Console {
     static log(level, colors, ...args) {
         let output = "";
         for (const arg of args) {
-            let msg = (arg instanceof Error) ? arg.stack : (typeof arg === 'string') ? arg : JSON.stringify(arg, null, 2);
+            const msg = arg instanceof Error ? arg.stack : typeof arg === "string" ? arg : JSON.stringify(arg, null, 2);
             if (msg)
-                output += this.formatLog(level, msg, colors) + '\n';
+                output += this.formatLog(level, msg, colors) + "\n";
         }
-        this.writeStatic(output.replace(/\n$/, ''));
+        this.writeStatic(output);
     }
     static async ask(question, defaultValue) {
         const rl = node_readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
-        const defaultPart = defaultValue ? ` ${Colors.FgGray}(${defaultValue})${Colors.Reset}` : '';
-        const prompt = ` ${Colors.FgCyan}?${Colors.Reset} ${Colors.Bright}${question}${Colors.Reset}${defaultPart}\n ${Colors.FgCyan}❯${Colors.Reset} `;
-        return new Promise(resolve => {
-            rl.question(prompt, ans => {
+        const defaultPart = defaultValue ? ` ${Colors.Dim}${Colors.FgGray}(${defaultValue})${Colors.Reset}` : "";
+        const prompt = ` ${Colors.FgCyan}${Colors.Bright}◆${Colors.Reset} ${Colors.Bright}${question}${Colors.Reset}${defaultPart}\n` +
+            ` ${Colors.FgCyan}❯${Colors.Reset} `;
+        return new Promise((resolve) => {
+            rl.question(prompt, (ans) => {
                 rl.close();
                 const value = ans.trim();
-                resolve(value === '' && defaultValue !== undefined ? defaultValue : value);
+                resolve(value === "" && defaultValue !== undefined ? defaultValue : value);
             });
         });
     }
     static async confirm(message, defaultYes = false) {
-        const suffix = defaultYes ? 'Y/n' : 'y/N';
-        const ans = (await this.ask(`${message} ${Colors.FgGray}[${suffix}]${Colors.Reset}`)).toLowerCase();
-        if (ans === '')
+        const suffix = defaultYes ? "Y/n" : "y/N";
+        const ans = (await this.ask(`${message} ${Colors.Dim}${Colors.FgGray}[${suffix}]${Colors.Reset}`)).toLowerCase();
+        if (ans === "")
             return defaultYes;
-        return ['y', 'yes', 's', 'sim'].includes(ans);
+        return ["y", "yes", "s", "sim"].includes(ans);
     }
     static table(data) {
         let rows;
         if (Array.isArray(data)) {
-            rows = data.map(row => ({ Field: String(row.Field), Value: String(row.Value) }));
+            rows = data.map((row) => ({ Field: String(row.Field), Value: String(row.Value) }));
         }
         else {
             rows = Object.entries(data).map(([Field, Value]) => ({ Field, Value: String(Value) }));
         }
-        const fieldLen = Math.max(...rows.map(r => r.Field.length), 'Field'.length);
-        const valueLen = Math.max(...rows.map(r => r.Value.length), 'Value'.length);
-        const h_line = '─'.repeat(fieldLen + 2);
-        const v_line = '─'.repeat(valueLen + 2);
+        const fieldLen = Math.max(...rows.map((r) => r.Field.length), "Field".length);
+        const valueLen = Math.max(...rows.map((r) => r.Value.length), "Value".length);
+        const h_line = "─".repeat(fieldLen + 2);
+        const v_line = "─".repeat(valueLen + 2);
         const top = `┌${h_line}┬${v_line}┐`;
         const mid = `├${h_line}┼${v_line}┤`;
         const bottom = `└${h_line}┴${v_line}┘`;
-        let output = top + '\n';
-        output += `│ ${Colors.Bright}${Colors.FgCyan}${'Field'.padEnd(fieldLen)}${Colors.Reset} │ ${Colors.Bright}${Colors.FgCyan}${'Value'.padEnd(valueLen)}${Colors.Reset} │\n`;
-        output += mid + '\n';
+        const headFg = this.fg(120, 230, 255);
+        const headBg = this.bg(18, 56, 64);
+        let output = `${Colors.Dim}${Colors.FgGray}${top}${Colors.Reset}\n`;
+        output += `${Colors.Dim}${Colors.FgGray}│${Colors.Reset} ${headBg}${headFg}${Colors.Bright}${"Field".padEnd(fieldLen)}${Colors.Reset} ${Colors.Dim}${Colors.FgGray}│${Colors.Reset} ${headBg}${headFg}${Colors.Bright}${"Value".padEnd(valueLen)}${Colors.Reset} ${Colors.Dim}${Colors.FgGray}│${Colors.Reset}\n`;
+        output += `${Colors.Dim}${Colors.FgGray}${mid}${Colors.Reset}\n`;
         for (const row of rows) {
-            output += `│ ${row.Field.padEnd(fieldLen)} │ ${row.Value.padEnd(valueLen)} │\n`;
+            output += `${Colors.Dim}${Colors.FgGray}│${Colors.Reset} ${Colors.FgAlmostWhite}${row.Field.padEnd(fieldLen)}${Colors.Reset} ${Colors.Dim}${Colors.FgGray}│${Colors.Reset} ${Colors.FgAlmostWhite}${row.Value.padEnd(valueLen)}${Colors.Reset} ${Colors.Dim}${Colors.FgGray}│${Colors.Reset}\n`;
         }
-        output += bottom + '\n';
+        output += `${Colors.Dim}${Colors.FgGray}${bottom}${Colors.Reset}\n`;
         this.writeStatic(output);
     }
     static dynamicLine(initialContent) {
         return new DynamicLine(initialContent);
     }
     static registerDynamicLine(id, content) {
-        this.activeLines.push({ id, content });
-        this.redrawDynamicLines();
+        this.hook();
+        const formatted = this.formatLog("WAIT", content);
+        const rows = this.countRowsAdded(formatted + "\n");
+        this.writeStatic(formatted);
+        this.activeLines.set(id, { offset: rows });
     }
     static updateDynamicLine(id, newContent) {
-        const line = this.activeLines.find(l => l.id === id);
-        if (line) {
-            line.content = newContent;
-            this.redrawDynamicLines();
-        }
+        this.editLine(id, newContent, "WAIT");
     }
     static endDynamicLine(id, finalContent) {
-        const index = this.activeLines.findIndex(l => l.id === id);
-        if (index > -1) {
-            this.activeLines.splice(index, 1);
-            this.writeStatic(this.formatLog(Levels.SUCCESS, finalContent));
+        if (this.activeLines.has(id)) {
+            this.editLine(id, finalContent, Levels.SUCCESS);
+            this.activeLines.delete(id);
+        }
+    }
+    static editLine(id, content, level) {
+        const line = this.activeLines.get(id);
+        if (!line)
+            return;
+        const stream = process.stdout;
+        const formatted = this.formatLog(level, content);
+        this.isWriting = true;
+        try {
+            node_readline_1.default.moveCursor(stream, 0, -line.offset);
+            node_readline_1.default.clearLine(stream, 0);
+            node_readline_1.default.cursorTo(stream, 0);
+            stream.write(formatted + "\n");
+            const newRows = this.countRowsAdded(formatted + "\n");
+            const rowsToMoveDown = line.offset - newRows;
+            if (rowsToMoveDown > 0) {
+                node_readline_1.default.moveCursor(stream, 0, rowsToMoveDown);
+            }
+            else if (rowsToMoveDown < 0) {
+                node_readline_1.default.moveCursor(stream, 0, rowsToMoveDown);
+            }
+        }
+        catch (e) {
+            // ignore
         }
+        this.isWriting = false;
     }
 }
 exports.default = Console;

package/dist/api/native-server.js

@@ -24,7 +24,7 @@ class NativeServer {
         const platform = os_1.default.platform();
         const arch = os_1.default.arch();
         let osName = '';
-        let ext = '.node';
+        let ext = '.node'; // Mantido .node conforme solicitado
         switch (platform) {
             case 'win32':
                 osName = 'win';
@@ -55,15 +55,26 @@ class NativeServer {
     static loadLibrary(customPath) {
         if (this.lib)
             return;
-        const libPath = customPath || this.getLibPath();
+        // Alterado de const para let para permitir reatribuição se cair no fallback
+        let libPath = customPath || this.getLibPath();
         if (!fs_1.default.existsSync(libPath)) {
+            // Tenta resolver relativo ao CWD se não achar no __dirname
             const altPath = path_1.default.resolve(process.cwd(), libPath);
-            if (!fs_1.default.existsSync(altPath)) {
+            // Ou tenta buscar direto pelo nome do arquivo no CWD caso o path relativo esteja errado
+            const altPathSimple = path_1.default.resolve(process.cwd(), path_1.default.basename(libPath));
+            if (fs_1.default.existsSync(altPath)) {
+                libPath = altPath; // <--- AQUI ESTAVA O ERRO: Atualiza libPath para o caminho que existe
+            }
+            else if (fs_1.default.existsSync(altPathSimple)) {
+                libPath = altPathSimple; // <--- Fallback extra de segurança
+            }
+            else {
                 console.warn(`Native Server Library not found at: ${libPath}`);
                 return;
             }
         }
         try {
+            // Agora o koffi carrega o caminho correto (libPath atualizado)
             this.lib = koffi_1.default.load(libPath);
             // func StartServer(..., onData, onClose)
             this.startFunc = this.lib.func('StartServer', 'str', [
@@ -79,7 +90,7 @@ class NativeServer {
             this.closeConnFunc = this.lib.func('CloseConn', 'void', ['int']);
         }
         catch (error) {
-            throw new Error(`Failed to load native library: ${error}`);
+            throw new Error(`Failed to load native library at ${libPath}: ${error}`);
         }
     }
     static start(options) {
@@ -87,6 +98,16 @@ class NativeServer {
         this.loadLibrary(customLibPath);
         if (!this.startFunc)
             return;
+        // Validação de certificados SSL ANTES de iniciar
+        const useSSL = certPath && keyPath;
+        if (useSSL) {
+            if (!fs_1.default.existsSync(certPath)) {
+                throw new Error(`SSL Certificate file not found at: ${certPath}`);
+            }
+            if (!fs_1.default.existsSync(keyPath)) {
+                throw new Error(`SSL Key file not found at: ${keyPath}`);
+            }
+        }
         // Callback de DADOS: Agora recebe pointer e length
         const onDataPtr = koffi_1.default.register((connId, ptr, len) => {
             try {