bun-ui-tests 1.0.0

package/README.md

@@ -0,0 +1,115 @@
+# 🧪 Bun Test UI
+
+Uma interface visual moderna e bonita para rodar e visualizar seus testes Bun em tempo real.
+
+![Tests](https://img.shields.io/badge/tests-passing-blue)
+![Bun](https://img.shields.io/badge/bun-1.0+-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+## ✨ Features
+
+- 🎨 **Interface Moderna** - Design limpo com tema dark
+- ⚡ **Tempo Real** - Veja os testes rodando ao vivo via WebSocket
+- 🔍 **Busca Recursiva** - Encontra automaticamente todos os arquivos de teste no projeto
+- 📂 **Organização por Arquivo** - Testes agrupados por arquivo com expansão/colapso
+- ▶️ **Execução Seletiva** - Rode todos os testes, um arquivo específico, ou um teste individual
+- 📊 **Estatísticas** - Contador de testes passados, falhos e em execução
+- 🎯 **Suporte Completo** - Detecta `.test.ts`, `.spec.js`, `_test.tsx` e mais
+- 🚀 **Performance** - Backend compilado para máxima velocidade
+
+## 🚀 Instalação Rápida
+
+```bash
+# Clone o repositório
+git clone <repo-url>
+cd buntestui
+
+# Instale globalmente
+bun link
+
+# Builde o projeto
+buntestui build
+```
+
+## 📖 Uso
+
+### Em qualquer projeto com testes Bun:
+
+```bash
+cd ~/meu-projeto
+buntestui run
+```
+
+Abra seu navegador em **http://localhost:3000** e veja a mágica acontecer! ✨
+
+## 🎮 Comandos
+
+| Comando | Descrição |
+|---------|-----------|
+| `buntestui build` | Builda o frontend (Vite) e backend (executável) |
+| `buntestui run` | Inicia o Test UI em modo produção (usa arquivos buildados) |
+| `buntestui dev` | Inicia em modo desenvolvimento (hot reload) |
+| `buntestui help` | Mostra ajuda |
+
+## 📋 Padrões de Teste Suportados
+
+O Bun Test UI detecta automaticamente:
+
+- `*.test.ts` / `*.test.js` / `*.test.tsx` / `*.test.jsx`
+- `*.spec.ts` / `*.spec.js` / `*.spec.tsx` / `*.spec.jsx`
+- `*_test.ts` / `*_test.js` / `*_test.tsx` / `*_test.jsx`
+- `*_spec.ts` / `*_spec.js` / `*_spec.tsx` / `*_spec.jsx`
+
+## 🏗️ Arquitetura
+
+```
+┌─────────────┐         WebSocket         ┌─────────────┐
+│             │      (port 5060)          │             │
+│  Frontend   │◄─────────────────────────►│  Backend    │
+│  (React)    │                           │  (Bun)      │
+│  port 5050  │                           │             │
+└─────────────┘                           └─────────────┘
+                                                  │
+                                                  ▼
+                                          ┌──────────────┐
+                                          │  bun test    │
+                                          │  (spawned)   │
+                                          └──────────────┘
+```
+
+- **Frontend**: React + Vite + Tailwind CSS
+- **Backend**: Bun native WebSocket + process spawning
+- **Comunicação**: WebSocket em tempo real
+- **Compilado**: Executável standalone (~93MB)
+
+## 🎨 Interface
+
+A interface possui:
+
+- **Painel de Testes**: Lista de arquivos e testes com status visual
+- **Painel de Output**: Logs em tempo real com syntax highlighting
+- **Header**: Estatísticas e controles de execução
+- **Design Responsivo**: Funciona em mobile e desktop
+
+### Cores:
+
+- 🔵 **Azul**: Testes passando, status conectado
+- 🟢 **Verde**: Logs de sucesso `(pass)`
+- 🔴 **Vermelho**: Testes falhando, erros
+- 🟡 **Amarelo**: Testes em execução
+
+## 📚 Documentação Completa
+
+Veja [INSTALL.md](./INSTALL.md) para instruções detalhadas de instalação e uso.
+
+## 🤝 Contribuindo
+
+Contribuições são bem-vindas! Sinta-se livre para abrir issues e pull requests.
+
+## 📄 Licença
+
+MIT
+
+## 🙏 Agradecimentos
+
+Feito com ❤️ para a comunidade Bun

package/cli.ts

@@ -0,0 +1,197 @@
+#!/usr/bin/env bun
+
+import { spawn } from "node:child_process";
+import { readFile, access } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const COMMANDS = {
+  run: "Run the test UI (production mode)",
+  dev: "Run in development mode (hot reload)",
+  help: "Show this help message"
+};
+
+async function showHelp() {
+  console.log(`
+🧪 Bun Test UI - A beautiful UI for running Bun tests
+
+Usage:
+  buntestui <command>
+
+Commands:
+  run       Start the test UI (production mode)
+  dev       Start in development mode (hot reload enabled)
+  help      Show this help message
+
+Examples:
+  buntestui run      # Run in production mode
+  buntestui dev      # Run in development mode (for testing)
+`);
+}
+
+async function buildFrontend() {
+  console.log("🏗️  Building frontend...\n");
+  
+  const appDir = join(__dirname, "app");
+  
+  return new Promise<void>((resolve, reject) => {
+    const proc = spawn("bun", ["run", "build"], {
+      cwd: appDir,
+      stdio: "inherit",
+      shell: true
+    });
+    
+    proc.on("close", (code) => {
+      if (code === 0) {
+        console.log("\n✅ Frontend built successfully!");
+        resolve();
+      } else {
+        reject(new Error(`Frontend build failed with code ${code}`));
+      }
+    });
+    
+    proc.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+async function checkBuildExists(): Promise<boolean> {
+  try {
+    const distPath = join(__dirname, "app", "dist", "index.html");
+    await access(distPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function runTestUI() {
+  // Verifica se o build do frontend existe
+  const buildExists = await checkBuildExists();
+  
+  if (!buildExists) {
+    console.log("⚠️  Frontend assets not found.\n");
+    console.log("If you are running from source, please run: bun run build");
+    console.log("If you installed via npm, this might be a packaging issue.\n");
+    process.exit(1);
+  }
+  
+  console.log("🚀 Starting Bun Test UI (Production Mode)...\n");
+  console.log("📡 WebSocket server: ws://localhost:5050/ws");
+  console.log("🌐 Frontend: http://localhost:5050\n");
+  console.log("Press Ctrl+C to stop\n");
+  
+  // Roda o script do backend diretamente com Bun
+  // O usuário OBRIGATORIAMENTE tem Bun instalado para usar esta ferramenta
+  const runnerScript = join(__dirname, "ui-runner.ts");
+  
+  const proc = spawn("bun", ["run", runnerScript], {
+    cwd: process.cwd(), // Roda no diretório atual do usuário
+    stdio: "inherit",
+    shell: false,
+    env: { ...process.env, NODE_ENV: "production" }
+  });
+  
+  proc.on("close", (code) => {
+    if (code !== 0) {
+      console.error(`\n❌ Process exited with code ${code}`);
+      process.exit(code || 1);
+    }
+  });
+  
+  proc.on("error", (err) => {
+    console.error("❌ Error starting test UI:", err);
+    process.exit(1);
+  });
+  
+  // Handle Ctrl+C
+  process.on("SIGINT", () => {
+    console.log("\n\n👋 Stopping Bun Test UI...");
+    proc.kill("SIGINT");
+    process.exit(0);
+  });
+}
+
+async function runDevMode() {
+  console.log("🚀 Starting Bun Test UI (Development Mode)...\n");
+  console.log("📡 WebSocket server: ws://localhost:5060");
+  console.log("🌐 Frontend: http://localhost:5050 (with hot reload)\n");
+  console.log("Press Ctrl+C to stop\n");
+  
+  // Inicia o backend (ui-runner.ts) com bun run e flag de dev mode
+  const backendPath = join(__dirname, "ui-runner.ts");
+  const backendProc = spawn("bun", ["run", backendPath], {
+    cwd: process.cwd(),
+    stdio: "inherit",
+    shell: true,
+    env: { ...process.env, BUN_TEST_UI_DEV: "true" }
+  });
+  
+  // Aguarda um pouco para o backend iniciar
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  
+  // Inicia o frontend em modo dev
+  const appDir = join(__dirname, "app");
+  const frontendProc = spawn("bun", ["run", "dev"], {
+    cwd: appDir,
+    stdio: "inherit",
+    shell: true
+  });
+  
+  // Handle Ctrl+C
+  process.on("SIGINT", () => {
+    console.log("\n\n👋 Stopping Bun Test UI...");
+    backendProc.kill("SIGINT");
+    frontendProc.kill("SIGINT");
+    process.exit(0);
+  });
+  
+  // Se um processo terminar, termina o outro também
+  backendProc.on("close", (code) => {
+    console.log("\n❌ Backend stopped");
+    frontendProc.kill("SIGINT");
+    process.exit(code || 1);
+  });
+  
+  frontendProc.on("close", (code) => {
+    console.log("\n❌ Frontend stopped");
+    backendProc.kill("SIGINT");
+    process.exit(code || 1);
+  });
+}
+
+// Main
+const command = process.argv[2];
+
+switch (command) {
+  case "run":
+    runTestUI()
+      .catch((err) => {
+        console.error("❌ Failed to start:", err);
+        process.exit(1);
+      });
+    break;
+    
+  case "dev":
+    runDevMode()
+      .catch((err) => {
+        console.error("❌ Failed to start dev mode:", err);
+        process.exit(1);
+      });
+    break;
+    
+  case "help":
+  case undefined:
+    showHelp();
+    process.exit(0);
+    break;
+    
+  default:
+    console.error(`❌ Unknown command: ${command}\n`);
+    showHelp();
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "bun-ui-tests",
+  "version": "1.0.0",
+  "description": "A beautiful UI for running Bun tests",
+  "type": "module",
+  "bin": {
+    "buntestui": "cli.ts"
+  },
+  "files": [
+    "cli.ts",
+    "ui-runner.ts",
+    "app/dist"
+  ],
+  "scripts": {
+    "dev": "bun run ui-runner.ts",
+    "prepublishOnly": "cd app && bun install && bun run build"
+  },
+  "keywords": [
+    "bun",
+    "test",
+    "ui",
+    "testing",
+    "runner"
+  ],
+  "author": "killd",
+  "license": "MIT"
+}

package/ui-runner.ts

@@ -0,0 +1,597 @@
+/**
+ * UI Runner for Bun Test
+ * 
+ * Este runner NÃO usa APIs internas do bun:test (que não existem publicamente).
+ * Ele apenas spawna um processo `bun test` e faz parsing do stdout/stderr.
+ * 
+ * Arquitetura:
+ * - Spawna `bun test` como processo filho
+ * - Captura stdout/stderr em tempo real
+ * - Faz parsing básico da saída (✓, ✗, nomes de testes)
+ * - Emite eventos via WebSocket para a UI
+ */
+
+import { spawn } from "node:child_process";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join, relative, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+
+// Determina o diretório do executável ou script
+const getBaseDir = () => {
+  // Se rodando como executável compilado, pega o diretório onde o CLI foi instalado
+  // O executável fica na raiz do pacote, então app/dist fica relativo a ele
+  if (import.meta.path && !import.meta.path.endsWith('.ts')) {
+    // É um executável compilado - usa process.execPath (path real do executável)
+    // import.meta.path retorna um path virtual do bunfs
+    return dirname(process.execPath);
+  }
+  // Se rodando como script .ts em dev, usa o dirname do próprio arquivo
+  const __filename = fileURLToPath(import.meta.url);
+  return dirname(__filename);
+};
+
+const baseDir = getBaseDir();
+const distPath = join(baseDir, "app", "dist");
+const isDevMode = process.env.BUN_TEST_UI_DEV === "true";
+
+// WebSocket Handler (lógica compartilhada)
+const websocketHandler = {
+  async open(ws: any) {
+    console.log("✓ UI connected");
+    
+    // Escaneia arquivos de teste
+    const testFiles = await scanTestFiles();
+    
+    // Escaneia todos os testes de cada arquivo
+    console.log("📖 Reading test files to extract test names...");
+    const testsMap = await scanAllTests();
+    
+    // Envia evento de conexão com lista de arquivos e testes
+    ws.send(JSON.stringify({
+      type: "connected",
+      payload: { 
+        message: "Runner ready",
+        testFiles,
+        testsMap // { "test/example.test.ts": ["test1", "test2", ...] }
+      }
+    }));
+    
+    console.log(`✓ Found ${testFiles.length} test files with ${Object.values(testsMap).flat().length} tests total`);
+  },
+  message(ws: any, message: any) {
+    try {
+      const data = JSON.parse(message.toString());
+      console.log('📨 [WEBSOCKET] Mensagem recebida:', data.type, data.payload);
+      
+      // Processa comandos da UI
+      if (data.type === "run:request") {
+        const file = data.payload?.file;
+        const testName = data.payload?.testName;
+        
+        console.log('▶️ [RUN REQUEST] file:', file, 'testName:', testName);
+        
+        if (testName) {
+          console.log(`Running specific test: ${testName} in ${file}`);
+        } else if (file) {
+          console.log(`Running file: ${file}`);
+        } else {
+          console.log("Running all tests");
+        }
+        
+        runTests(ws, file, testName);
+      } else {
+        console.log('⚠️ [WEBSOCKET] Tipo desconhecido:', data.type);
+      }
+    } catch (err) {
+      console.error("Error processing message:", err);
+    }
+  },
+  close(ws: any) {
+    console.log("✗ UI disconnected");
+  },
+};
+
+if (isDevMode) {
+  // === MODO DESENVOLVIMENTO ===
+  // Frontend roda via Vite na porta 5050
+  // Backend roda separadamente na porta 5060 (apenas WS)
+  
+  Bun.serve({
+    port: 5060,
+    fetch(req, server) {
+      // Aceita upgrade em qualquer path ou especificamente /ws
+      if (server.upgrade(req)) {
+        return; 
+      }
+      return new Response("Bun Test UI Backend (Dev Mode)", { status: 200 });
+    },
+    websocket: websocketHandler
+  });
+  
+  console.log("📡 WebSocket server running on ws://localhost:5060");
+  
+} else {
+  // === MODO PRODUÇÃO ===
+  // Servidor ÚNICO na porta 5050
+  // Serve arquivos estáticos do frontend E WebSocket no mesmo endpoint
+  
+  const PORT = 5050;
+  
+  Bun.serve({
+    port: PORT,
+    async fetch(req, server) {
+      const url = new URL(req.url);
+      
+      // 1. WebSocket Upgrade (/ws)
+      if (url.pathname === "/ws") {
+        if (server.upgrade(req)) {
+          return;
+        }
+        return new Response("WebSocket upgrade failed", { status: 400 });
+      }
+      
+      // 2. Arquivos Estáticos (Frontend)
+      if (existsSync(distPath)) {
+        let filePath = url.pathname === "/" ? "/index.html" : url.pathname;
+        const fullPath = join(distPath, filePath);
+        
+        try {
+          const file = Bun.file(fullPath);
+          if (await file.exists()) {
+            return new Response(file);
+          }
+          
+          // Se não encontrou o arquivo e não é um asset (SPA fallback)
+          if (!filePath.includes(".")) {
+            const indexFile = Bun.file(join(distPath, "index.html"));
+            return new Response(indexFile);
+          }
+        } catch (err) {
+          console.error("Error serving file:", err);
+        }
+      } else {
+        return new Response("Frontend build not found. Run 'buntestui build' first.", { status: 404 });
+      }
+      
+      return new Response("Not found", { status: 404 });
+    },
+    websocket: websocketHandler
+  });
+  
+  console.log(`🚀 Server running on http://localhost:${PORT}`);
+  console.log(`📡 WebSocket endpoint available at ws://localhost:${PORT}/ws`);
+}
+
+
+/**
+ * Escaneia recursivamente todo o projeto e retorna lista de arquivos de teste
+ * Suporta os padrões do Bun: .test.ts, .test.js, .test.tsx, .test.jsx, _test.ts, _test.js, etc
+ */
+async function scanTestFiles(): Promise<string[]> {
+  const testFiles: string[] = [];
+  const rootDir = process.cwd();
+  
+  // Pastas a ignorar durante a busca recursiva
+  const ignoreDirs = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    '.next',
+    '.svelte-kit',
+    'coverage',
+    '.turbo',
+    '.cache',
+    'out',
+    '.vercel',
+    '.netlify'
+  ]);
+  
+  // Padrões de arquivos de teste suportados pelo Bun
+  const testPatterns = [
+    /\.test\.(ts|tsx|js|jsx)$/,     // file.test.ts, file.test.js, etc
+    /\.spec\.(ts|tsx|js|jsx)$/,     // file.spec.ts, file.spec.js, etc
+    /_test\.(ts|tsx|js|jsx)$/,      // file_test.ts, file_test.js, etc
+    /_spec\.(ts|tsx|js|jsx)$/,      // file_spec.ts, file_spec.js, etc
+  ];
+  
+  async function scanDirectory(dir: string): Promise<void> {
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        
+        if (entry.isDirectory()) {
+          // Ignora diretórios na lista de ignorados
+          if (!ignoreDirs.has(entry.name)) {
+            await scanDirectory(fullPath);
+          }
+        } else if (entry.isFile()) {
+          // Verifica se o arquivo corresponde a algum padrão de teste
+          if (testPatterns.some(pattern => pattern.test(entry.name))) {
+            // Retorna path relativo ao diretório raiz
+            const relativePath = relative(rootDir, fullPath);
+            testFiles.push(relativePath);
+          }
+        }
+      }
+    } catch (err) {
+      // Ignora erros de leitura de diretórios (permissões, etc)
+      console.error(`Error scanning directory ${dir}:`, err);
+    }
+  }
+  
+  await scanDirectory(rootDir);
+  
+  // Ordena os arquivos alfabeticamente
+  testFiles.sort();
+  
+  return testFiles;
+}
+
+/**
+ * Extrai os nomes dos testes de um arquivo sem executá-lo
+ * Faz parsing do código para encontrar test(), it() e describe()
+ */
+async function extractTestsFromFile(filePath: string): Promise<string[]> {
+  try {
+    const fullPath = join(process.cwd(), filePath);
+    const content = await readFile(fullPath, "utf-8");
+    const tests: string[] = [];
+    
+    // Regex para capturar test("nome"), it("nome"), describe("nome")
+    // Suporta aspas simples e duplas
+    const testRegex = /(?:test|it|describe)\s*\(\s*[`"'](.+?)[`"']/g;
+    
+    let match;
+    while ((match = testRegex.exec(content)) !== null) {
+      tests.push(match[1]);
+    }
+    
+    return tests;
+  } catch (err) {
+    console.error(`Error reading file ${filePath}:`, err);
+    return [];
+  }
+}
+
+/**
+ * Escaneia todos os arquivos e retorna um mapa de arquivo -> testes
+ */
+async function scanAllTests(): Promise<Record<string, string[]>> {
+  const testFiles = await scanTestFiles();
+  const testsMap: Record<string, string[]> = {};
+  
+  for (const file of testFiles) {
+    const tests = await extractTestsFromFile(file);
+    testsMap[file] = tests;
+  }
+  
+  return testsMap;
+}
+
+/**
+ * Executa bun test e faz parsing da saída
+ * @param ws WebSocket connection
+ * @param file Arquivo específico para testar (opcional)
+ * @param testName Nome do teste específico (opcional, requer file)
+ */
+function runTests(ws: any, file?: string, testName?: string) {
+  const args = ["test"];
+  
+  if (file) {
+    args.push(file);
+  }
+  
+  // Bun suporta --test-name-pattern para filtrar testes
+  // Escapa caracteres especiais de regex e usa o nome exato
+  if (testName) {
+    // Escapa caracteres especiais de regex
+    const escapedName = testName.replace(/[.*+?^${}()|[\\]/g, '\\$&');
+    args.push("--test-name-pattern", escapedName);
+  }
+  
+  console.log('🚀 [RUN] Comando:', `bun ${args.join(" ")}`);
+  console.log(`Starting bun test ${args.slice(1).join(" ") || "(all)"}...`);
+  
+  // Emite evento de início
+  ws.send(JSON.stringify({
+    type: "run:start",
+    payload: { 
+      timestamp: Date.now(),
+      file: file || null,
+      testName: testName || null
+    }
+  }));
+  
+  // Spawna o processo bun test
+  // IMPORTANTE: Não usamos nenhuma API interna do bun:test
+  const bunTest = spawn("bun", args, {
+    cwd: process.cwd(),
+    env: { ...process.env, FORCE_COLOR: "0" }, // Desabilita cores para facilitar parsing
+  });
+  
+  let currentTestFile = "";
+  let buffer = "";
+  let errorBlock: string[] = [];  // Acumula linhas de erro
+  let summaryBlock: string[] = []; // Acumula linhas de resumo
+  let inErrorBlock = false;
+  let inSummaryBlock = false;
+  
+  // Função para verificar se é linha de bloco de erro
+  const isErrorLine = (line: string): boolean => {
+    const trimmed = line.trim();
+    // Linha que é só espaços seguidos de ^ (indicador de erro)
+    const hasErrorPointer = /^\s*\^/.test(line);
+    
+    return (
+      /^\d+\s*\|/.test(trimmed) ||       // Linha de código: "72 |"
+      trimmed.startsWith('error:') ||     // "error: expect..."
+      trimmed.startsWith('Expected:') ||  // "Expected: 3"
+      trimmed.startsWith('Received:') ||  // "Received: 2"
+      trimmed.includes('at <anonymous>') || // Stack trace
+      hasErrorPointer ||                  // Seta de erro "      ^"
+      /^\s+at\s/.test(line) ||            // "    at ..." stack trace
+      trimmed.startsWith('(fail)')        // Linha de fail - FAZ PARTE DO BLOCO!
+    );
+  };
+  
+  // Função para verificar se é linha de resumo
+  const isSummaryLine = (line: string): boolean => {
+    const trimmed = line.trim();
+    return (
+      /^\d+\s+pass$/.test(trimmed) ||               // "19 pass"
+      /^\d+\s+fail$/.test(trimmed) ||               // "1 fail"
+      /^\d+\s+expect\(\)\s+calls/.test(trimmed) ||  // "33 expect() calls"
+      /^Ran\s+\d+/.test(trimmed)                    // "Ran 20 tests..."
+    );
+  };
+  
+  // Função para enviar bloco de erro
+  const flushErrorBlock = () => {
+    if (errorBlock.length > 0) {
+      console.log('📦 [ERROR BLOCK] Enviando bloco com', errorBlock.length, 'linhas:');
+      console.log('---START---');
+      console.log(errorBlock.join('\n'));
+      console.log('---END---');
+      
+      ws.send(JSON.stringify({
+        type: "log",
+        payload: { message: errorBlock.join('\n'), stream: "stdout" }
+      }));
+      errorBlock = [];
+      inErrorBlock = false;
+    }
+  };
+  
+  // Função para enviar bloco de resumo
+  const flushSummaryBlock = () => {
+    if (summaryBlock.length > 0) {
+      console.log('📊 [SUMMARY BLOCK] Enviando bloco com', summaryBlock.length, 'linhas:');
+      console.log('---START---');
+      console.log(summaryBlock.join('\n'));
+      console.log('---END---');
+      
+      ws.send(JSON.stringify({
+        type: "log",
+        payload: { message: summaryBlock.join('\n'), stream: "stdout" }
+      }));
+      summaryBlock = [];
+      inSummaryBlock = false;
+    }
+  };
+  
+  // Processa stdout linha por linha
+  bunTest.stdout.on("data", (data) => {
+    const text = data.toString();
+    buffer += text;
+    
+    // Processa linhas completas
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || ""; // Guarda última linha incompleta
+    
+    for (const line of lines) {
+      currentTestFile = processLine(line, ws, currentTestFile);
+      
+      // Linhas vazias podem fazer parte de blocos
+      const trimmed = line.trim();
+      
+      // Verifica se é linha de erro
+      if (isErrorLine(line)) {
+        console.log('🔴 [ERROR LINE] Detectado:', line.substring(0, 50));
+        // Se estava no resumo, envia o resumo primeiro
+        flushSummaryBlock();
+        
+        inErrorBlock = true;
+        errorBlock.push(line);
+        continue;
+      }
+      
+      // Linha vazia dentro de bloco de erro - mantém no bloco
+      if (inErrorBlock && !trimmed) {
+        console.log('🔴 [ERROR EMPTY] Linha vazia no bloco de erro');
+        errorBlock.push(line);
+        continue;
+      }
+      
+      // Verifica se é linha de resumo
+      if (isSummaryLine(line)) {
+        console.log('📊 [SUMMARY LINE] Detectado:', line.substring(0, 50));
+        // Se estava no erro, envia o erro primeiro
+        flushErrorBlock();
+        
+        inSummaryBlock = true;
+        summaryBlock.push(line);
+        continue;
+      }
+      
+      // Linha normal - envia blocos pendentes e depois a linha
+      flushErrorBlock();
+      flushSummaryBlock();
+      
+      // Envia linhas normais separadamente (se não vazia)
+      if (trimmed) {
+        console.log('📝 [NORMAL LINE] Enviando:', line.substring(0, 50));
+        ws.send(JSON.stringify({
+          type: "log",
+          payload: { message: line, stream: "stdout" }
+        }));
+      }
+    }
+  });
+  
+  bunTest.stderr.on("data", (data) => {
+    const text = data.toString();
+    
+    // Envia stderr linha por linha também
+    const lines = text.split("\n").filter(line => line.trim());
+    for (const line of lines) {
+      ws.send(JSON.stringify({
+        type: "log",
+        payload: { message: line, stream: "stderr" }
+      }));
+    }
+  });
+  
+  bunTest.on("close", (code) => {
+    console.log(`bun test exited with code ${code}`);
+    
+    // Processa buffer pendente antes de finalizar
+    if (buffer.trim()) {
+      console.log('⚠️ [CLOSE] Buffer pendente:', buffer.substring(0, 100));
+      const lines = buffer.split("\n");
+      for (const line of lines) {
+        if (line.trim()) {
+          currentTestFile = processLine(line, ws, currentTestFile);
+          
+          const trimmed = line.trim();
+          
+          if (isErrorLine(line)) {
+            inErrorBlock = true;
+            errorBlock.push(line);
+          } else if (inErrorBlock && !trimmed) {
+            errorBlock.push(line);
+          } else if (isSummaryLine(line)) {
+            flushErrorBlock();
+            inSummaryBlock = true;
+            summaryBlock.push(line);
+          } else {
+            flushErrorBlock();
+            flushSummaryBlock();
+            ws.send(JSON.stringify({
+              type: "log",
+              payload: { message: line, stream: "stdout" }
+            }));
+          }
+        }
+      }
+    }
+    
+    // Envia blocos pendentes antes de finalizar
+    flushErrorBlock();
+    flushSummaryBlock();
+    
+    console.log('✅ [CLOSE] Processo finalizado, todos os logs enviados');
+    
+    ws.send(JSON.stringify({
+      type: "run:complete",
+      payload: { 
+        exitCode: code,
+        timestamp: Date.now()
+      }
+    }));
+  });
+  
+  bunTest.on("error", (error) => {
+    console.error("Error running bun test:", error);
+    
+    ws.send(JSON.stringify({
+      type: "error",
+      payload: { message: error.message }
+    }));
+  });
+}
+
+/**
+ * Faz parsing de uma linha de saída do bun test
+ * 
+ * Formatos esperados (baseado na saída real do bun test):
+ * - ✓ test name [0.00ms]
+ * - ✗ test name [0.00ms]
+ * - test/file.test.ts:
+ * 
+ * @returns O currentTestFile atualizado
+ */
+function processLine(line: string, ws: any, currentTestFile: string): string {
+  const trimmed = line.trim();
+  
+  if (!trimmed) return currentTestFile;
+  
+  // Detecta arquivo de teste (com suporte a todos os padrões)
+  if (trimmed.match(/\.(test|spec)\.(ts|js|tsx|jsx):/) || trimmed.match(/_(test|spec)\.(ts|js|tsx|jsx):/)) {
+    const filePath = trimmed.replace(":", "");
+    
+    // Envia quebra de linha antes do nome do arquivo para separar visualmente
+    ws.send(JSON.stringify({
+      type: "log",
+      payload: { message: "", stream: "stdout" }
+    }));
+    
+    ws.send(JSON.stringify({
+      type: "file:start",
+      payload: { filePath }
+    }));
+    return filePath; // Atualiza o arquivo atual
+  }
+  
+  // Detecta teste que passou - formato: (pass) test name [0.00ms]
+  const passMatch = trimmed.match(/^\(pass\)\s+(.+?)\s+\[(.+?)\]/);
+  if (passMatch) {
+    const [, testName, duration] = passMatch;
+    
+    ws.send(JSON.stringify({
+      type: "test:pass",
+      payload: {
+        testName: testName.trim(),
+        duration: duration.trim(),
+        timestamp: Date.now(),
+        filePath: currentTestFile
+      }
+    }));
+    return currentTestFile;
+  }
+  
+  // Detecta teste que falhou - formato: (fail) test name [0.00ms]
+  const failMatch = trimmed.match(/^\(fail\)\s+(.+?)(?:\s+\[(.+?)\])?/);
+  if (failMatch) {
+    const [, testName, duration] = failMatch;
+    
+    ws.send(JSON.stringify({
+      type: "test:fail",
+      payload: {
+        testName: testName.trim(),
+        duration: duration?.trim() || "N/A",
+        timestamp: Date.now(),
+        filePath: currentTestFile
+      }
+    }));
+    return currentTestFile;
+  }
+  
+  // Detecta início de teste (quando aparece sem ✓ ou ✗)
+  // Isso pode variar dependendo da versão do Bun
+  if (trimmed.match(/^(test|it|describe)\s/)) {
+    ws.send(JSON.stringify({
+      type: "test:start",
+      payload: {
+        testName: trimmed,
+        timestamp: Date.now(),
+        filePath: currentTestFile
+      }
+    }));
+  }
+  
+  return currentTestFile;
+}